@stigmer/cli 3.18.1-dev.20260919070736 → 3.19.1-dev.20260920100552

package/src/resources/apply/synth/runtime.ts

@@ -1,39 +0,0 @@
-// Runtime inference for SDK project synthesis.
-//
-// A project's `entry_point` extension determines which language runtime executes
-// it — there is no explicit `runtime` field (the proto enum was removed; the
-// extension is the single source of truth). Port of the Go CLI's
-// `internal/cli/apply/runtime.go`; the extension table is kept in lockstep with
-// the backend's `supportedEntryPointExtensions` (project validator).
-
-import { extname } from "node:path";
-import { UsageError } from "../../../errors/index.js";
-
-/** Language runtime used to execute an SDK entry point. */
-export type Runtime = "go" | "python" | "node";
-
-// Extension → runtime. Keep in sync with the backend project validator and Go's
-// extensionToRuntime.
-const EXTENSION_TO_RUNTIME: ReadonlyMap<string, Runtime> = new Map([
-  [".go", "go"],
-  [".py", "python"],
-  [".ts", "node"],
-  [".js", "node"],
-  [".mts", "node"],
-  [".mjs", "node"],
-]);
-
-/**
- * Infer the runtime from an entry point's file extension. Throws a UsageError
- * listing the supported extensions when the extension is unrecognized.
- */
-export function inferRuntime(entryPoint: string): Runtime {
-  const ext = extname(entryPoint).toLowerCase();
-  const runtime = EXTENSION_TO_RUNTIME.get(ext);
-  if (runtime !== undefined) return runtime;
-
-  const supported = [...EXTENSION_TO_RUNTIME.keys()].join(", ");
-  throw new UsageError(
-    `cannot infer runtime from entry point '${entryPoint}' (extension '${ext}')\n\n` + `Supported extensions: ${supported}`,
-  );
-}

package/src/resources/apply/synth/synthesize.test.ts

@@ -1,109 +0,0 @@
-// Synthesize orchestration with an injected spawn: asserts the env/cwd/command
-// handed to the subprocess, the per-runtime command choice, the `.stigmer`
-// output dir, and the actionable errors on non-zero exit / spawn failure /
-// missing inputs.
-
-import { existsSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { isAbsolute, join } from "node:path";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { runtimeCommand, type SpawnFn, synthesize } from "./synthesize.js";
-
-let dir: string;
-
-beforeEach(() => {
-  dir = mkdtempSync(join(tmpdir(), "synth-exec-"));
-  writeFileSync(join(dir, "index.ts"), "// entry");
-});
-
-afterEach(() => {
-  rmSync(dir, { recursive: true, force: true });
-});
-
-const ok: SpawnFn = async () => ({ exitCode: 0, stdout: "done", stderr: "" });
-const noPrepare = () => {};
-
-describe("synthesize", () => {
-  it("spawns the entry point with the synthesis env and cwd, creating .stigmer", async () => {
-    const calls: Array<{ command: string; args: readonly string[]; cwd: string; env: NodeJS.ProcessEnv }> = [];
-    const spawn: SpawnFn = async (command, args, options) => {
-      calls.push({ command, args, cwd: options.cwd, env: options.env });
-      return { exitCode: 0, stdout: "", stderr: "" };
-    };
-
-    const result = await synthesize(
-      { projectDir: dir, entryPoint: "index.ts", runtime: "node", orgId: "acme" },
-      { spawn, prepare: noPrepare },
-    );
-
-    expect(calls).toHaveLength(1);
-    expect(calls[0].command).toBe("npx");
-    // The entry is passed as an absolute path (npx ignores cwd for relative).
-    expect(calls[0].args[0]).toBe("tsx");
-    expect(isAbsolute(calls[0].args[1])).toBe(true);
-    expect(calls[0].args[1].endsWith("/index.ts")).toBe(true);
-    expect(calls[0].cwd).toBe(result.outputDir.replace(/\/\.stigmer$/, ""));
-    expect(calls[0].env.STIGMER_OUT_DIR).toBe(result.outputDir);
-    expect(calls[0].env.STIGMER_ORG_ID).toBe("acme");
-    expect(result.outputDir.endsWith("/.stigmer")).toBe(true);
-    expect(existsSync(result.outputDir)).toBe(true);
-  });
-
-  it("omits STIGMER_ORG_ID when no org is given", async () => {
-    let env: NodeJS.ProcessEnv = {};
-    const spawn: SpawnFn = async (_c, _a, options) => {
-      env = options.env;
-      return { exitCode: 0, stdout: "", stderr: "" };
-    };
-    await synthesize({ projectDir: dir, entryPoint: "index.ts", runtime: "node", orgId: "" }, { spawn, prepare: noPrepare });
-    expect(env.STIGMER_ORG_ID).toBeUndefined();
-  });
-
-  it("maps a non-zero exit to an actionable error with stderr and guidance", async () => {
-    const spawn: SpawnFn = async () => ({ exitCode: 1, stdout: "", stderr: "ReferenceError: boom" });
-    await expect(
-      synthesize({ projectDir: dir, entryPoint: "index.ts", runtime: "node", orgId: "" }, { spawn, prepare: noPrepare }),
-    ).rejects.toThrow(/SDK synthesis failed:[\s\S]*ReferenceError: boom[\s\S]*npm install/);
-  });
-
-  it("maps a spawn failure (missing binary) to an actionable error", async () => {
-    const spawn: SpawnFn = async () => {
-      throw new Error("spawn npx ENOENT");
-    };
-    await expect(
-      synthesize({ projectDir: dir, entryPoint: "index.ts", runtime: "node", orgId: "" }, { spawn, prepare: noPrepare }),
-    ).rejects.toThrow(/SDK synthesis failed:[\s\S]*spawn npx ENOENT/);
-  });
-
-  it("rejects a missing entry point before spawning", async () => {
-    const spawn = vi.fn(ok);
-    await expect(
-      synthesize({ projectDir: dir, entryPoint: "missing.ts", runtime: "node", orgId: "" }, { spawn, prepare: noPrepare }),
-    ).rejects.toThrow(/entry point not found/);
-    expect(spawn).not.toHaveBeenCalled();
-  });
-
-  it("rejects a missing project directory", async () => {
-    await expect(
-      synthesize({ projectDir: join(dir, "nope"), entryPoint: "index.ts", runtime: "node", orgId: "" }, { spawn: ok }),
-    ).rejects.toThrow(/project directory not found/);
-  });
-
-  it("enforces node readiness via the default prepare (node_modules missing)", async () => {
-    writeFileSync(join(dir, "package.json"), "{}");
-    await expect(
-      synthesize({ projectDir: dir, entryPoint: "index.ts", runtime: "node", orgId: "" }, { spawn: ok }),
-    ).rejects.toThrow(/node_modules not found/);
-  });
-});
-
-describe("runtimeCommand", () => {
-  it("chooses the runner per runtime and extension", () => {
-    expect(runtimeCommand("go", "main.go")).toEqual(["go", "run", "main.go"]);
-    expect(runtimeCommand("python", "main.py")).toEqual(["python3", "main.py"]);
-    expect(runtimeCommand("node", "index.ts")).toEqual(["npx", "tsx", "index.ts"]);
-    expect(runtimeCommand("node", "index.mts")).toEqual(["npx", "tsx", "index.mts"]);
-    expect(runtimeCommand("node", "index.js")).toEqual(["node", "index.js"]);
-    expect(runtimeCommand("node", "index.mjs")).toEqual(["node", "index.mjs"]);
-  });
-});

package/src/resources/apply/synth/synthesize.ts

@@ -1,161 +0,0 @@
-// SDK synthesis execution.
-//
-// Runs a project's `entry_point` as a subprocess with `STIGMER_OUT_DIR` (and
-// `STIGMER_ORG_ID`) set; the program writes `.pb` files into that dir, which the
-// reader then decodes. Uniform subprocess model for every runtime (DD-009 §5):
-//   go      → `go run <entry>`
-//   python  → `python3 <entry>`
-//   node    → `npx tsx <entry>` for TS, `node <entry>` for JS
-//
-// `tsx` (not Go's `ts-node`) executes TypeScript entries — it is the runner the
-// CLI ecosystem already standardizes on (DD-009 alternatives). The spawn is
-// injected so the orchestration is unit-testable without a real subprocess
-// (mirrors `connect/oauth.ts`). Port of `internal/cli/apply/synthesize.go`.
-
-import { spawn } from "node:child_process";
-import { existsSync, mkdirSync } from "node:fs";
-import { extname, join, resolve } from "node:path";
-import { UsageError } from "../../../errors/index.js";
-import type { Runtime } from "./runtime.js";
-
-/** Result of running a subprocess to completion. */
-export interface SpawnResult {
-  readonly exitCode: number;
-  readonly stdout: string;
-  readonly stderr: string;
-}
-
-/** A function that runs a command to completion (injectable for tests). */
-export type SpawnFn = (
-  command: string,
-  args: readonly string[],
-  options: { readonly cwd: string; readonly env: NodeJS.ProcessEnv },
-) => Promise<SpawnResult>;
-
-/** Inputs for one synthesis run. */
-export interface SynthesizeOptions {
-  /** Directory containing the SDK code and stigmer.yaml. */
-  readonly projectDir: string;
-  /** Entry point file, relative to `projectDir`. */
-  readonly entryPoint: string;
-  /** Runtime inferred from the entry point extension. */
-  readonly runtime: Runtime;
-  /** Resolved org, injected as STIGMER_ORG_ID (empty = omit). */
-  readonly orgId: string;
-}
-
-/** Injectable collaborators (defaults run real subprocesses / fs checks). */
-export interface SynthesizeDeps {
-  readonly spawn?: SpawnFn;
-  readonly prepare?: (runtime: Runtime, projectDir: string) => void;
-}
-
-/** Outcome of synthesis: where the `.pb` files were written, plus SDK stdout. */
-export interface SynthesizeResult {
-  readonly outputDir: string;
-  readonly stdout: string;
-}
-
-/**
- * Execute the SDK entry point and leave the synthesized `.pb` files in
- * `<projectDir>/.stigmer`. Validates inputs, runs runtime prep, spawns the
- * program with the synthesis env, and maps a non-zero exit (or spawn failure)
- * to an actionable error. The caller reads the output dir with the reader.
- */
-export async function synthesize(opts: SynthesizeOptions, deps: SynthesizeDeps = {}): Promise<SynthesizeResult> {
-  if (opts.projectDir === "") throw new UsageError("project directory is required");
-  if (opts.entryPoint === "") throw new UsageError("entry point is required");
-
-  const projectDir = resolve(opts.projectDir);
-  if (!existsSync(projectDir)) throw new UsageError(`project directory not found: ${opts.projectDir}`);
-  const entryAbs = join(projectDir, opts.entryPoint);
-  if (!existsSync(entryAbs)) throw new UsageError(`entry point not found: ${opts.entryPoint}`);
-
-  const outputDir = join(projectDir, ".stigmer");
-  mkdirSync(outputDir, { recursive: true });
-
-  (deps.prepare ?? defaultPrepare)(opts.runtime, projectDir);
-
-  // Pass the ABSOLUTE entry path: `npx` resolves a relative entry against the
-  // npm project root (its "local prefix"), not the spawn cwd, so a relative path
-  // breaks for the node runtime. An absolute path is correct for every runtime;
-  // cwd stays the project dir so the program's own relative imports resolve.
-  const [command, ...args] = runtimeCommand(opts.runtime, entryAbs);
-  const env: NodeJS.ProcessEnv = { ...process.env, STIGMER_OUT_DIR: outputDir };
-  if (opts.orgId !== "") env.STIGMER_ORG_ID = opts.orgId;
-
-  let result: SpawnResult;
-  try {
-    result = await (deps.spawn ?? defaultSpawn)(command, args, { cwd: projectDir, env });
-  } catch (err) {
-    throw new UsageError(formatExecutionError(opts.runtime, "", (err as Error).message));
-  }
-  if (result.exitCode !== 0) {
-    throw new UsageError(formatExecutionError(opts.runtime, result.stderr, `exited with code ${result.exitCode}`));
-  }
-
-  return { outputDir, stdout: result.stdout };
-}
-
-/** Command + args to execute an entry point for the given runtime. */
-export function runtimeCommand(runtime: Runtime, entryPoint: string): string[] {
-  switch (runtime) {
-    case "go":
-      return ["go", "run", entryPoint];
-    case "python":
-      return ["python3", entryPoint];
-    case "node": {
-      const ext = extname(entryPoint).toLowerCase();
-      // TypeScript entries run through tsx; plain JS runs on node directly.
-      return ext === ".ts" || ext === ".tsx" || ext === ".mts" ? ["npx", "tsx", entryPoint] : ["node", entryPoint];
-    }
-  }
-}
-
-// Lightweight, runtime-specific readiness checks (no subprocess). Unlike Go we
-// do NOT auto-run `go mod tidy`; the entry-point run surfaces missing deps and
-// the user resolves them — keeping the single subprocess the synthesis itself.
-function defaultPrepare(runtime: Runtime, projectDir: string): void {
-  if (runtime === "node") {
-    if (!existsSync(join(projectDir, "package.json"))) {
-      throw new UsageError("package.json not found: run 'npm init' to initialize a Node.js project");
-    }
-    if (!existsSync(join(projectDir, "node_modules"))) {
-      throw new UsageError("node_modules not found: run 'npm install' to install dependencies");
-    }
-  } else if (runtime === "go" && !existsSync(join(projectDir, "go.mod"))) {
-    throw new UsageError("go.mod not found: run 'go mod init' to initialize a Go module");
-  }
-}
-
-// Real subprocess: collects stdout/stderr, resolves with the exit code.
-const defaultSpawn: SpawnFn = (command, args, options) =>
-  new Promise<SpawnResult>((resolvePromise, rejectPromise) => {
-    const child = spawn(command, [...args], { cwd: options.cwd, env: options.env });
-    let stdout = "";
-    let stderr = "";
-    child.stdout?.on("data", (chunk) => {
-      stdout += chunk.toString();
-    });
-    child.stderr?.on("data", (chunk) => {
-      stderr += chunk.toString();
-    });
-    child.on("error", (err) => rejectPromise(err));
-    child.on("close", (code) => resolvePromise({ exitCode: code ?? 0, stdout, stderr }));
-  });
-
-// Actionable failure message: truncated stderr + runtime-specific guidance.
-// Port of Go's formatExecutionError.
-function formatExecutionError(runtime: Runtime, stderr: string, fallback: string): string {
-  let detail = stderr.length > 800 ? `${stderr.slice(0, 800)}\n... (truncated)` : stderr;
-  if (detail === "") detail = fallback;
-
-  const guidance =
-    runtime === "go"
-      ? "Check for compile errors above. Run 'go build' to see full error output."
-      : runtime === "python"
-        ? "If you see import errors, install your dependencies (e.g. pip install -r requirements.txt)."
-        : "If you see module errors, run 'npm install' to install dependencies.";
-
-  return `SDK synthesis failed:\n${detail}\n\n${guidance}`;
-}