@runfusion/fusion 0.26.0 → 0.27.0

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

@@ -0,0 +1,191 @@
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Database } from "@fusion/core";
+import { describe, expect, it } from "vitest";
+import { createCliPressStore } from "../../store/cli-press-store.js";
+import { encodeCredentialValue } from "../../store/credentials.js";
+import { buildExecutorRuntimeEnv } from "../executor-runtime-env.js";
+
+function createHarness() {
+  const rootDir = mkdtempSync(join(tmpdir(), "cli-press-runtime-env-"));
+  const db = new Database(join(rootDir, ".fusion"), { inMemory: true });
+  db.init();
+  const store = createCliPressStore(db);
+  const warnings: string[] = [];
+
+  const ctx = {
+    pluginId: "fusion-plugin-cli-printing-press",
+    taskStore: undefined,
+    settings: {},
+    logger: {
+      log: () => {},
+      info: () => {},
+      warn: (msg: string) => warnings.push(msg),
+      error: () => {},
+      debug: () => {},
+    },
+    emitEvent: () => {},
+  };
+
+  const cleanup = () => {
+    db.close();
+    rmSync(rootDir, { recursive: true, force: true });
+  };
+
+  return { rootDir, db, store, warnings, ctx, cleanup };
+}
+
+describe("buildExecutorRuntimeEnv", () => {
+  it("returns empty env/path when no generated services are present", () => {
+    const h = createHarness();
+    try {
+      const result = buildExecutorRuntimeEnv(h.store, { taskId: "FN-1", worktreePath: h.rootDir, rootDir: h.rootDir }, h.ctx as never);
+      expect(result.pathPrepend).toEqual([]);
+      expect(result.env).toEqual({});
+    } finally {
+      h.cleanup();
+    }
+  });
+
+  it("adds executable artifact directory and env_var credential", () => {
+    const h = createHarness();
+    try {
+      const service = h.store.createService({
+        slug: "alpha",
+        displayName: "Alpha",
+        baseUrl: "https://example.com",
+        sourceKind: "manual",
+      });
+      const spec = h.store.createSpec({
+        serviceId: service.id,
+        name: "alpha-cli",
+        version: "0.1.0",
+        generatorVersion: "1.0.0",
+        specJson: "{}",
+        status: "generated",
+        generatedAt: new Date().toISOString(),
+      });
+      const relativePath = `plugins/cli-printing-press/artifacts/${service.id}/${spec.id}/alpha`;
+      const absolutePath = join(h.rootDir, ".fusion", relativePath);
+      mkdirSync(join(absolutePath, ".."), { recursive: true });
+      writeFileSync(absolutePath, "#!/bin/sh\necho alpha\n");
+
+      h.store.createArtifact({ cliSpecId: spec.id, kind: "script", path: relativePath, executable: true });
+      h.store.createCredential({
+        serviceId: service.id,
+        name: "api",
+        kind: "env_var",
+        placement: { kind: "env_var", envVar: "ALPHA_TOKEN" },
+        value: encodeCredentialValue("secret-alpha"),
+      });
+
+      const result = buildExecutorRuntimeEnv(h.store, { taskId: "FN-1", worktreePath: h.rootDir, rootDir: h.rootDir }, h.ctx as never);
+      expect(result.pathPrepend).toEqual([join(h.rootDir, ".fusion", "plugins/cli-printing-press/artifacts", service.id, spec.id)]);
+      expect(result.env).toEqual({ ALPHA_TOKEN: "secret-alpha" });
+    } finally {
+      h.cleanup();
+    }
+  });
+
+  it("deduplicates path entries across services", () => {
+    const h = createHarness();
+    try {
+      const sharedDir = `plugins/cli-printing-press/artifacts/shared/bin`;
+      const sharedExec1 = `${sharedDir}/one`;
+      const sharedExec2 = `${sharedDir}/two`;
+      mkdirSync(join(h.rootDir, ".fusion", sharedDir), { recursive: true });
+      writeFileSync(join(h.rootDir, ".fusion", sharedExec1), "1");
+      writeFileSync(join(h.rootDir, ".fusion", sharedExec2), "2");
+
+      for (const slug of ["one", "two"]) {
+        const service = h.store.createService({ slug, displayName: slug, baseUrl: "https://example.com", sourceKind: "manual" });
+        const spec = h.store.createSpec({
+          serviceId: service.id,
+          name: `${slug}-cli`,
+          version: "0.1.0",
+          generatorVersion: "1.0.0",
+          specJson: "{}",
+          status: "generated",
+          generatedAt: new Date().toISOString(),
+        });
+        h.store.createArtifact({
+          cliSpecId: spec.id,
+          kind: "script",
+          path: slug === "one" ? sharedExec1 : sharedExec2,
+          executable: true,
+        });
+      }
+
+      const result = buildExecutorRuntimeEnv(h.store, { taskId: "FN-1", worktreePath: h.rootDir, rootDir: h.rootDir }, h.ctx as never);
+      expect(result.pathPrepend).toEqual([join(h.rootDir, ".fusion", sharedDir)]);
+    } finally {
+      h.cleanup();
+    }
+  });
+
+  it("skips missing artifacts and logs warning", () => {
+    const h = createHarness();
+    try {
+      const service = h.store.createService({ slug: "missing", displayName: "Missing", baseUrl: "https://example.com", sourceKind: "manual" });
+      const spec = h.store.createSpec({
+        serviceId: service.id,
+        name: "missing-cli",
+        version: "0.1.0",
+        generatorVersion: "1.0.0",
+        specJson: "{}",
+        status: "generated",
+        generatedAt: new Date().toISOString(),
+      });
+      h.store.createArtifact({
+        cliSpecId: spec.id,
+        kind: "script",
+        path: `plugins/cli-printing-press/artifacts/${service.id}/${spec.id}/missing`,
+        executable: true,
+      });
+
+      const result = buildExecutorRuntimeEnv(h.store, { taskId: "FN-1", worktreePath: h.rootDir, rootDir: h.rootDir }, h.ctx as never);
+      expect(result.pathPrepend).toEqual([]);
+      expect(h.warnings.length).toBe(1);
+      expect(h.warnings[0]).toContain("Skipping missing artifact");
+    } finally {
+      h.cleanup();
+    }
+  });
+
+  it("rejects oauth credentials defensively", () => {
+    const h = createHarness();
+    try {
+      const service = h.store.createService({ slug: "oauth", displayName: "OAuth", baseUrl: "https://example.com", sourceKind: "manual" });
+      const encoded = JSON.stringify(encodeCredentialValue("token"));
+      const placement = JSON.stringify({ kind: "oauth", provider: "x" });
+      h.db.prepare("INSERT INTO cli_press_credentials (id, serviceId, name, kind, value, placement, createdAt, updatedAt) VALUES (?, ?, ?, ?, ?, ?, datetime('now'), datetime('now'))")
+        .run("cred_oauth", service.id, "oauth", "oauth", encoded, placement);
+
+      expect(() =>
+        buildExecutorRuntimeEnv(h.store, { taskId: "FN-1", worktreePath: h.rootDir, rootDir: h.rootDir }, h.ctx as never),
+      ).toThrow(/OAuth credentials are not supported/);
+    } finally {
+      h.cleanup();
+    }
+  });
+
+  it("ignores non env_var credentials", () => {
+    const h = createHarness();
+    try {
+      const service = h.store.createService({ slug: "beta", displayName: "Beta", baseUrl: "https://example.com", sourceKind: "manual" });
+      h.store.createCredential({
+        serviceId: service.id,
+        name: "header",
+        kind: "header",
+        placement: { kind: "header", header: "X-Token" },
+        value: encodeCredentialValue("header-token"),
+      });
+
+      const result = buildExecutorRuntimeEnv(h.store, { taskId: "FN-1", worktreePath: h.rootDir, rootDir: h.rootDir }, h.ctx as never);
+      expect(result.env).toEqual({});
+    } finally {
+      h.cleanup();
+    }
+  });
+});

package/dist/plugins/fusion-plugin-cli-printing-press/src/runtime/executor-runtime-env.ts

@@ -0,0 +1,75 @@
+import { dirname, isAbsolute, join } from "node:path";
+import { existsSync } from "node:fs";
+import type { ExecutorRuntimeEnvContribution, ExecutorRuntimeTaskContext, PluginContext } from "@fusion/plugin-sdk";
+import type { createCliPressStore } from "../store/cli-press-store.js";
+import { decodeCredentialValue } from "../store/credentials.js";
+
+type CliPressStore = ReturnType<typeof createCliPressStore>;
+
+function toEpoch(value?: string): number {
+  if (!value) return 0;
+  const parsed = Date.parse(value);
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+
+export function buildExecutorRuntimeEnv(
+  store: CliPressStore,
+  taskCtx: ExecutorRuntimeTaskContext,
+  ctx: PluginContext,
+): ExecutorRuntimeEnvContribution {
+  const pathDirs: string[] = [];
+  const env: Record<string, string> = {};
+
+  for (const service of store.listServices()) {
+    const specs = store
+      .listSpecs(service.id)
+      .filter((spec) => spec.status === "generated")
+      .sort((a, b) => toEpoch(b.generatedAt ?? b.updatedAt) - toEpoch(a.generatedAt ?? a.updatedAt));
+
+    const selectedSpec = specs.find((spec) => {
+      const artifacts = store.listArtifacts(spec.id);
+      return artifacts.some((artifact) => artifact.executable);
+    });
+
+    if (selectedSpec) {
+      const executableArtifacts = store.listArtifacts(selectedSpec.id).filter((artifact) => artifact.executable);
+      for (const artifact of executableArtifacts) {
+        const absoluteArtifactPath = isAbsolute(artifact.path)
+          ? artifact.path
+          : join(taskCtx.rootDir, ".fusion", artifact.path);
+        if (!existsSync(absoluteArtifactPath)) {
+          ctx.logger.warn(
+            `[executorRuntimeEnv] Skipping missing artifact for service ${service.slug}: ${absoluteArtifactPath}`,
+          );
+          continue;
+        }
+        pathDirs.push(dirname(absoluteArtifactPath));
+      }
+    }
+
+    for (const credential of store.listCredentials(service.id)) {
+      const credentialKind = (credential as { kind: string }).kind;
+      if (credentialKind === "oauth" || credentialKind === "oauth2") {
+        throw new Error(`OAuth credentials are not supported for service ${service.slug}`);
+      }
+
+      if (credential.kind !== "env_var") {
+        continue;
+      }
+
+      if (credential.placement.kind !== "env_var") {
+        throw new Error(
+          `Credential placement mismatch for ${credential.name}: expected env_var placement, got ${credential.placement.kind}`,
+        );
+      }
+
+      env[credential.placement.envVar] = decodeCredentialValue(credential.value);
+    }
+  }
+
+  return {
+    pathPrepend: Array.from(new Set(pathDirs)),
+    env,
+    description: "cli-printing-press generated CLIs",
+  };
+}

package/dist/plugins/fusion-plugin-cli-printing-press/src/storage/draft-store.ts

@@ -0,0 +1,85 @@
+/* Interim storage — replaced by FN-3766's canonical schema. Do not extend without updating that ticket. */
+import { randomUUID } from "node:crypto";
+import { mkdir, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import type { ServiceDraft } from "../wizard/types.js";
+
+export class NotFoundError extends Error {
+  constructor(id: string) {
+    super(`Draft not found: ${id}`);
+    this.name = "NotFoundError";
+  }
+}
+
+function mergeDraft(existing: ServiceDraft, patch: Partial<ServiceDraft>): ServiceDraft {
+  const mergedCredential = patch.credential && typeof patch.credential === "object"
+    ? { ...existing.credential, ...patch.credential }
+    : existing.credential;
+
+  return {
+    ...existing,
+    ...patch,
+    credential: mergedCredential,
+    endpoints: patch.endpoints ?? existing.endpoints,
+  };
+}
+
+export function getArtifactDir(id: string, projectRoot: string): string {
+  return join(projectRoot, ".fusion", "plugins", "cli-printing-press", "generated", id);
+}
+
+export function createDraftStore({ rootDir }: { rootDir: string }) {
+  const draftsDir = join(rootDir, ".fusion", "plugins", "cli-printing-press", "drafts");
+
+  async function ensureDir() { await mkdir(draftsDir, { recursive: true }); }
+
+  function nextUpdatedAt(previous?: string): string {
+    const now = Date.now();
+    const previousTime = previous ? Date.parse(previous) : Number.NaN;
+    if (Number.isFinite(previousTime) && now <= previousTime) {
+      return new Date(previousTime + 1).toISOString();
+    }
+    return new Date(now).toISOString();
+  }
+
+  async function writeAtomic(path: string, draft: ServiceDraft): Promise<void> {
+    const tempPath = `${path}.tmp-${randomUUID()}`;
+    await writeFile(tempPath, JSON.stringify(draft, null, 2), "utf8");
+    await rename(tempPath, path);
+  }
+
+  return {
+    async create(input: ServiceDraft) {
+      await ensureDir();
+      const now = nextUpdatedAt();
+      const draft: ServiceDraft = { ...input, id: input.id || randomUUID(), createdAt: input.createdAt || now, updatedAt: now };
+      await writeAtomic(join(draftsDir, `${draft.id}.json`), draft);
+      return draft;
+    },
+    async list() {
+      await ensureDir();
+      const files = await readdir(draftsDir);
+      const entries = await Promise.all(files.filter((file) => file.endsWith(".json")).map(async (file) => JSON.parse(await readFile(join(draftsDir, file), "utf8")) as ServiceDraft));
+      return entries.map(({ id, name, slug, updatedAt }) => ({ id, name, slug, updatedAt }));
+    },
+    async get(id: string) {
+      try { return JSON.parse(await readFile(join(draftsDir, `${id}.json`), "utf8")) as ServiceDraft; } catch { return null; }
+    },
+    async update(id: string, patch: Partial<ServiceDraft>) {
+      await ensureDir();
+      const current = await this.get(id);
+      if (!current) throw new NotFoundError(id);
+      const updated: ServiceDraft = {
+        ...mergeDraft(current, patch),
+        id: current.id,
+        createdAt: current.createdAt,
+        updatedAt: nextUpdatedAt(current.updatedAt),
+      };
+      await writeAtomic(join(draftsDir, `${id}.json`), updated);
+      return updated;
+    },
+    async delete(id: string) {
+      await rm(join(draftsDir, `${id}.json`), { force: true });
+    },
+  };
+}

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

@@ -0,0 +1,128 @@
+import { mkdtempSync } from "node:fs";
+import { rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Database } from "@fusion/core";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { createCliPressStore, ensureCliPressSchema } from "../cli-press-store.js";
+import { encodeCredentialValue } from "../credentials.js";
+
+describe("cli-press-store", () => {
+  let rootDir: string;
+  let db: Database;
+  let store: ReturnType<typeof createCliPressStore>;
+
+  beforeEach(() => {
+    rootDir = mkdtempSync(join(tmpdir(), "cli-press-store-"));
+    db = new Database(join(rootDir, ".fusion"), { inMemory: true });
+    db.init();
+    ensureCliPressSchema(db);
+    ensureCliPressSchema(db);
+    store = createCliPressStore(db);
+  });
+
+  afterEach(async () => {
+    db.close();
+    await rm(rootDir, { recursive: true, force: true });
+  });
+
+  it("creates schema idempotently and runs full CRUD", () => {
+    const service = store.createService({
+      slug: "demo",
+      displayName: "Demo",
+      description: "Demo service",
+      baseUrl: "https://example.com",
+      sourceKind: "manual",
+      sourceRef: "wizard",
+    });
+    expect(service.id).toMatch(/^svc_/);
+
+    const updatedService = store.updateService(service.id, { displayName: "Demo Updated" });
+    expect(updatedService.displayName).toBe("Demo Updated");
+
+    const spec = store.createSpec({
+      serviceId: service.id,
+      name: "demo-cli",
+      version: "0.1.0",
+      generatorVersion: "1.0.0",
+      specJson: JSON.stringify({ hello: "world" }),
+      status: "draft",
+      generatedAt: undefined,
+      lastGenerationError: undefined,
+    });
+    expect(store.getSpec(spec.id)?.specJson).toBe(JSON.stringify({ hello: "world" }));
+
+    const updatedSpec = store.updateSpec(spec.id, { status: "generated" });
+    expect(updatedSpec.status).toBe("generated");
+
+    const artifact = store.createArtifact({
+      cliSpecId: spec.id,
+      kind: "script",
+      path: "plugins/cli-printing-press/artifacts/demo.sh",
+      executable: true,
+      checksum: "abc",
+      sizeBytes: 42,
+    });
+    expect(artifact.id).toMatch(/^art_/);
+
+    const cred = store.createCredential({
+      serviceId: service.id,
+      name: "api",
+      kind: "api_key",
+      value: encodeCredentialValue("secret"),
+      placement: { kind: "api_key", header: "X-API-Key" },
+    });
+    expect(cred.id).toMatch(/^cred_/);
+
+    const setting = store.setSetting({
+      serviceId: service.id,
+      key: "region",
+      value: "us-east-1",
+      scope: "runtime",
+    });
+    expect(setting.id).toMatch(/^set_/);
+
+    expect(store.listServices()).toHaveLength(1);
+    expect(store.listSpecs(service.id)).toHaveLength(1);
+    expect(store.listArtifacts(spec.id)).toHaveLength(1);
+    expect(store.listCredentials(service.id)).toHaveLength(1);
+    expect(store.listSettings(service.id)).toHaveLength(1);
+
+    store.deleteService(service.id);
+    expect(store.listServices()).toHaveLength(0);
+    expect(store.listSpecs(service.id)).toHaveLength(0);
+    expect(store.listCredentials(service.id)).toHaveLength(0);
+    expect(store.listSettings(service.id)).toHaveLength(0);
+  });
+
+  it("rejects oauth and invalid placement", () => {
+    const service = store.createService({
+      slug: "oauth-demo",
+      displayName: "OAuth Demo",
+      description: "",
+      baseUrl: "https://example.com",
+      sourceKind: "manual",
+      sourceRef: "wizard",
+    });
+
+    expect(() =>
+      store.createCredential({
+        serviceId: service.id,
+        name: "bad",
+        kind: "oauth" as never,
+        value: encodeCredentialValue("x"),
+        placement: { kind: "header", header: "Authorization" },
+      }),
+    ).toThrow("not supported");
+
+    expect(() =>
+      store.createCredential({
+        serviceId: service.id,
+        name: "bad2",
+        kind: "api_key",
+        value: encodeCredentialValue("x"),
+        placement: { kind: "api_key", header: "X", queryParam: "token" },
+      }),
+    ).toThrow("Invalid credential placement");
+  });
+});

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

@@ -0,0 +1,62 @@
+import { describe, expect, it } from "vitest";
+import type { Credential } from "../cli-press-types.js";
+import { applyCredentialToRequest, decodeCredentialValue, encodeCredentialValue } from "../credentials.js";
+
+function baseCredential(partial: Partial<Credential>): Credential {
+  return {
+    id: "cred_1",
+    serviceId: "svc_1",
+    name: "cred",
+    kind: "header",
+    value: encodeCredentialValue("secret"),
+    placement: { kind: "header", header: "X-Custom-Token" },
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    ...partial,
+  } as Credential;
+}
+
+describe("credentials", () => {
+  it("encodes and decodes", () => {
+    const encoded = encodeCredentialValue("alice:s3cret");
+    expect(encoded.encoding).toBe("base64");
+    expect(decodeCredentialValue(encoded)).toBe("alice:s3cret");
+  });
+
+  it("applies all credential kinds", () => {
+    const request = { headers: {}, query: {}, env: {} };
+
+    applyCredentialToRequest(baseCredential({ kind: "header", placement: { kind: "header", header: "X-Custom-Token" } }), request);
+    applyCredentialToRequest(baseCredential({ kind: "query_param", placement: { kind: "query_param", queryParam: "api_token" } }), request);
+    applyCredentialToRequest(baseCredential({ kind: "env_var", placement: { kind: "env_var", envVar: "GITHUB_TOKEN" } }), request);
+    applyCredentialToRequest(baseCredential({ kind: "bearer_token", placement: { kind: "bearer_token", header: "Authorization" } }), request);
+    applyCredentialToRequest(baseCredential({ kind: "api_key", placement: { kind: "api_key", header: "X-API-Key" } }), request);
+    applyCredentialToRequest(baseCredential({ kind: "api_key", placement: { kind: "api_key", queryParam: "api_key" } }), request);
+    applyCredentialToRequest(
+      baseCredential({
+        kind: "basic_auth",
+        value: encodeCredentialValue("alice:s3cret"),
+        placement: { kind: "basic_auth", header: "Authorization" },
+      }),
+      request,
+    );
+
+    expect(request.headers["X-Custom-Token"]).toBe("secret");
+    expect(request.query.api_token).toBe("secret");
+    expect(request.env.GITHUB_TOKEN).toBe("secret");
+    expect(request.headers.Authorization).toBe("Basic YWxpY2U6czNjcmV0");
+    expect(request.headers["X-API-Key"]).toBe("secret");
+    expect(request.query.api_key).toBe("secret");
+  });
+
+  it("throws on placement mismatch and oauth", () => {
+    const request = { headers: {}, query: {}, env: {} };
+    expect(() =>
+      applyCredentialToRequest(baseCredential({ kind: "header", placement: { kind: "query_param", queryParam: "x" } as any }), request),
+    ).toThrow("Invalid credential placement");
+
+    expect(() =>
+      applyCredentialToRequest(baseCredential({ kind: "oauth" as any, placement: { kind: "oauth", header: "Authorization" } as any }), request),
+    ).toThrow("not supported");
+  });
+});