/** * `plugins build` — Phase 06 #23 — orchestrate the wasm build. * * The actual ts→wasm compilation is operator-toolchain-specific (the * supported chains today are AssemblyScript via `asc`, TinyGo via * `tinygo build -target=wasi`, and Rust via `cargo build --target * wasm32-wasi`). The CLI is intentionally pure orchestration: it * detects which toolchain the plugin is using by reading its * package.json / Cargo.toml / asconfig.json and prints the canonical * build command to run. When no toolchain marker is found, the command * surfaces a clear next-step rather than guessing. * * Why no auto-exec: spawning a heterogeneous compiler chain from this * CLI silently hides errors and surprises authors with global-binary * dependencies. Printing the command keeps the build path transparent * and lets CI scripts wire it in their own way. */ import { defineCommand } from "citty"; import consola from "consola"; import { readFile, stat } from "node:fs/promises"; import { join, resolve } from "node:path"; export type DetectedToolchain = "assemblyscript" | "tinygo" | "rust-cargo" | "unknown"; export interface DetectToolchainInput { readonly cwd: string; readonly readFile: (p: string) => Promise; readonly exists: (p: string) => Promise; } export async function detectToolchain(input: DetectToolchainInput): Promise { if (await input.exists(join(input.cwd, "asconfig.json"))) { return "assemblyscript"; } if (await input.exists(join(input.cwd, "Cargo.toml"))) { return "rust-cargo"; } if (await input.exists(join(input.cwd, "go.mod"))) { return "tinygo"; } // Also accept package.json with AS / wasi deps. if (await input.exists(join(input.cwd, "package.json"))) { try { const pkg = JSON.parse(await input.readFile(join(input.cwd, "package.json"))) as Record; const deps = { ...((pkg.dependencies as Record | undefined) ?? {}), ...((pkg.devDependencies as Record | undefined) ?? {}), }; if (typeof deps["assemblyscript"] === "string") { return "assemblyscript"; } } catch { // Fall through to unknown. } } return "unknown"; } export function buildCommandForToolchain( toolchain: DetectedToolchain, options: { output: string } ): { command: string; description: string } { switch (toolchain) { case "assemblyscript": return { command: `npx asc src/index.ts --target release --outFile ${options.output}`, description: "AssemblyScript via `asc` (release target).", }; case "tinygo": return { command: `tinygo build -target=wasi -o ${options.output} ./...`, description: "TinyGo with the wasi target.", }; case "rust-cargo": return { command: `cargo build --release --target wasm32-wasi && cp target/wasm32-wasi/release/*.wasm ${options.output}`, description: "Rust via cargo + wasm32-wasi target.", }; case "unknown": default: return { command: "", description: "No toolchain marker (asconfig.json / Cargo.toml / go.mod) detected.", }; } } export const pluginsBuildCommand = defineCommand({ meta: { name: "build", description: "Detect the plugin's wasm toolchain and print the canonical build command.", }, args: { cwd: { type: "string", description: "Plugin source directory (default: process cwd)." }, output: { type: "string", description: "Output wasm filename (default: plugin.wasm)." }, }, async run({ args }) { const cwd = args.cwd ? resolve(String(args.cwd)) : process.cwd(); const output = args.output ? String(args.output) : "plugin.wasm"; const toolchain = await detectToolchain({ cwd, readFile: async (p) => await readFile(p, "utf8"), exists: async (p) => { try { await stat(p); return true; } catch { return false; } }, }); const { command, description } = buildCommandForToolchain(toolchain, { output }); consola.info(`Detected toolchain: ${toolchain} (${description})`); consola.log(command); if (toolchain === "unknown") { process.exitCode = 1; } }, });