cueloop 0.1.0-alpha.80 → 0.1.0-alpha.81

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cueloop",
-  "version": "0.1.0-alpha.80",
+  "version": "0.1.0-alpha.81",
   "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": {
@@ -27,13 +27,15 @@
     "access": "public"
   },
   "scripts": {
-    "build:binary": "bun build --compile --external cpu-features ./src/main.ts --outfile dist/cueloop"
+    "build:binary": "bun build --compile --minify --external cpu-features ./src/main.ts --outfile dist/cueloop"
   },
   "dependencies": {
-    "@cueloop/adapters": "0.1.0-alpha.80",
-    "@cueloop/client": "0.1.0-alpha.80",
-    "@cueloop/daemon": "0.1.0-alpha.80",
-    "@cueloop/schema": "0.1.0-alpha.80",
+    "@cueloop/adapters": "0.1.0-alpha.81",
+    "@cueloop/client": "0.1.0-alpha.81",
+    "@cueloop/daemon": "0.1.0-alpha.81",
+    "@cueloop/schema": "0.1.0-alpha.81",
+    "@modelcontextprotocol/server": "2.0.0",
+    "@valibot/to-json-schema": "1.4.0",
     "valibot": "^1.4.2"
   },
   "engines": {

package/src/codex-hook-command.ts

@@ -0,0 +1,21 @@
+import { CodexHookInputSchema, runCodexHook } from "@cueloop/adapters/codex/hook";
+import * as v from "valibot";
+
+/** Read one Codex lifecycle event and return its optional tool rewrite. */
+export async function codexHookCommand(): Promise<number> {
+  try {
+    const input = v.parse(
+      CodexHookInputSchema,
+      JSON.parse(await new Response(Bun.stdin.stream()).text()),
+    );
+    const output = runCodexHook(input);
+
+    if (output) console.log(JSON.stringify(output));
+
+    return 0;
+  } catch (error) {
+    console.error(`cueloop Codex hook failed: ${String(error)}`);
+
+    return 1;
+  }
+}

package/src/codex-mcp-command.ts

@@ -0,0 +1,104 @@
+import { McpServer } from "@modelcontextprotocol/server";
+import { serveStdio } from "@modelcontextprotocol/server/stdio";
+import { toJsonSchema } from "@valibot/to-json-schema";
+import * as v from "valibot";
+import { createCodexDeliveryService } from "@cueloop/adapters/codex/delivery-service";
+import { createCodexSessionRegistry } from "@cueloop/adapters/codex/session-registry";
+import { runHarnessBridge } from "@cueloop/adapters/harness-bridge";
+import { cueloopHome } from "@cueloop/daemon/paths";
+import { WORKFLOW_KINDS } from "@cueloop/schema";
+import { CLI_VERSION } from "./version";
+
+const OpenThreadInputSchema = v.object({
+  workflow: v.picklist(WORKFLOW_KINDS),
+  content: v.optional(v.string()),
+  proposal: v.optional(v.string()),
+  pullRequestReference: v.optional(v.string()),
+  title: v.optional(v.string()),
+  harnessSessionId: v.pipe(v.string(), v.minLength(1)),
+  cwd: v.string(),
+  hookToken: v.pipe(v.string(), v.minLength(1)),
+});
+const RefineCorpusInputSchema = v.object({});
+
+function mcpInputSchema<TSchema extends v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>>(
+  schema: TSchema,
+) {
+  const convert = () => toJsonSchema(schema);
+
+  return {
+    ...schema,
+    "~standard": {
+      ...schema["~standard"],
+      jsonSchema: { input: convert, output: convert },
+    },
+  };
+}
+
+/** Expose the shared Thread workflows to a standard Codex session. */
+export function createCodexMcpServer(home = cueloopHome()): McpServer {
+  const server = new McpServer({ name: "cueloop", version: CLI_VERSION });
+  const sessions = createCodexSessionRegistry(home);
+
+  server.registerTool(
+    "open_thread",
+    {
+      description:
+        "Submit or revise a cueloop Thread for plan, reply, prototype, diff, review, or refine.",
+      inputSchema: mcpInputSchema(OpenThreadInputSchema),
+    },
+    async (input) => {
+      try {
+        if (!sessions.authorized(input.harnessSessionId, input.cwd, input.hookToken)) {
+          throw new Error(
+            "cueloop Codex session is not authorized; trust the plugin hooks and restart Codex",
+          );
+        }
+        const { hookToken: _hookToken, ...threadInput } = input;
+        const result = await runHarnessBridge(
+          { operation: "open", harness: "codex", ...threadInput },
+          home,
+        );
+
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { isError: true, content: [{ type: "text", text: String(error) }] };
+      }
+    },
+  );
+  server.registerTool(
+    "refine_corpus",
+    {
+      description: "Analyze past cueloop Threads before proposing a refine writeback.",
+      inputSchema: mcpInputSchema(RefineCorpusInputSchema),
+    },
+    async () => {
+      try {
+        const result = await runHarnessBridge({ operation: "refine" }, home);
+
+        return {
+          content: [{ type: "text", text: result.operation === "refine" ? result.report : "" }],
+        };
+      } catch (error) {
+        return { isError: true, content: [{ type: "text", text: String(error) }] };
+      }
+    },
+  );
+
+  return server;
+}
+
+/** Keep the MCP transport and durable Codex Message poller alive together. */
+export async function codexMcpCommand(): Promise<number> {
+  const delivery = createCodexDeliveryService();
+
+  delivery.start();
+  const server = serveStdio(() => createCodexMcpServer(), {
+    onerror: (error) => console.error(`cueloop Codex MCP: ${String(error)}`),
+  });
+  await new Promise<void>((resolve) => process.stdin.once("end", resolve));
+  delivery.stop();
+  await server.close();
+
+  return 0;
+}

package/src/harness-command.ts

@@ -0,0 +1,16 @@
+import { runHarnessBridge } from "@cueloop/adapters/harness-bridge";
+
+export async function harnessCommand(): Promise<number> {
+  try {
+    const request = JSON.parse(await new Response(Bun.stdin.stream()).text());
+    const response = await runHarnessBridge(request);
+
+    console.log(JSON.stringify(response));
+
+    return 0;
+  } catch (error) {
+    console.error(`cueloop harness bridge failed: ${String(error)}`);
+
+    return 1;
+  }
+}

package/src/main.ts

@@ -112,7 +112,9 @@ const commandHandlers: CommandHandlers = {
   prototype: (rest) => prototypeCommand(rest),
   serve: (rest) => serveEntry(rest),
   share: (rest) => shareEntry(rest),
-  wake: async (rest) => (await import("./wake-command")).wakeCommand(rest),
+  harness: async () => (await import("./harness-command")).harnessCommand(),
+  "codex-hook": async () => (await import("./codex-hook-command")).codexHookCommand(),
+  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),
@@ -344,7 +346,6 @@ 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 wake <id> [--harness codex --thread <id>]  resume the agent with the message (spawn detached)",
       "  cueloop review-post <id> <pr>    post a resolved session's message back to the PR",
       "  cueloop daemon                   run the daemon in the foreground",
       "  cueloop stop                     stop the local daemon",

package/src/pr.ts

@@ -8,8 +8,8 @@
 
 import type { Thread } from "@cueloop/schema";
 import { join } from "node:path";
-import { GitHubForgeReviewPort } from "@cueloop/adapters/forge-review";
-import { DeliveredMessageStore } from "@cueloop/adapters/delivered-message-store";
+import { createGitHubForgeReviewPort } from "@cueloop/adapters/forge-review";
+import { createDeliveredMessageStore } from "@cueloop/adapters/delivered-message-store";
 import { DaemonClient } from "@cueloop/daemon/client";
 import { cueloopHome } from "@cueloop/daemon/paths";
 import { openReview } from "@cueloop/daemon/thread-review";
@@ -20,9 +20,9 @@ function ghBin(): string {
   return process.env.CUELOOP_GH || "gh";
 }
 
-function forge(): GitHubForgeReviewPort {
-  return new GitHubForgeReviewPort(
-    new DeliveredMessageStore(join(cueloopHome(), "forge-delivered-messages.json")),
+function forge(): ReturnType<typeof createGitHubForgeReviewPort> {
+  return createGitHubForgeReviewPort(
+    createDeliveredMessageStore(join(cueloopHome(), "forge-delivered-messages.json")),
     ghBin(),
   );
 }

package/src/refine-command.ts

@@ -1,7 +1,10 @@
 /** CLI wrapper around the shared corpus analysis used by harness refine workflows. */
 
 import { cueloopHome } from "@cueloop/daemon/paths";
-import { LocalRefineCorpusPort } from "@cueloop/adapters/refine-corpus";
+import {
+  createLocalRefineCorpusPort,
+  type RefineCorpusAnalysis,
+} from "@cueloop/adapters/refine-corpus";
 import { DaemonClient } from "@cueloop/daemon/client";
 import { parseArgs, stringFlag } from "./args";
 
@@ -11,10 +14,10 @@ export async function refineCommand(argv: string[]): Promise<number> {
   const home = stringFlag(flags, "home") ?? cueloopHome();
   const rawLimit = stringFlag(flags, "limit");
   const client = await DaemonClient.connect({ home, autostart: true });
-  let result: Awaited<ReturnType<LocalRefineCorpusPort["analyzeRefineCorpus"]>>;
+  let result: RefineCorpusAnalysis;
 
   try {
-    const corpus = new LocalRefineCorpusPort(
+    const corpus = createLocalRefineCorpusPort(
       client,
       home,
       rawLimit === undefined ? undefined : Number(rawLimit),

package/src/thread-commands.ts

@@ -7,13 +7,14 @@
 import {
   ARTIFACT_TYPES,
   isArtifactType,
+  manualThreadOpenCommand,
   newAnnotationId,
   type Anchor,
   type Annotation,
 } from "@cueloop/schema";
 import * as v from "valibot";
 import { DaemonClient } from "@cueloop/daemon/client";
-import { openHerdrPaneForReview } from "@cueloop/daemon/herdr-pane";
+import { createTerminalThreadSurfacePort } from "@cueloop/adapters/terminal-thread-surface-port";
 import { openReview, messageResponse } from "@cueloop/daemon/thread-review";
 import { loadConfig, quickActionBody, resolveQuickAction } from "@cueloop/client/config";
 import { slashItemsFrom } from "@cueloop/client/slash-palette";
@@ -61,8 +62,16 @@ async function sessionCreate({ client, flags }: SessionContext): Promise<number>
     notes,
   });
 
-  // herdr auto-open: render the review in a tab (no-op outside herdr).
-  await openHerdrPaneForReview(review.session, client);
+  const panel = review.session.artifact.type === "diff" ? "changes" : "thread";
+  const openResult = await createTerminalThreadSurfacePort(client).openThreads(
+    review.id,
+    panel,
+    review.session,
+  );
+
+  if (openResult !== "opened" && openResult !== "focused") {
+    console.error(manualThreadOpenCommand(review.id));
+  }
   out(review.session);
 
   return 0;

package/src/wake-command.test.ts

@@ -1,14 +0,0 @@
-/** cueloop wake argument guards: a missing session id and a codex wake without a thread id both fail with a usage code before any daemon or harness work. */
-
-import { describe, expect, test } from "bun:test";
-import { wakeCommand } from "./wake-command";
-
-describe("wakeCommand argument guards", () => {
-  test("a missing session id is a usage error", async () => {
-    expect(await wakeCommand([])).toBe(2);
-  });
-
-  test("a codex wake without a thread id is a usage error", async () => {
-    expect(await wakeCommand(["ses_1", "--harness", "codex"])).toBe(2);
-  });
-});

package/src/wake-command.ts

@@ -1,44 +0,0 @@
-/**
- * `cueloop wake <session-id>` - the production caller for the non-blocking wake.
- * A detached child of a coding-agent session parks on the review's message and
- * injects it back into that same live session when the human decides, so the
- * agent resumes itself without a blocked, pinned tool call. The plan skill (and
- * the Claude Code hook's non-blocking path) spawn this right after a
- * non-blocking review:  `cueloop wake <session-id> &`.
- *
- * Claude Code is the default and reads its inbox socket from the environment.
- * Codex needs its running thread id (`--harness codex --thread <thread-id>`).
- * pi wakes in-process from its extension and does not use this command.
- */
-
-import { parseArgs, stringFlag } from "./args";
-
-export async function wakeCommand(argv: string[]): Promise<number> {
-  const { positional, flags } = parseArgs(argv);
-  const sessionId = positional[0];
-
-  if (sessionId === undefined) {
-    console.error(
-      "usage: cueloop wake <session-id> [--harness claude-code|codex] [--thread <codex-thread-id>]",
-    );
-
-    return 2;
-  }
-  const harness = stringFlag(flags, "harness") ?? "claude-code";
-
-  if (harness === "codex") {
-    const threadId = stringFlag(flags, "thread");
-
-    if (threadId === undefined) {
-      console.error("cueloop wake --harness codex needs --thread <codex-thread-id>");
-
-      return 2;
-    }
-    const { runCodexWake } = await import("@cueloop/adapters/codex/wake");
-
-    return (await runCodexWake(sessionId, threadId)) ? 0 : 1;
-  }
-  const { runInboxWake } = await import("@cueloop/adapters/claude-code/wake");
-
-  return (await runInboxWake(sessionId)) ? 0 : 1;
-}