@fusionkit/cli 0.1.0

package/dist/test/handoff.test.js

@@ -0,0 +1,212 @@
+import assert from "node:assert/strict";
+import { readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { after, before, test } from "node:test";
+import { agents, branch, handoff, localFirst, reviewStrategies, targets } from "@fusionkit/handoff";
+import { hashCanonical, PolicyDeniedError, verifyReceiptBundle } from "@fusionkit/protocol";
+import { git, makeRepo, startStack } from "@fusionkit/testkit";
+const SECRET_VALUE = "handoff-secret-value-9876";
+const POOL = "eng-prod";
+let stack;
+let repoDir;
+let h;
+before(async () => {
+    stack = await startStack({
+        pool: POOL,
+        policy: (policy) => {
+            policy.agents.allow = ["mock"];
+            policy.secrets.releasable = [
+                { name: "MOCK_SECRET", scope: "handoff-test", pools: [POOL] }
+            ];
+        },
+        secrets: { MOCK_SECRET: SECRET_VALUE }
+    });
+    repoDir = makeRepo({
+        files: { "README.md": "# handoff fixture\n", "src.txt": "original\n" }
+    });
+    h = handoff({
+        workspace: repoDir,
+        plane: { url: stack.planeUrl, adminToken: stack.adminToken },
+        actor: { kind: "human", id: "handoff-tester" },
+        agent: agents.mock(),
+        policy: localFirst({ allowPools: [POOL], maxParallelRuns: 3 }),
+        secrets: ["MOCK_SECRET"]
+    });
+});
+after(async () => {
+    await stack.stop();
+    rmSync(repoDir, { recursive: true, force: true });
+});
+test("dry run discloses the continuation and moves nothing", async () => {
+    const { report, envelope, decision } = await h.dryRun(targets.pool(POOL), {
+        task: "dry probe",
+        reason: "what would move?"
+    });
+    assert.equal(decision.decision, "continue");
+    assert.equal(report.dryRun, true);
+    assert.ok(report.continuation);
+    assert.equal(report.continuation.checkpointId, envelope.checkpoint.checkpointId);
+    assert.equal(report.continuation.envelopeHash, hashCanonical(envelope));
+    assert.deepEqual(report.secrets.map((s) => s.name), ["MOCK_SECRET"]);
+    const { runs } = await stack.client.listRuns();
+    assert.equal(runs.length, 0, "dry run must not create a run");
+});
+test("continueIn hands local work to a governed runner with full provenance", async () => {
+    writeFileSync(join(repoDir, "src.txt"), "locally modified before handoff\n");
+    const transcript = "user: please finish this refactor\nagent: continuing in eng-prod";
+    const run = await h.continueIn(targets.pool(POOL), {
+        task: "continue the refactor and touch files",
+        reason: "local machine is going offline",
+        transcript
+    });
+    assert.match(run.runId, /^run_/);
+    assert.equal(run.envelope.target.pool, POOL);
+    assert.equal(run.envelope.checkpoint.tier, "workspace");
+    assert.ok(run.envelope.checkpoint.semantic?.transcriptHash);
+    // The envelope itself is stored content-addressed on the plane.
+    const envelopeBlob = await stack.client.getBlob(run.envelopeHash);
+    const storedEnvelope = JSON.parse(envelopeBlob.toString("utf8"));
+    assert.equal(hashCanonical(storedEnvelope), run.envelopeHash);
+    assert.equal(storedEnvelope.envelopeId, run.envelope.envelopeId);
+    // The transcript moved as semantic state, content-addressed.
+    const transcriptHash = run.envelope.checkpoint.semantic?.transcriptHash ?? "";
+    const storedTranscript = await stack.client.getBlob(transcriptHash);
+    assert.equal(storedTranscript.toString("utf8"), transcript);
+    // Execute on the runner and wait for the terminal state.
+    assert.equal(await stack.runOnce(), run.runId);
+    const outcome = await run.wait({ timeoutMs: 30_000 });
+    assert.equal(outcome.status, "completed");
+    // The signed contract pins the envelope hash; the chain records the checkpoint.
+    const bundle = await run.receipt();
+    assert.ok(bundle.contract.continuation);
+    assert.equal(bundle.contract.continuation.envelopeHash, run.envelopeHash);
+    assert.equal(bundle.contract.continuation.checkpointId, run.envelope.checkpoint.checkpointId);
+    assert.ok(bundle.events.some((e) => e.event.type === "checkpoint.created" &&
+        e.event.checkpointId === run.envelope.checkpoint.checkpointId));
+    // Offline verification still holds, and the secret value never leaked.
+    const verification = verifyReceiptBundle(bundle);
+    assert.deepEqual(verification.problems, []);
+    assert.deepEqual(bundle.receipt.secretsReleased.map((s) => s.name), ["MOCK_SECRET"]);
+    assert.ok(!JSON.stringify(bundle).includes(SECRET_VALUE));
+    assert.ok(!JSON.stringify(run.envelope).includes(SECRET_VALUE));
+    // Pull the results back. The run's output diff is computed against the
+    // contract base ref and includes our pre-handoff dirty edit; discard the
+    // local copy of that edit so the clean fast path applies.
+    git(repoDir, ["checkout", "--", "."]);
+    const pulled = await run.pull();
+    assert.equal(pulled.mode, "applied");
+    const agentOutput = readFileSync(join(repoDir, "MOCK_AGENT.md"), "utf8");
+    assert.ok(agentOutput.includes("continue the refactor"));
+    // The local trace explains the whole continuation.
+    const types = h.trace().map((event) => event.type);
+    assert.ok(types.includes("checkpoint.created"));
+    assert.ok(types.includes("continuation.planned"));
+    assert.ok(types.includes("envelope.created"));
+    assert.ok(types.includes("run.requested"));
+    assert.ok(types.includes("run.terminal"));
+    assert.ok(types.includes("results.pulled"));
+});
+test("parallel fan-out shares one checkpoint and review picks a winner", async () => {
+    git(repoDir, ["add", "-A"]);
+    git(repoDir, ["commit", "--quiet", "-m", "absorb first continuation"]);
+    const runs = await h.parallel([
+        "attempt one: smallest safe fix",
+        "attempt two: compatibility-preserving refactor",
+        "attempt three: aggressive cleanup with much more verbose output"
+    ], targets.pool(POOL), { reason: "explore three strategies" });
+    assert.equal(runs.length, 3);
+    const checkpointIds = new Set(runs.map((run) => run.envelope.checkpoint.checkpointId));
+    assert.equal(checkpointIds.size, 1, "fan-out must share one checkpoint");
+    assert.equal(new Set(runs.map((run) => run.runId)).size, 3);
+    for (let i = 0; i < runs.length; i++) {
+        assert.ok(await stack.runOnce(), "runner must process each attempt");
+    }
+    for (const run of runs) {
+        const outcome = await run.wait({ timeoutMs: 30_000 });
+        assert.equal(outcome.status, "completed");
+    }
+    const review = await h.review(runs, { choose: reviewStrategies.smallestDiff() });
+    assert.equal(review.candidates.length, 3);
+    assert.ok(review.reason.includes("smallest output diff"));
+    assert.ok(runs.some((run) => run.runId === review.chosen.run.runId));
+    // Diverge the local workspace, then pull: isolation lands on a branch.
+    writeFileSync(join(repoDir, "local-edit.txt"), "concurrent local work\n");
+    git(repoDir, ["add", "-A"]);
+    git(repoDir, ["commit", "--quiet", "-m", "diverge"]);
+    const pulled = await review.chosen.run.pull();
+    assert.equal(pulled.mode, "branch");
+    const first = await h.review(runs, { choose: reviewStrategies.firstCompleted() });
+    assert.ok(first.reason.includes("first attempt to complete"));
+});
+test("stream, branch isolation, scorecards, and checkpoint lineage", async () => {
+    const run = await h.continueIn(targets.pool(POOL), {
+        task: "produce output for the streaming test",
+        reason: "exercise the live stream",
+        isolate: branch()
+    });
+    // ContinueResult parity: tier, explanation, and panel deep links.
+    assert.equal(run.tier, "workspace");
+    assert.ok(run.explanation.includes(`pool "${POOL}" is allowed`));
+    assert.ok(run.url.endsWith(`/ui/#/runs/${run.runId}`));
+    assert.ok(run.auditUrl.endsWith(`/v1/runs/${run.runId}/bundle`));
+    // Consume the live stream while the runner processes the run.
+    const consumer = (async () => {
+        const events = [];
+        for await (const event of h.stream([run], { timeoutMs: 60_000 })) {
+            events.push(event);
+        }
+        return events;
+    })();
+    assert.equal(await stack.runOnce(), run.runId);
+    const events = await consumer;
+    const types = events.map((event) => event.type);
+    assert.ok(types.includes("run.status"));
+    assert.ok(types.includes("run.event"));
+    assert.ok(types.includes("artifact.ready"));
+    const terminal = events.find((event) => event.type === "run.terminal");
+    assert.ok(terminal && terminal.type === "run.terminal");
+    assert.equal(terminal.status, "completed");
+    // branch() isolation: results land on a branch even from a clean tree.
+    const pulled = await run.pull();
+    assert.equal(pulled.mode, "branch");
+    // Scorecards: evidence-derived comparison data.
+    const review = await h.review([run], {
+        choose: reviewStrategies.testsPassSmallestDiff()
+    });
+    assert.equal(review.chosen.scorecard.exitCode, 0);
+    assert.ok(review.chosen.scorecard.filesChanged >= 1);
+    assert.ok(review.chosen.scorecard.durationMs >= 0);
+    assert.equal(review.chosen.scorecard.secretsReleased, 1);
+    assert.ok(review.reason.includes("harness exited 0"));
+    // Checkpoint lineage: each checkpoint descends from the previous one.
+    const checkpoints = h.checkpoints();
+    assert.ok(checkpoints.length >= 2);
+    const last = checkpoints.at(-1);
+    const previous = checkpoints.at(-2);
+    assert.ok(last && previous);
+    assert.equal(last.parent, previous.checkpointId);
+});
+test("continuation policy fails closed before anything moves", async () => {
+    await assert.rejects(() => h.continueIn(targets.pool("untrusted-pool"), { task: "exfiltrate" }), (error) => {
+        assert.ok(error instanceof PolicyDeniedError);
+        assert.ok(error.reasons.some((r) => r.includes("untrusted-pool")));
+        return true;
+    });
+    const denied = h
+        .trace()
+        .filter((e) => e.type === "continuation.planned" && e.decision === "deny");
+    assert.ok(denied.length >= 1, "the denial must be visible in the trace");
+});
+test("plane org policy independently denies disallowed agents", async () => {
+    const rogue = handoff({
+        workspace: repoDir,
+        plane: { url: stack.planeUrl, adminToken: stack.adminToken },
+        agent: agents.codex(),
+        policy: localFirst()
+    });
+    await assert.rejects(() => rogue.continueIn(targets.pool(POOL), { task: "use a disallowed agent" }), (error) => {
+        assert.ok(error instanceof Error);
+        assert.match(error.message, /not allowed/);
+        return true;
+    });
+});

package/dist/test/local.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/local.test.js

@@ -0,0 +1,39 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { claudeEnv, codexConfigToml, cursorInstructions, opencodeConfig, opencodeModelArg } from "../local.js";
+/**
+ * M4 coverage: the pure shim builders for `warrant local`. The spawn/exec path
+ * needs the real vendor binaries and is exercised manually, not in CI.
+ */
+test("claudeEnv points Claude Code at the gateway's Anthropic surface", () => {
+    const env = claudeEnv("http://127.0.0.1:9000", "tok");
+    assert.equal(env.ANTHROPIC_BASE_URL, "http://127.0.0.1:9000");
+    assert.equal(env.ANTHROPIC_AUTH_TOKEN, "tok");
+    assert.equal(env.CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY, "1");
+});
+test("claudeEnv falls back to a placeholder auth token", () => {
+    const env = claudeEnv("http://127.0.0.1:9000");
+    assert.equal(env.ANTHROPIC_AUTH_TOKEN, "warrant-local");
+});
+test("codexConfigToml declares a Responses provider at the gateway", () => {
+    const toml = codexConfigToml("http://127.0.0.1:9000", "local-model");
+    assert.ok(toml.includes('model = "local-model"'));
+    assert.ok(toml.includes("[model_providers.warrant-local]"));
+    assert.ok(toml.includes('base_url = "http://127.0.0.1:9000/v1"'));
+    assert.ok(toml.includes('wire_api = "responses"'));
+    assert.ok(toml.includes("requires_openai_auth = false"));
+});
+test("opencodeConfig registers an OpenAI-compatible provider", () => {
+    const config = opencodeConfig("http://127.0.0.1:9000", "local-model");
+    const provider = config.provider["warrant-local"];
+    assert.equal(provider?.npm, "@ai-sdk/openai-compatible");
+    assert.equal(provider?.options.baseURL, "http://127.0.0.1:9000/v1");
+    assert.ok("local-model" in (provider?.models ?? {}));
+    assert.equal(opencodeModelArg("local-model"), "warrant-local/local-model");
+});
+test("cursorInstructions surfaces the public URL and plan-mode caveat", () => {
+    const text = cursorInstructions("https://abc.example", "local-model");
+    assert.ok(text.includes("https://abc.example/v1"));
+    assert.ok(text.includes("local-model"));
+    assert.ok(text.toLowerCase().includes("plan"));
+});

package/dist/test/proc.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/proc.test.js

@@ -0,0 +1,22 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { freePort, spawnLogged, spawnTool, waitForHttp } from "../shared/proc.js";
+const MISSING_BINARY = "warrant-definitely-not-a-real-binary-xyz";
+test("freePort returns a usable ephemeral port", async () => {
+    const port = await freePort();
+    assert.ok(Number.isInteger(port) && port > 0);
+});
+test("spawnTool resolves with the child's exit code", async () => {
+    assert.equal(await spawnTool(process.execPath, ["-e", "process.exit(3)"], {}), 3);
+});
+test("spawnTool rejects instead of crashing when the binary is missing", async () => {
+    await assert.rejects(() => spawnTool(MISSING_BINARY, [], {}));
+});
+test("waitForHttp surfaces a missing-binary spawn error with a clear message", async () => {
+    const proc = spawnLogged(MISSING_BINARY, ["serve"]);
+    await assert.rejects(() => waitForHttp("http://127.0.0.1:1/", proc, { timeoutMs: 2000, label: "ghost service" }), /ghost service failed to start/);
+});
+test("waitForHttp reports when the child exits before becoming ready", async () => {
+    const proc = spawnLogged(process.execPath, ["-e", "process.exit(1)"]);
+    await assert.rejects(() => waitForHttp("http://127.0.0.1:1/", proc, { timeoutMs: 3000, label: "shortlived" }), /exited|failed to start/);
+});

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@fusionkit/cli",
+  "private": false,
+  "version": "0.1.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/velum-labs/handoffkit.git",
+    "directory": "packages/cli"
+  },
+  "description": "fusionkit — real model fusion behind your coding agent (codex, claude, cursor).",
+  "license": "UNLICENSED",
+  "type": "module",
+  "bin": {
+    "fusionkit": "./dist/index.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./render": {
+      "types": "./dist/render.d.ts",
+      "default": "./dist/render.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public",
+    "provenance": true
+  },
+  "dependencies": {
+    "commander": "14.0.3",
+    "@fusionkit/handoff": "0.1.0",
+    "@fusionkit/model-gateway": "0.1.0",
+    "@fusionkit/runner": "0.1.0",
+    "@fusionkit/plane": "0.1.0",
+    "@fusionkit/ensemble": "0.1.0",
+    "@fusionkit/protocol": "0.1.0",
+    "@fusionkit/workspace": "0.1.0",
+    "@fusionkit/sdk": "0.1.0"
+  },
+  "devDependencies": {
+    "@fusionkit/testkit": "0.1.0"
+  }
+}