cueloop 0.1.0-alpha.89 → 0.1.0-alpha.90

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cueloop",
-  "version": "0.1.0-alpha.89",
+  "version": "0.1.0-alpha.90",
   "description": "Terminal review surface for coding agents: annotate plans and diffs, return a message, send structured feedback back",
   "homepage": "https://github.com/mmurakaru/cueloop#readme",
   "bugs": {
@@ -30,10 +30,11 @@
     "build:binary": "bun build --compile --minify --external cpu-features ./src/main.ts --outfile dist/cueloop"
   },
   "dependencies": {
-    "@cueloop/adapters": "0.1.0-alpha.89",
-    "@cueloop/client": "0.1.0-alpha.89",
-    "@cueloop/daemon": "0.1.0-alpha.89",
-    "@cueloop/schema": "0.1.0-alpha.89",
+    "@cueloop/adapters": "0.1.0-alpha.90",
+    "@cueloop/client": "0.1.0-alpha.90",
+    "@cueloop/daemon": "0.1.0-alpha.90",
+    "@cueloop/extension-api": "0.1.0-alpha.90",
+    "@cueloop/schema": "0.1.0-alpha.90",
     "@modelcontextprotocol/server": "2.0.0",
     "@valibot/to-json-schema": "1.4.0",
     "valibot": "^1.5.0"

package/src/codex-delivery-worker-command.test.ts

@@ -0,0 +1,69 @@
+import { afterEach, expect, test } from "bun:test";
+import { chmodSync, existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { DaemonServer } from "@cueloop/daemon";
+import { DaemonClient } from "@cueloop/daemon/client";
+import { createCodexSessionRegistry } from "@cueloop/adapters/codex/session-registry";
+import { runHarnessBridge } from "@cueloop/adapters/harness-bridge";
+import { startCodexDeliveryWorker } from "./codex-delivery-worker-command";
+
+const home = mkdtempSync(join(tmpdir(), "cueloop-codex-worker-"));
+const server = new DaemonServer({ home, idleExitMs: 0 });
+const codexBin = join(home, "codex");
+let worker: ReturnType<typeof Bun.spawn> | undefined;
+
+afterEach(async () => {
+  worker?.kill();
+  await worker?.exited;
+  server.stop();
+  rmSync(home, { recursive: true, force: true });
+});
+
+test("a Codex reply is delivered without an MCP transport", async () => {
+  server.start();
+  writeFileSync(codexBin, '#!/bin/sh\nprintf "%s" "$5" > delivered.txt\n');
+  chmodSync(codexBin, 0o755);
+  createCodexSessionRegistry(home).activate("codex-session-1");
+  const opened = await runHarnessBridge(
+    {
+      operation: "open",
+      harness: "codex",
+      harnessSessionId: "codex-session-1",
+      cwd: home,
+      workflow: "plan",
+      content: "# Wait for feedback",
+    },
+    home,
+  );
+
+  if (opened.operation !== "open") throw new Error("expected open Thread");
+  const previousCodexBin = process.env.CUELOOP_CODEX_BIN;
+
+  // A reused PID belonging to this test process must not impersonate the worker.
+  writeFileSync(join(home, "codex-delivery-worker.pid"), String(process.pid));
+  process.env.CUELOOP_CODEX_BIN = codexBin;
+  worker = startCodexDeliveryWorker(home, [
+    process.execPath,
+    "run",
+    import.meta.dir + "/main.ts",
+    "codex-delivery-worker",
+  ]);
+  if (previousCodexBin === undefined) delete process.env.CUELOOP_CODEX_BIN;
+  else process.env.CUELOOP_CODEX_BIN = previousCodexBin;
+  expect(worker).toBeDefined();
+  const deadline = Date.now() + 5000;
+
+  while (!existsSync(join(home, "codex-delivery-worker.pid")) && Date.now() < deadline)
+    await Bun.sleep(20);
+  expect(existsSync(join(home, "codex-delivery-worker.pid"))).toBe(true);
+  const client = await DaemonClient.connect({ home });
+
+  try {
+    await client.sessionSendMessage(opened.threadId, "approved", "Continue after MCP exit.");
+    while (!existsSync(join(home, "delivered.txt")) && Date.now() < deadline) await Bun.sleep(20);
+    expect(readFileSync(join(home, "delivered.txt"), "utf8")).toContain("Continue after MCP exit.");
+  } finally {
+    client.close();
+  }
+});

package/src/codex-delivery-worker-command.ts

@@ -0,0 +1,99 @@
+import { closeSync, openSync, readFileSync, statSync, unlinkSync, writeSync } from "node:fs";
+import { join } from "node:path";
+import { createCodexDeliveryService } from "@cueloop/adapters/codex/delivery-service";
+import { createCodexSessionRegistry } from "@cueloop/adapters/codex/session-registry";
+import { cueloopHome } from "@cueloop/daemon/paths";
+
+const EMPTY_SESSION_GRACE_MS = 30_000;
+
+function claimWorker(path: string): boolean {
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      const descriptor = openSync(path, "wx", 0o600);
+
+      writeSync(descriptor, String(process.pid));
+      closeSync(descriptor);
+
+      return true;
+    } catch (error) {
+      if (!(error instanceof Error && "code" in error && error.code === "EEXIST")) throw error;
+      const before = statSync(path);
+      const owner = Number(readFileSync(path, "utf8"));
+
+      if (Number.isSafeInteger(owner) && owner > 0) {
+        try {
+          process.kill(owner, 0);
+          const command = Bun.spawnSync(["ps", "-p", String(owner), "-o", "command="], {
+            stdout: "pipe",
+            stderr: "ignore",
+          });
+
+          if (
+            command.exitCode === 0 &&
+            /(?:^|\s)codex-delivery-worker(?:\s|$)/.test(command.stdout.toString())
+          )
+            return false;
+        } catch (cause) {
+          if (!(cause instanceof Error && "code" in cause && cause.code === "ESRCH")) return false;
+        }
+      } else if (Date.now() - before.mtimeMs < 5_000) {
+        return false;
+      }
+      if (statSync(path).ino !== before.ino) return false;
+      unlinkSync(path);
+    }
+  }
+
+  return false;
+}
+
+/** Run durable Codex Message delivery after the MCP transport has closed. */
+export async function codexDeliveryWorkerCommand(): Promise<number> {
+  const home = cueloopHome();
+  const lockPath = join(home, "codex-delivery-worker.pid");
+
+  if (!claimWorker(lockPath)) return 0;
+  const sessions = createCodexSessionRegistry(home);
+  const delivery = createCodexDeliveryService({
+    home,
+    codexBin: process.env.CUELOOP_CODEX_BIN,
+  });
+  let emptySince: number | undefined;
+
+  try {
+    delivery.start();
+    while (true) {
+      await Bun.sleep(1000);
+      emptySince = sessions.list().length === 0 ? (emptySince ?? Date.now()) : undefined;
+
+      if (emptySince !== undefined && Date.now() - emptySince >= EMPTY_SESSION_GRACE_MS) break;
+    }
+  } finally {
+    delivery.stop();
+    if (readFileSync(lockPath, "utf8") === String(process.pid)) unlinkSync(lockPath);
+  }
+
+  return 0;
+}
+
+/** The child owns the poller, so MCP transport shutdown does not stop delivery. */
+export function startCodexDeliveryWorker(
+  home: string,
+  command = [...process.argv.slice(0, -1), "codex-delivery-worker"],
+): ReturnType<typeof Bun.spawn> | undefined {
+  try {
+    const child = Bun.spawn(command, {
+      env: { ...process.env, CUELOOP_HOME: home },
+      stdin: "ignore",
+      stdout: "ignore",
+      stderr: "ignore",
+      detached: true,
+    });
+
+    child.unref();
+
+    return child;
+  } catch (error) {
+    console.error(`cueloop Codex delivery worker: ${String(error)}`);
+  }
+}

package/src/codex-mcp-command.ts

@@ -8,6 +8,7 @@ import { runHarnessBridge } from "@cueloop/adapters/harness-bridge";
 import { cueloopHome } from "@cueloop/daemon/paths";
 import { WORKFLOW_KINDS } from "@cueloop/schema";
 import { CLI_VERSION } from "./version";
+import { startCodexDeliveryWorker } from "./codex-delivery-worker-command";
 
 const OpenThreadInputSchema = v.object({
   workflow: v.picklist(WORKFLOW_KINDS),
@@ -60,6 +61,8 @@ export function createCodexMcpServer(home = cueloopHome()): McpServer {
           home,
         );
 
+        if (result.operation === "open") startCodexDeliveryWorker(home);
+
         return { content: [{ type: "text", text: JSON.stringify(result) }] };
       } catch (error) {
         return { isError: true, content: [{ type: "text", text: String(error) }] };

package/src/install-command.test.ts

@@ -0,0 +1,142 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { installExtensionCommand } from "./install-command";
+
+const roots: string[] = [];
+
+afterEach(() => {
+  for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true });
+});
+
+function testRoot(): string {
+  const root = mkdtempSync(join(tmpdir(), "cueloop-install-test-"));
+
+  roots.push(root);
+
+  return root;
+}
+
+describe("cueloop install", () => {
+  test("rejects sources outside npm without running a package command", async () => {
+    const root = testRoot();
+    let called = false;
+
+    expect(
+      await installExtensionCommand(["file:./extension"], {
+        installRoot: root,
+        runPackageCommand: async () => {
+          called = true;
+
+          return { exitCode: 0, stderr: "" };
+        },
+      }),
+    ).toBe(2);
+    expect(called).toBe(false);
+  });
+
+  test("installs a package whose manifest declares a client entry", async () => {
+    const root = testRoot();
+    const commands: string[][] = [];
+    const result = await installExtensionCommand(["npm:@example/tools@1.0.0"], {
+      installRoot: root,
+      runPackageCommand: async (args) => {
+        commands.push(args);
+        const packageRoot = join(root, "node_modules", "@example/tools");
+
+        mkdirSync(packageRoot, { recursive: true });
+        writeFileSync(
+          join(root, "package.json"),
+          JSON.stringify({ dependencies: { "@example/tools": "1.0.0" } }),
+        );
+        writeFileSync(
+          join(packageRoot, "package.json"),
+          JSON.stringify({ cueloop: { client: "./client.js" } }),
+        );
+        writeFileSync(join(packageRoot, "client.js"), "export default () => {};");
+
+        return { exitCode: 0, stderr: "" };
+      },
+    });
+
+    expect(result).toBe(0);
+    expect(commands).toEqual([["add", "--ignore-scripts", "--cwd", root, "@example/tools@1.0.0"]]);
+    expect(JSON.parse(readFileSync(join(root, "package.json"), "utf8")).dependencies).toEqual({
+      "@example/tools": "1.0.0",
+    });
+  });
+
+  test("removes a package without a cueloop manifest", async () => {
+    const root = testRoot();
+    const commands: string[][] = [];
+    const result = await installExtensionCommand(["npm:example"], {
+      installRoot: root,
+      runPackageCommand: async (args) => {
+        commands.push(args);
+        if (args[0] === "add") {
+          const packageRoot = join(root, "node_modules", "example");
+
+          mkdirSync(packageRoot, { recursive: true });
+          writeFileSync(
+            join(root, "package.json"),
+            JSON.stringify({ dependencies: { example: "1.0.0" } }),
+          );
+          writeFileSync(join(packageRoot, "package.json"), "{}");
+        }
+
+        return { exitCode: 0, stderr: "" };
+      },
+    });
+
+    expect(result).toBe(1);
+    expect(commands[1]).toEqual(["remove", "--ignore-scripts", "--cwd", root, "example"]);
+  });
+
+  test("restores the prior version after an invalid upgrade", async () => {
+    const root = testRoot();
+    const packageRoot = join(root, "node_modules", "example");
+    const commands: string[][] = [];
+
+    mkdirSync(packageRoot, { recursive: true });
+    writeFileSync(
+      join(root, "package.json"),
+      JSON.stringify({ dependencies: { example: "1.0.0" } }),
+    );
+    writeFileSync(
+      join(packageRoot, "package.json"),
+      JSON.stringify({ version: "1.0.0", cueloop: { client: "./client.js" } }),
+    );
+    writeFileSync(join(packageRoot, "client.js"), "export default () => {};");
+    const result = await installExtensionCommand(["npm:example@2.0.0"], {
+      installRoot: root,
+      runPackageCommand: async (args) => {
+        commands.push(args);
+        if (args.at(-1) === "example@2.0.0") {
+          writeFileSync(
+            join(root, "package.json"),
+            JSON.stringify({ dependencies: { example: "2.0.0" } }),
+          );
+          writeFileSync(join(packageRoot, "package.json"), JSON.stringify({ version: "2.0.0" }));
+        } else {
+          writeFileSync(
+            join(root, "package.json"),
+            JSON.stringify({ dependencies: { example: "1.0.0" } }),
+          );
+          writeFileSync(
+            join(packageRoot, "package.json"),
+            JSON.stringify({ version: "1.0.0", cueloop: { client: "./client.js" } }),
+          );
+        }
+
+        return { exitCode: 0, stderr: "" };
+      },
+    });
+
+    expect(result).toBe(1);
+    expect(commands[1]).toEqual(["add", "--ignore-scripts", "--cwd", root, "example@1.0.0"]);
+    expect(JSON.parse(readFileSync(join(root, "package.json"), "utf8")).dependencies.example).toBe(
+      "1.0.0",
+    );
+  });
+});

package/src/install-command.ts

@@ -0,0 +1,114 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import * as v from "valibot";
+import {
+  discoverInstalledExtensionPackages,
+  extensionInstallRoot,
+} from "@cueloop/extension-api/installed-packages";
+
+const NPM_PACKAGE_SOURCE = /^npm:((?:@[a-z0-9_.-]+\/)?[a-z0-9_.-]+)(?:@([^\s/]+))?$/i;
+
+interface PackageCommandResult {
+  exitCode: number;
+  stderr: string;
+}
+
+interface InstallOptions {
+  installRoot?: string;
+  runPackageCommand?: (args: string[]) => Promise<PackageCommandResult>;
+}
+
+async function runPackageCommand(args: string[]): Promise<PackageCommandResult> {
+  // A compiled executable can invoke its bundled Bun CLI without `bun` on PATH.
+  const child = Bun.spawn([process.execPath, ...args], {
+    env: { ...process.env, BUN_BE_BUN: "1" },
+    stdout: "ignore",
+    stderr: "pipe",
+  });
+  const [exitCode, stderr] = await Promise.all([child.exited, new Response(child.stderr).text()]);
+
+  return { exitCode, stderr };
+}
+
+function previousPackageSpec(installRoot: string, name: string): string | null {
+  const path = join(installRoot, "node_modules", name, "package.json");
+
+  if (!existsSync(path)) return null;
+  try {
+    const parsed = v.safeParse(
+      v.object({ version: v.pipe(v.string(), v.minLength(1)) }),
+      JSON.parse(readFileSync(path, "utf8")),
+    );
+
+    return parsed.success ? `${name}@${parsed.output.version}` : null;
+  } catch {
+    return null;
+  }
+}
+
+/** Install a user-level npm extension after checking its declared entry points. */
+export async function installExtensionCommand(
+  argv: string[],
+  options: InstallOptions = {},
+): Promise<number> {
+  const source = argv[0];
+  const match = source?.match(NPM_PACKAGE_SOURCE);
+
+  if (argv.length !== 1 || !match) {
+    console.error("cueloop install: expected npm:<package>[@version]");
+
+    return 2;
+  }
+  const name = match[1]!;
+  const spec = source!.slice("npm:".length);
+  const installRoot = options.installRoot ?? extensionInstallRoot();
+  const runCommand = options.runPackageCommand ?? runPackageCommand;
+  const previousSpec = previousPackageSpec(installRoot, name);
+
+  mkdirSync(installRoot, { recursive: true });
+  const rootManifest = join(installRoot, "package.json");
+
+  if (!existsSync(rootManifest)) {
+    writeFileSync(
+      rootManifest,
+      JSON.stringify({ name: "cueloop-extensions", private: true }, null, 2),
+    );
+  }
+  const { exitCode, stderr } = await runCommand([
+    "add",
+    "--ignore-scripts",
+    "--cwd",
+    installRoot,
+    spec,
+  ]);
+
+  if (exitCode !== 0) {
+    console.error(`cueloop install: ${stderr.trim() || "bun add failed"}`);
+
+    return 1;
+  }
+  const discovered = discoverInstalledExtensionPackages(installRoot);
+  const installed = discovered.packages.find((entry) => entry.name === name);
+
+  if (!installed) {
+    const error = discovered.errors.find((message) => message.includes(` ${name}:`));
+    console.error(`cueloop install: ${error ?? `extension ${name} has no valid cueloop manifest`}`);
+    const restored = await runCommand(
+      previousSpec
+        ? ["add", "--ignore-scripts", "--cwd", installRoot, previousSpec]
+        : ["remove", "--ignore-scripts", "--cwd", installRoot, name],
+    );
+
+    if (restored.exitCode !== 0)
+      console.error(
+        `cueloop install: could not restore ${previousSpec ?? name}: ${restored.stderr.trim()}`,
+      );
+
+    return 1;
+  }
+  console.log(
+    `Installed ${name}. Restart cueloop and run 'cueloop restart' to load daemon capabilities.`,
+  );
+
+  return 0;
+}

package/src/main.ts

@@ -114,10 +114,13 @@ const commandHandlers: CommandHandlers = {
   share: (rest) => shareEntry(rest),
   harness: async () => (await import("./harness-command")).harnessCommand(),
   "codex-hook": async () => (await import("./codex-hook-command")).codexHookCommand(),
+  "codex-delivery-worker": async () =>
+    (await import("./codex-delivery-worker-command")).codexDeliveryWorkerCommand(),
   mcp: async () => (await import("./codex-mcp-command")).codexMcpCommand(),
   actions: async (rest) => (await import("./actions-command")).actionsCommand(rest),
   refine: async (rest) => (await import("./refine-command")).refineCommand(rest),
   update: async (rest) => (await import("./update-command")).updateCommand(rest),
+  install: async (rest) => (await import("./install-command")).installExtensionCommand(rest),
   review: (rest) => reviewEntry(rest),
   "review-config": async () => (await import("./pr")).reviewConfigCommand(),
   "review-comment": async (rest) => (await import("./pr")).reviewCommentCommand(rest),
@@ -349,6 +352,7 @@ function printHelp(): void {
       "  cueloop actions list             list the quick-action vocabulary (for annotate --action)",
       "  cueloop refine                   mine past reviews into a markdown report + writeback proposals",
       "  cueloop update [--dry-run]       update the installed cueloop binary (--dry-run reports the target only)",
+      "  cueloop install npm:<package>    install a user-level extension package",
       "  cueloop review-post <id>         explicitly post selected agent findings to the PR",
       "  cueloop review-comment <id>      add or update an agent PR finding (see --help)",
       "  cueloop daemon                   run the daemon in the foreground",

package/src/thread-commands.ts

@@ -55,6 +55,7 @@ async function sessionCreate({ client, flags }: SessionContext): Promise<number>
     type,
     content,
     cwd: stringFlag(flags, "cwd"),
+    vcs: stringFlag(flags, "vcs"),
     agent: stringFlag(flags, "agent"),
     agentSessionId: stringFlag(flags, "agent-session-id"),
     planPath: stringFlag(flags, "plan-path"),
@@ -420,8 +421,26 @@ async function sessionSubmitRevisionCommand({
     .split(",")
     .map((annotationId) => annotationId.trim())
     .filter(Boolean);
+  const session = await client.sessionGet(id);
+  let files;
+  let source;
+
+  if (session.artifact.type === "diff" && session.artifact.meta.pr === undefined) {
+    files = [];
+    try {
+      const captured = await client.repoDiff(session.workspace.repoRoot, session.artifact.meta.vcs);
+
+      if (captured.patch.replace(/\n+$/, "") === content.replace(/\n+$/, "")) {
+        files = captured.files;
+        source =
+          captured.source && captured.vcs ? { vcs: captured.vcs, ...captured.source } : undefined;
+      }
+    } catch {
+      // Keep a supplied patch reviewable without attaching stale file contents.
+    }
+  }
 
-  out(await client.sessionSubmitRevision(id, content, addressed));
+  out(await client.sessionSubmitRevision(id, content, addressed, files, source));
 
   return 0;
 }