@runfusion/fusion 0.26.0 → 0.27.1

package/dist/plugins/fusion-plugin-cli-printing-press/src/__tests__/fixtures/registry.ts

@@ -0,0 +1,82 @@
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Database } from "@fusion/core";
+import { createCliPressStore } from "../../store/cli-press-store.js";
+import { encodeCredentialValue } from "../../store/credentials.js";
+
+export function makeFakeRegistry() {
+  const rootDir = mkdtempSync(join(tmpdir(), "cli-printing-press-registry-"));
+  const db = new Database(join(rootDir, ".fusion"), { inMemory: true });
+  db.init();
+  const store = createCliPressStore(db);
+
+  const acme = store.createService({
+    slug: "acme",
+    displayName: "Acme Service",
+    description: "Acme CLI",
+    baseUrl: "https://acme.example.com",
+    sourceKind: "manual",
+  });
+  const acmeSpec = store.createSpec({
+    serviceId: acme.id,
+    name: "acme-cli",
+    version: "1.0.0",
+    generatorVersion: "cli-printing-press",
+    specJson: JSON.stringify({ id: acme.id, slug: acme.slug }),
+    status: "generated",
+    generatedAt: new Date().toISOString(),
+    lastGenerationError: undefined,
+  });
+  const acmePath = `plugins/cli-printing-press/artifacts/${acme.id}/${acmeSpec.id}/acme`;
+  const acmeAbsPath = join(rootDir, ".fusion", acmePath);
+  mkdirSync(join(acmeAbsPath, ".."), { recursive: true });
+  writeFileSync(acmeAbsPath, "#!/bin/sh\necho acme\n");
+  store.createArtifact({ cliSpecId: acmeSpec.id, kind: "script", path: acmePath, executable: true });
+  store.createCredential({
+    serviceId: acme.id,
+    name: "token",
+    kind: "env_var",
+    placement: { kind: "env_var", envVar: "ACME_TOKEN" },
+    value: encodeCredentialValue("acme-secret"),
+  });
+
+  const beta = store.createService({
+    slug: "beta",
+    displayName: "Beta Service",
+    description: "Beta CLI",
+    baseUrl: "https://beta.example.com",
+    sourceKind: "manual",
+  });
+  const betaSpec = store.createSpec({
+    serviceId: beta.id,
+    name: "beta-cli",
+    version: "1.0.0",
+    generatorVersion: "cli-printing-press",
+    specJson: JSON.stringify({ id: beta.id, slug: beta.slug, unbuilt: true }),
+    status: "draft",
+    generatedAt: undefined,
+    lastGenerationError: undefined,
+  });
+  store.createCredential({
+    serviceId: beta.id,
+    name: "header-token",
+    kind: "header",
+    placement: { kind: "header", header: "X-Beta-Token" },
+    value: encodeCredentialValue("beta-secret"),
+  });
+
+  const cleanup = () => {
+    db.close();
+    rmSync(rootDir, { recursive: true, force: true });
+  };
+
+  return {
+    rootDir,
+    db,
+    store,
+    services: { acme, beta },
+    specs: { acme: acmeSpec, beta: betaSpec },
+    cleanup,
+  };
+}

package/dist/plugins/fusion-plugin-cli-printing-press/src/__tests__/generator.test.ts

@@ -0,0 +1,54 @@
+import { access, mkdtemp, readFile, stat } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { generateCli } from "../generation/generator.js";
+import { createDraftStore, getArtifactDir } from "../storage/draft-store.js";
+import type { ServiceDraft } from "../wizard/types.js";
+
+function makeDraft(id = "d-1"): ServiceDraft {
+  const now = new Date().toISOString();
+  return {
+    id,
+    name: "Demo",
+    slug: "demo",
+    description: "",
+    baseUrl: "https://example.com",
+    transport: "http",
+    endpoints: [{ id: "ep-1", name: "Ping", method: "GET", path: "/ping", params: "id" }],
+    credential: { kind: "none" },
+    createdAt: now,
+    updatedAt: now,
+  };
+}
+
+describe("generateCli", () => {
+  it("creates an executable file in artifact dir", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "clipp-gen-"));
+    const draft = makeDraft();
+    const artifact = await generateCli({ draft, outDir: getArtifactDir(draft.id, rootDir) });
+
+    await access(artifact.binPath);
+    const contents = await readFile(artifact.binPath, "utf8");
+    expect(contents).toContain("const draft =");
+
+    if (process.platform !== "win32") {
+      const mode = (await stat(artifact.binPath)).mode & 0o777;
+      expect(mode).toBe(0o755);
+    }
+  });
+
+  it("supports persisting generatedAt on rerun", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "clipp-gen-store-"));
+    const store = createDraftStore({ rootDir });
+    const created = await store.create(makeDraft("d-2"));
+
+    const first = await generateCli({ draft: created, outDir: getArtifactDir(created.id, rootDir) });
+    const updated = await store.update(created.id, { generatedAt: first.generatedAt, artifactPath: first.binPath });
+    const second = await generateCli({ draft: updated, outDir: getArtifactDir(updated.id, rootDir) });
+    const updatedAgain = await store.update(created.id, { generatedAt: second.generatedAt, artifactPath: second.binPath });
+
+    expect(updatedAgain.generatedAt).toBe(second.generatedAt);
+    expect(updatedAgain.generatedAt).not.toBe(first.generatedAt);
+  });
+});

package/dist/plugins/fusion-plugin-cli-printing-press/src/__tests__/manage-view.test.tsx

@@ -0,0 +1,98 @@
+// @vitest-environment jsdom
+import { render, screen, waitFor } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { CliPrintingPressManageView } from "../manage-view";
+import type { ServiceDraft } from "../wizard/types";
+
+vi.mock("lucide-react", () => ({
+  List: () => null,
+  Pencil: () => null,
+  RefreshCw: () => null,
+  Trash2: () => null,
+  Play: () => null,
+  CheckCircle2: () => null,
+  AlertTriangle: () => null,
+}));
+
+function makeDraft(id: string, name = "Demo"): ServiceDraft {
+  const now = new Date().toISOString();
+  return {
+    id,
+    name,
+    slug: id,
+    description: "",
+    baseUrl: `https://${id}.example.com`,
+    transport: "http",
+    endpoints: [{ id: `${id}-e1`, name: "Ping", method: "GET", path: "/ping" }],
+    credential: { kind: "none" },
+    createdAt: now,
+    updatedAt: now,
+  };
+}
+
+describe("CliPrintingPressManageView", () => {
+  beforeEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("renders empty state", async () => {
+    vi.stubGlobal("fetch", vi.fn(async () => ({ ok: true, json: async () => [] })));
+    render(<CliPrintingPressManageView />);
+    expect(await screen.findByText(/No saved drafts yet/i)).toBeTruthy();
+  });
+
+  it("renders list, detail, edit/save, regenerate, and delete", async () => {
+    const draft1 = makeDraft("draft-1", "Draft One");
+    const draft2 = makeDraft("draft-2", "Draft Two");
+    const updated = { ...draft1, name: "Draft One Edited" };
+
+    const fetchMock = vi.fn(async (input: RequestInfo | URL, init?: RequestInit) => {
+      const url = String(input);
+      const method = init?.method ?? "GET";
+
+      if (method === "GET" && url.endsWith("/drafts")) {
+        return { ok: true, json: async () => ([
+          { id: draft1.id, name: draft1.name, slug: draft1.slug, updatedAt: draft1.updatedAt },
+          { id: draft2.id, name: draft2.name, slug: draft2.slug, updatedAt: draft2.updatedAt },
+        ]) };
+      }
+      if (method === "GET" && url.endsWith(`/drafts/${draft1.id}`)) return { ok: true, json: async () => draft1 };
+      if (method === "GET" && url.endsWith(`/drafts/${draft2.id}`)) return { ok: true, json: async () => draft2 };
+      if (method === "PUT" && url.endsWith(`/drafts/${draft1.id}`)) return { ok: true, json: async () => updated };
+      if (method === "POST" && url.endsWith(`/drafts/${draft1.id}/regenerate`)) {
+        const generatedAt = new Date().toISOString();
+        return { ok: true, json: async () => ({ draft: { ...updated, regeneratedAt: generatedAt, generatedAt, artifactPath: "/tmp/demo.mjs" }, artifact: { draftId: draft1.id, slug: draft1.slug, binPath: "/tmp/demo.mjs", entrypoint: "node", generatedAt } }) };
+      }
+      if (method === "DELETE" && url.endsWith(`/drafts/${draft1.id}`)) return { ok: true, status: 204, json: async () => ({}) };
+      return { ok: false, status: 404, json: async () => ({ error: "Not found" }) };
+    });
+
+    vi.stubGlobal("fetch", fetchMock);
+    vi.spyOn(globalThis, "confirm").mockReturnValue(true);
+
+    const user = userEvent.setup();
+    render(<CliPrintingPressManageView />);
+
+    expect(await screen.findByText("Draft One")).toBeTruthy();
+    expect(screen.getByText("Draft Two")).toBeTruthy();
+    expect(await screen.findByText(/Base URL:/)).toBeTruthy();
+
+    await user.click(screen.getByRole("button", { name: /Edit/i }));
+    await user.clear(screen.getByLabelText("Name"));
+    await user.type(screen.getByLabelText("Name"), "Draft One Edited");
+    await user.click(screen.getByRole("button", { name: "Next" }));
+    await user.click(screen.getByRole("button", { name: "Next" }));
+    await user.click(screen.getByRole("button", { name: "Next" }));
+    await user.click(screen.getByRole("button", { name: "Next" }));
+    await user.click(screen.getByRole("button", { name: "Save" }));
+
+    await waitFor(() => expect(fetchMock).toHaveBeenCalledWith(expect.stringContaining(`/drafts/${draft1.id}`), expect.objectContaining({ method: "PUT" })));
+
+    await user.click(screen.getByRole("button", { name: /^Regenerate$/i }));
+    expect(await screen.findByText(/Regenerated at/i)).toBeTruthy();
+
+    await user.click(screen.getByRole("button", { name: /Delete/i }));
+    await waitFor(() => expect(fetchMock).toHaveBeenCalledWith(expect.stringContaining(`/drafts/${draft1.id}`), expect.objectContaining({ method: "DELETE" })));
+  });
+});

package/dist/plugins/fusion-plugin-cli-printing-press/src/__tests__/manifest.test.ts

@@ -1,9 +1,9 @@
-import { describe, it, expect } from "vitest";
+import { describe, expect, it } from "vitest";
 import { validatePluginManifest } from "@fusion/core";
 import plugin from "../index.js";
 import manifestJson from "../../manifest.json" with { type: "json" };
 
-describe("cli-printing-press plugin stub (FN-3762)", () => {
+describe("cli-printing-press plugin", () => {
   it("registers with the correct manifest id", () => {
     expect(plugin.manifest.id).toBe("fusion-plugin-cli-printing-press");
   });
@@ -13,8 +13,24 @@ describe("cli-printing-press plugin stub (FN-3762)", () => {
     expect(validation.valid).toBe(true);
   });
 
-  it("has no routes or dashboardViews in the stub", () => {
-    expect(plugin.routes).toBeUndefined();
-    expect(plugin.dashboardViews).toBeUndefined();
+  it("registers the wizard and manage dashboard views", () => {
+    expect(plugin.dashboardViews).toEqual([
+      {
+        viewId: "wizard",
+        label: "Create Service CLI",
+        componentPath: "./dashboard-view",
+        icon: "Wand2",
+        placement: "primary",
+        order: 60,
+      },
+      {
+        viewId: "manage",
+        label: "Manage Service CLIs",
+        componentPath: "./manage-view",
+        icon: "List",
+        placement: "primary",
+        order: 61,
+      },
+    ]);
   });
 });

package/dist/plugins/fusion-plugin-cli-printing-press/src/__tests__/registration.test.ts

@@ -0,0 +1,29 @@
+import { describe, expect, it } from "vitest";
+import { validatePluginManifest } from "@fusion/core";
+import plugin from "../index.js";
+import { ensureCliPressSchema } from "../store/cli-press-store.js";
+import { makeFakeRegistry } from "./fixtures/registry.js";
+
+describe("plugin registration contracts", () => {
+  it("declares expected manifest and semver version", () => {
+    expect(plugin.manifest.id).toBe("fusion-plugin-cli-printing-press");
+    expect(plugin.manifest.version).toMatch(/^\d+\.\d+\.\d+$/);
+    expect(validatePluginManifest(plugin.manifest).valid).toBe(true);
+  });
+
+  it("registers schema, routes, dashboard views and executor runtime hook", () => {
+    const h = makeFakeRegistry();
+    try {
+      expect(() => ensureCliPressSchema(h.db)).not.toThrow();
+      expect(plugin.routes?.some((route) => route.path === "/drafts")).toBe(true);
+      expect(plugin.dashboardViews?.map((view) => view.viewId)).toEqual(["wizard", "manage"]);
+      expect(typeof plugin.executorRuntimeEnv).toBe("function");
+    } finally {
+      h.cleanup();
+    }
+  });
+
+  it.skip("TODO(FN-3768): assert plugin workflow-step template contributions once shipped", () => {
+    // This branch does not yet export workflow step templates/contributions for cli-printing-press.
+  });
+});

package/dist/plugins/fusion-plugin-cli-printing-press/src/__tests__/run-routes.test.ts

@@ -0,0 +1,98 @@
+import { mkdtemp } from "node:fs/promises";
+import { createServer } from "node:http";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { Database } from "@fusion/core";
+import { createCliPrintingPressRoutes } from "../routes/wizard-routes.js";
+import type { ServiceDraft } from "../wizard/types.js";
+
+function makeDraft(baseUrl: string): ServiceDraft {
+  const now = new Date().toISOString();
+  return {
+    id: "",
+    name: "Demo",
+    slug: "demo",
+    description: "",
+    baseUrl,
+    transport: "http",
+    endpoints: [{ id: "e1", name: "Ping", method: "GET", path: "/ping" }],
+    credential: { kind: "none" },
+    createdAt: now,
+    updatedAt: now,
+  };
+}
+
+function route(method: string, path: string) {
+  const found = createCliPrintingPressRoutes().find((entry) => entry.method === method && entry.path === path);
+  if (!found) throw new Error(`missing route ${method} ${path}`);
+  return found;
+}
+
+const servers: Array<{ close: () => void }> = [];
+afterEach(() => {
+  while (servers.length) servers.pop()?.close();
+});
+
+async function startServer(handler: (req: any, res: any) => void): Promise<string> {
+  const server = createServer(handler);
+  await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
+  servers.push(server);
+  const addr = server.address();
+  if (!addr || typeof addr === "string") throw new Error("Invalid address");
+  return `http://127.0.0.1:${addr.port}`;
+}
+
+describe("run routes", () => {
+  it("regenerates and runs successfully", async () => {
+    const baseUrl = await startServer((_req, res) => {
+      res.statusCode = 200;
+      res.end("pong");
+    });
+    const rootDir = await mkdtemp(join(tmpdir(), "cli-printing-press-run-routes-"));
+    const db = new Database(join(rootDir, ".fusion"), { inMemory: true });
+    db.init();
+    const ctx = { taskStore: { getRootDir: () => rootDir, getDatabase: () => db } } as any;
+
+    const createRes = await route("POST", "/drafts").handler({ params: {}, body: makeDraft(baseUrl) }, ctx);
+    const id = (createRes.body as { id: string }).id;
+
+    const regenRes = await route("POST", "/drafts/:id/regenerate").handler({ params: { id } }, ctx);
+    expect(regenRes.status).toBe(200);
+    expect((regenRes.body as any).stub).toBeUndefined();
+
+    const runRes = await route("POST", "/drafts/:id/run").handler({ params: { id }, body: { endpointId: "e1", params: {} } }, ctx);
+    expect(runRes.status).toBe(200);
+    expect((runRes.body as any).stdout).toContain("pong");
+  });
+
+  it("returns validation, 404, 409, and timeout responses", async () => {
+    const baseUrl = await startServer((_req, res) => {
+      setTimeout(() => {
+        res.statusCode = 200;
+        res.end("slow");
+      }, 50);
+    });
+    const rootDir = await mkdtemp(join(tmpdir(), "cli-printing-press-run-routes-"));
+    const db = new Database(join(rootDir, ".fusion"), { inMemory: true });
+    db.init();
+    const ctx = { taskStore: { getRootDir: () => rootDir, getDatabase: () => db } } as any;
+
+    const createRes = await route("POST", "/drafts").handler({ params: {}, body: makeDraft(baseUrl) }, ctx);
+    const id = (createRes.body as { id: string }).id;
+
+    const noArtifact = await route("POST", "/drafts/:id/run").handler({ params: { id }, body: { endpointId: "e1", params: {} } }, ctx);
+    expect(noArtifact.status).toBe(409);
+
+    const badBody = await route("POST", "/drafts/:id/run").handler({ params: { id }, body: { endpointId: "", params: {} } }, ctx);
+    expect(badBody.status).toBe(400);
+
+    const unknown = await route("POST", "/drafts/:id/run").handler({ params: { id: "missing" }, body: { endpointId: "e1", params: {} } }, ctx);
+    expect(unknown.status).toBe(404);
+
+    await route("POST", "/drafts/:id/regenerate").handler({ params: { id } }, ctx);
+    const timeout = await route("POST", "/drafts/:id/run").handler({ params: { id }, body: { endpointId: "e1", params: {}, timeoutMs: 1 } }, ctx);
+    expect(timeout.status).toBe(200);
+    expect((timeout.body as any).timedOut).toBe(true);
+  });
+});

package/dist/plugins/fusion-plugin-cli-printing-press/src/__tests__/runner.test.ts

@@ -0,0 +1,55 @@
+import { mkdtemp, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { runGeneratedCli } from "../generation/runner.js";
+import type { GeneratedCliArtifact } from "../generation/types.js";
+
+async function writeFixture(script: string): Promise<{ artifact: GeneratedCliArtifact; root: string }> {
+  const root = await mkdtemp(join(tmpdir(), "clipp-runner-"));
+  const binPath = join(root, "fixture.mjs");
+  await writeFile(binPath, script, "utf8");
+  return {
+    root,
+    artifact: {
+      draftId: "draft-1",
+      slug: "fixture",
+      binPath,
+      entrypoint: "node",
+      generatedAt: new Date().toISOString(),
+    },
+  };
+}
+
+describe("runGeneratedCli", () => {
+  it("returns success output", async () => {
+    const { artifact, root } = await writeFixture("console.log('ok-output')");
+    const result = await runGeneratedCli({ artifact, endpointId: "x", params: { enabled: true }, cwd: root });
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toContain("ok-output");
+    expect(result.timedOut).toBe(false);
+  });
+
+  it("captures non-zero exit", async () => {
+    const { artifact, root } = await writeFixture("console.error('bad-output'); process.exit(7)");
+    const result = await runGeneratedCli({ artifact, endpointId: "x", params: {}, cwd: root });
+    expect(result.exitCode).toBe(7);
+    expect(result.stderr).toContain("bad-output");
+  });
+
+  it("captures timeout", async () => {
+    const { artifact, root } = await writeFixture("await new Promise((resolve) => setTimeout(resolve, 500)); console.log('late')");
+    const result = await runGeneratedCli({ artifact, endpointId: "x", params: {}, timeoutMs: 1, cwd: root });
+    expect(result.timedOut).toBe(true);
+    expect(result.exitCode).toBeNull();
+  });
+
+  it("redacts credentials from stdout and argv echo", async () => {
+    const secret = "super-secret-value";
+    const { artifact, root } = await writeFixture("console.log(process.env.CLIPP_CRED_API_KEY)");
+    const result = await runGeneratedCli({ artifact, endpointId: "x", params: { token: secret }, credentials: { api_key: secret }, cwd: root });
+    expect(result.stdout).not.toContain(secret);
+    expect(result.argv.join(" ")).not.toContain(secret);
+    expect(result.stdout).toContain("***");
+  });
+});

package/dist/plugins/fusion-plugin-cli-printing-press/src/__tests__/runtime-availability.test.ts

@@ -0,0 +1,61 @@
+import { describe, expect, it } from "vitest";
+import plugin from "../index.js";
+import { buildExecutorRuntimeEnv } from "../runtime/executor-runtime-env.js";
+import { makeFakeRegistry } from "./fixtures/registry.js";
+
+describe("runtime availability", () => {
+  it("exposes executor runtime env hook through plugin entry", () => {
+    expect(typeof plugin.executorRuntimeEnv).toBe("function");
+  });
+
+  it("returns PATH/env entries for generated CLIs only", () => {
+    const h = makeFakeRegistry();
+    try {
+      const result = buildExecutorRuntimeEnv(
+        h.store,
+        { taskId: "FN-3769", worktreePath: h.rootDir, rootDir: h.rootDir },
+        {
+          pluginId: "fusion-plugin-cli-printing-press",
+          taskStore: {} as never,
+          settings: {},
+          logger: { info() {}, warn() {}, error() {}, debug() {} },
+          emitEvent() {},
+        },
+      );
+
+      expect(result.pathPrepend).toHaveLength(1);
+      expect(result.pathPrepend[0]).toContain(`/artifacts/${h.services.acme.id}/${h.specs.acme.id}`);
+      expect(result.env).toEqual({ ACME_TOKEN: "acme-secret" });
+    } finally {
+      h.cleanup();
+    }
+  });
+
+  it("skips draft specs from PATH contributions", () => {
+    const h = makeFakeRegistry();
+    try {
+      const betaArtifacts = h.store.listArtifacts(h.specs.beta.id);
+      expect(betaArtifacts).toHaveLength(0);
+
+      const result = buildExecutorRuntimeEnv(
+        h.store,
+        { taskId: "FN-3769", worktreePath: h.rootDir, rootDir: h.rootDir },
+        {
+          pluginId: "fusion-plugin-cli-printing-press",
+          taskStore: {} as never,
+          settings: {},
+          logger: { info() {}, warn() {}, error() {}, debug() {} },
+          emitEvent() {},
+        },
+      );
+
+      expect(result.pathPrepend.some((entry) => entry.includes(`/artifacts/${h.services.beta.id}/`))).toBe(false);
+    } finally {
+      h.cleanup();
+    }
+  });
+
+  it.skip("TODO(FN-3767): cover resolveGeneratedCliInvocation contract once exported", () => {
+    // FN-3767 documented resolveGeneratedCliInvocation, but this branch has only buildExecutorRuntimeEnv.
+  });
+});

package/dist/plugins/fusion-plugin-cli-printing-press/src/__tests__/validation.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, it } from "vitest";
+import type { ServiceDraft } from "../wizard/types";
+import { validateBasics, validateCredentials, validateDraft, validateEndpoints, validateTransport } from "../wizard/validation";
+
+function makeDraft(): ServiceDraft {
+  const now = new Date().toISOString();
+  return { id: "", name: "GitHub", slug: "github", description: "", baseUrl: "https://api.github.com", transport: "http", endpoints: [{ id: "e1", name: "List Repos", method: "GET", path: "/user/repos" }], credential: { kind: "apiKey", header: "Authorization", envVar: "GITHUB_TOKEN" }, createdAt: now, updatedAt: now };
+}
+
+describe("wizard validation", () => {
+  it("validates basics", () => {
+    expect(validateBasics(makeDraft()).ok).toBe(true);
+    expect(validateBasics({ ...makeDraft(), slug: "Bad Slug" }).ok).toBe(false);
+  });
+  it("validates transport", () => {
+    expect(validateTransport(makeDraft()).ok).toBe(true);
+  });
+  it("validates endpoints", () => {
+    expect(validateEndpoints(makeDraft()).ok).toBe(true);
+    expect(validateEndpoints({ ...makeDraft(), endpoints: [] }).ok).toBe(false);
+  });
+  it("validates credentials", () => {
+    expect(validateCredentials({ kind: "bearerToken", envVar: "TOKEN" }).ok).toBe(true);
+    expect(validateCredentials({ kind: "bearerToken", envVar: "" }).ok).toBe(false);
+  });
+  it("validates full draft", () => {
+    expect(validateDraft(makeDraft()).ok).toBe(true);
+    expect(validateDraft({ ...makeDraft(), baseUrl: "not-url" }).ok).toBe(false);
+  });
+});

package/dist/plugins/fusion-plugin-cli-printing-press/src/__tests__/wizard-routes.test.ts

@@ -0,0 +1,61 @@
+import { mkdtemp } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { Database } from "@fusion/core";
+import { createCliPrintingPressRoutes } from "../routes/wizard-routes";
+import type { ServiceDraft } from "../wizard/types";
+
+function makeDraft(): ServiceDraft {
+  const now = new Date().toISOString();
+  return { id: "", name: "Demo", slug: "demo", description: "", baseUrl: "https://example.com", transport: "http", endpoints: [{ id: "e1", name: "Ping", method: "GET", path: "/ping" }], credential: { kind: "none" }, createdAt: now, updatedAt: now };
+}
+
+function route(method: string, path: string) {
+  const found = createCliPrintingPressRoutes().find((entry) => entry.method === method && entry.path === path);
+  if (!found) throw new Error(`missing route ${method} ${path}`);
+  return found;
+}
+
+describe("wizard routes", () => {
+  it("handles create/get/delete lifecycle", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "cli-printing-press-routes-"));
+    const db = new Database(join(rootDir, ".fusion"), { inMemory: true });
+    db.init();
+    const ctx = { taskStore: { getRootDir: () => rootDir, getDatabase: () => db } } as any;
+
+    const createRes = await route("POST", "/drafts").handler({ params: {}, body: makeDraft() }, ctx);
+    expect(createRes.status).toBe(201);
+    const id = (createRes.body as { id: string }).id;
+
+    const getRes = await route("GET", "/drafts/:id").handler({ params: { id } }, ctx);
+    expect(getRes.status).toBe(200);
+
+    const missRes = await route("GET", "/drafts/:id").handler({ params: { id: "missing" } }, ctx);
+    expect(missRes.status).toBe(404);
+
+    const invalidRes = await route("POST", "/drafts").handler({ params: {}, body: { ...makeDraft(), slug: "Bad Slug" } }, ctx);
+    expect(invalidRes.status).toBe(400);
+    expect((invalidRes.body as { errors: Record<string, string> }).errors.slug).toBeTruthy();
+
+    const putRes = await route("PUT", "/drafts/:id").handler({ params: { id }, body: { ...makeDraft(), id, name: "Renamed" } }, ctx);
+    expect(putRes.status).toBe(200);
+    expect((putRes.body as { name: string }).name).toBe("Renamed");
+
+    const invalidPutRes = await route("PUT", "/drafts/:id").handler({ params: { id }, body: { ...makeDraft(), id, baseUrl: "invalid-url" } }, ctx);
+    expect(invalidPutRes.status).toBe(400);
+
+    const missingPutRes = await route("PUT", "/drafts/:id").handler({ params: { id: "missing" }, body: { ...makeDraft(), id: "missing" } }, ctx);
+    expect(missingPutRes.status).toBe(404);
+
+    const regenRes = await route("POST", "/drafts/:id/regenerate").handler({ params: { id } }, ctx);
+    expect(regenRes.status).toBe(200);
+    expect((regenRes.body as { artifact?: { binPath: string } }).artifact?.binPath).toBeTruthy();
+
+    const missingRegenRes = await route("POST", "/drafts/:id/regenerate").handler({ params: { id: "missing" } }, ctx);
+    expect(missingRegenRes.status).toBe(404);
+
+    const deleteRes = await route("DELETE", "/drafts/:id").handler({ params: { id } }, ctx);
+    expect(deleteRes.status).toBe(204);
+  });
+});

package/dist/plugins/fusion-plugin-cli-printing-press/src/__tests__/workflow-integration.test.ts

@@ -0,0 +1,19 @@
+import { describe, expect, it } from "vitest";
+import plugin from "../index.js";
+import { installExecMock } from "./fixtures/exec-mock.js";
+
+describe("workflow integration contracts", () => {
+  it("guards against execSync usage in workflow-oriented execution fixtures", () => {
+    const execMock = installExecMock();
+    execMock.assertExecSyncUnused();
+    expect(typeof plugin.manifest.id).toBe("string");
+  });
+
+  it.skip("TODO(FN-3768): execute script-mode workflow handler once plugin workflow step contributions are available", () => {
+    // Missing in this branch: cli-printing-press workflow step contribution + script handler wiring.
+  });
+
+  it.skip("TODO(FN-3768): run through runWorkflowSteps with plugin:cli-printing-press:<id>", () => {
+    // packages/core resolvePluginWorkflowStep currently hard-codes mode="prompt".
+  });
+});