opencara 0.101.0 → 0.103.0

package/dist/opencara-mcp.js

@@ -0,0 +1,467 @@
+#!/usr/bin/env node
+
+// src/bin/opencara-mcp.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { env, exit, stderr } from "node:process";
+
+// src/mcp/ipc.ts
+import { createServer, createConnection } from "node:net";
+var IPC_SOCKET_ENV = "OPENCARA_MCP_IPC_SOCKET";
+function encode(frame) {
+  return JSON.stringify(frame) + "\n";
+}
+function decode(buffered, chunk) {
+  const buf = buffered + chunk;
+  const lines = buf.split("\n");
+  const remainder = lines.pop() ?? "";
+  const frames = [];
+  const malformed = [];
+  for (const line of lines) {
+    const t = line.trim();
+    if (t.length === 0) continue;
+    try {
+      const parsed = JSON.parse(t);
+      if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) && "type" in parsed && (parsed.type === "tool-call" || parsed.type === "tool-result")) {
+        frames.push(parsed);
+      } else {
+        malformed.push(t);
+      }
+    } catch {
+      malformed.push(t);
+    }
+  }
+  return { frames, malformed, buffered: remainder };
+}
+var IpcClient = class {
+  constructor(socketPath) {
+    this.socketPath = socketPath;
+  }
+  socketPath;
+  socket = null;
+  buffered = "";
+  nextCallId = 1;
+  pending = /* @__PURE__ */ new Map();
+  async connect() {
+    await new Promise((resolve, reject) => {
+      const socket = createConnection({ path: this.socketPath }, () => {
+        this.socket = socket;
+        socket.setEncoding("utf8");
+        socket.on("data", (chunk) => this.onData(chunk));
+        socket.on("close", () => this.onClose("socket closed"));
+        socket.on("error", (err) => this.onClose(`socket error: ${err.message}`));
+        resolve();
+      });
+      socket.once("error", (err) => {
+        if (!this.socket) reject(err);
+      });
+    });
+  }
+  /** Mint a callId and round-trip a tool-call. */
+  async call(kind, args) {
+    if (!this.socket) throw new Error("ipc client not connected");
+    const callId = `c${this.nextCallId++}`;
+    const frame = { type: "tool-call", callId, kind, args };
+    return new Promise((resolve, reject) => {
+      this.pending.set(callId, { resolve, reject });
+      this.socket.write(encode(frame));
+    });
+  }
+  close() {
+    this.onClose("close()");
+    if (this.socket) {
+      this.socket.end();
+      this.socket = null;
+    }
+  }
+  onData(chunk) {
+    const d = decode(this.buffered, chunk);
+    this.buffered = d.buffered;
+    for (const frame of d.frames) {
+      if (frame.type === "tool-result") {
+        const p = this.pending.get(frame.callId);
+        if (p) {
+          this.pending.delete(frame.callId);
+          p.resolve(frame.result);
+        }
+      }
+    }
+  }
+  onClose(reason) {
+    if (this.pending.size === 0) return;
+    const err = new Error(`ipc client disconnected: ${reason}`);
+    for (const p of this.pending.values()) p.reject(err);
+    this.pending.clear();
+  }
+};
+
+// src/mcp/tools.ts
+import "zod";
+
+// ../shared/dist/events.js
+import { z } from "zod";
+var PlatformSchema = z.enum(["github"]);
+var PlatformEventSchema = z.object({
+  id: z.string(),
+  platform: PlatformSchema,
+  type: z.string(),
+  receivedAt: z.string().datetime(),
+  payload: z.unknown()
+});
+
+// ../shared/dist/agent.js
+import { z as z2 } from "zod";
+var AgentRunStatusSchema = z2.enum([
+  "queued",
+  "assigned",
+  "running",
+  "succeeded",
+  "failed",
+  "cancelled"
+]);
+var AcpHistoryTurnSchema = z2.object({
+  role: z2.enum(["user", "assistant"]),
+  text: z2.string()
+});
+var AcpSpecSchema = z2.object({
+  systemPromptMd: z2.string(),
+  userPromptMd: z2.string(),
+  history: z2.array(AcpHistoryTurnSchema).default([]),
+  pageContextJson: z2.string().optional()
+});
+var AgentSpecSchema = z2.object({
+  kind: z2.string(),
+  command: z2.string(),
+  args: z2.array(z2.string()).default([]),
+  env: z2.record(z2.string()).default({}),
+  cwd: z2.string().optional(),
+  /**
+   * Present iff this run goes through the ACP+MCP path. Mutually exclusive
+   * with the legacy stdin-JSON envelope — when set, `JobAssignment.stdinJson`
+   * is ignored by the device runner.
+   */
+  acp: AcpSpecSchema.optional()
+});
+var AgentRunSchema = z2.object({
+  id: z2.string(),
+  spec: AgentSpecSchema,
+  triggerEventId: z2.string().optional(),
+  status: AgentRunStatusSchema,
+  hostId: z2.string().nullable(),
+  createdAt: z2.string().datetime(),
+  startedAt: z2.string().datetime().nullable(),
+  finishedAt: z2.string().datetime().nullable(),
+  exitCode: z2.number().int().nullable()
+});
+
+// ../shared/dist/host-protocol.js
+import { z as z3 } from "zod";
+var PairingCreateRequestSchema = z3.object({
+  device_secret_hash: z3.string()
+});
+var PairingCreateResponseSchema = z3.object({
+  code: z3.string(),
+  expires_at: z3.string().datetime()
+});
+var PairingStatusResponseSchema = z3.union([
+  z3.object({ status: z3.literal("pending") }),
+  z3.object({
+    status: z3.literal("confirmed"),
+    token: z3.string(),
+    agent_host_id: z3.string(),
+    device_name: z3.string()
+  }),
+  z3.object({ status: z3.literal("expired") })
+]);
+var PairingConfirmRequestSchema = z3.object({
+  device_name: z3.string().min(1)
+});
+var SystemInfoSchema = z3.object({
+  os: z3.string(),
+  // os.platform()
+  release: z3.string(),
+  // os.release()
+  arch: z3.string(),
+  // os.arch()
+  hostname: z3.string(),
+  cpu: z3.object({
+    model: z3.string(),
+    cores: z3.number().int().nonnegative(),
+    speedMhz: z3.number().int().nonnegative()
+  }),
+  memory: z3.object({
+    totalBytes: z3.number().nonnegative(),
+    freeBytes: z3.number().nonnegative()
+  }),
+  disk: z3.object({
+    path: z3.string(),
+    totalBytes: z3.number().nonnegative(),
+    freeBytes: z3.number().nonnegative()
+  }).optional(),
+  ipAddrs: z3.array(z3.string()).default([]),
+  uptimeSec: z3.number().nonnegative()
+});
+var HelloMessageSchema = z3.object({
+  type: z3.literal("hello"),
+  platform: z3.string(),
+  version: z3.string(),
+  capabilities: z3.array(z3.string()).default([]),
+  systemInfo: SystemInfoSchema.optional()
+});
+var JobAssignmentSchema = z3.object({
+  type: z3.literal("job"),
+  run: AgentRunSchema,
+  spec: AgentSpecSchema,
+  stdinJson: z3.unknown().optional()
+});
+var LogFrameSchema = z3.object({
+  type: z3.literal("log"),
+  runId: z3.string(),
+  seq: z3.number().int().min(0),
+  stream: z3.enum(["stdout", "stderr"]),
+  chunk: z3.string()
+});
+var RunDoneSchema = z3.object({
+  type: z3.literal("done"),
+  runId: z3.string(),
+  status: z3.enum(["succeeded", "failed", "cancelled"]),
+  exitCode: z3.number().int().nullable().optional(),
+  errorMessage: z3.string().optional()
+});
+var HelloAckSchema = z3.object({
+  type: z3.literal("hello-ack"),
+  agentHostId: z3.string(),
+  deviceName: z3.string()
+});
+var PingSchema = z3.object({ type: z3.literal("ping") });
+var PongSchema = z3.object({ type: z3.literal("pong") });
+var AgentCallEnvelope = {
+  type: z3.literal("agent-call"),
+  runId: z3.string(),
+  callId: z3.string()
+};
+var IssueBodySetCallSchema = z3.object({
+  ...AgentCallEnvelope,
+  kind: z3.literal("issue.body.set"),
+  issueNumber: z3.number().int(),
+  bodyMd: z3.string()
+});
+var FlowNodeConfigSetCallSchema = z3.object({
+  ...AgentCallEnvelope,
+  kind: z3.literal("flow.node.config.set"),
+  flowSlug: z3.string().min(1),
+  nodeId: z3.string().min(1),
+  config: z3.record(z3.string(), z3.unknown())
+});
+var TemplateNodeConfigSetCallSchema = z3.object({
+  ...AgentCallEnvelope,
+  kind: z3.literal("template.node.config.set"),
+  templateSlug: z3.string().min(1),
+  nodeId: z3.string().min(1),
+  config: z3.record(z3.string(), z3.unknown())
+});
+var AgentCallSchema = z3.discriminatedUnion("kind", [
+  IssueBodySetCallSchema,
+  FlowNodeConfigSetCallSchema,
+  TemplateNodeConfigSetCallSchema
+]);
+var AgentCallRequestEnvelope = {
+  type: z3.literal("agent-call-request"),
+  runId: z3.string(),
+  callId: z3.string()
+};
+var IssueBodySetCallRequestSchema = z3.object({
+  ...AgentCallRequestEnvelope,
+  kind: z3.literal("issue.body.set"),
+  issueNumber: z3.number().int(),
+  bodyMd: z3.string()
+});
+var FlowNodeConfigSetCallRequestSchema = z3.object({
+  ...AgentCallRequestEnvelope,
+  kind: z3.literal("flow.node.config.set"),
+  flowSlug: z3.string().min(1),
+  nodeId: z3.string().min(1),
+  config: z3.record(z3.string(), z3.unknown())
+});
+var TemplateNodeConfigSetCallRequestSchema = z3.object({
+  ...AgentCallRequestEnvelope,
+  kind: z3.literal("template.node.config.set"),
+  templateSlug: z3.string().min(1),
+  nodeId: z3.string().min(1),
+  config: z3.record(z3.string(), z3.unknown())
+});
+var AgentCallRequestSchema = z3.discriminatedUnion("kind", [
+  IssueBodySetCallRequestSchema,
+  FlowNodeConfigSetCallRequestSchema,
+  TemplateNodeConfigSetCallRequestSchema
+]);
+var AgentCallResultSchema = z3.object({
+  type: z3.literal("agent-call-result"),
+  runId: z3.string(),
+  callId: z3.string(),
+  result: z3.union([
+    z3.object({ ok: z3.literal(true) }),
+    z3.object({ ok: z3.literal(false), reason: z3.string() })
+  ])
+});
+var ServerToDeviceMessageSchema = z3.discriminatedUnion("type", [
+  JobAssignmentSchema,
+  HelloAckSchema,
+  PingSchema,
+  AgentCallResultSchema
+]);
+var DeviceToServerMessageSchema = z3.union([
+  HelloMessageSchema,
+  LogFrameSchema,
+  RunDoneSchema,
+  PongSchema,
+  AgentCallSchema,
+  AgentCallRequestSchema
+]);
+var HostRegisterRequestSchema = z3.object({
+  hostId: z3.string(),
+  hostName: z3.string(),
+  capabilities: z3.array(z3.string()).default([]),
+  token: z3.string()
+});
+var HostRegisterResponseSchema = z3.object({
+  ok: z3.literal(true),
+  pollIntervalMs: z3.number().int().positive()
+});
+
+// ../shared/dist/issues.js
+import { z as z4 } from "zod";
+var IssueLabelSchema = z4.object({
+  name: z4.string(),
+  color: z4.string()
+});
+var IssueAssigneeSchema = z4.object({
+  login: z4.string(),
+  id: z4.number()
+});
+var IssueSummarySchema = z4.object({
+  id: z4.string(),
+  number: z4.number().int(),
+  title: z4.string(),
+  state: z4.string(),
+  stateReason: z4.string().nullable(),
+  labels: z4.array(IssueLabelSchema),
+  assignees: z4.array(IssueAssigneeSchema),
+  authorLogin: z4.string().nullable(),
+  htmlUrl: z4.string(),
+  createdAt: z4.string().datetime(),
+  updatedAt: z4.string().datetime(),
+  closedAt: z4.string().datetime().nullable()
+});
+var IssueDetailSchema = IssueSummarySchema.extend({
+  bodyMd: z4.string().nullable(),
+  draftBodyMd: z4.string().nullable(),
+  draftUpdatedAt: z4.string().datetime().nullable()
+});
+
+// src/mcp/tools.ts
+var issueBodySetShape = IssueBodySetCallSchema.omit({
+  type: true,
+  runId: true,
+  callId: true,
+  kind: true
+}).shape;
+var flowNodeConfigSetShape = FlowNodeConfigSetCallSchema.omit({
+  type: true,
+  runId: true,
+  callId: true,
+  kind: true
+}).shape;
+var templateNodeConfigSetShape = TemplateNodeConfigSetCallSchema.omit({
+  type: true,
+  runId: true,
+  callId: true,
+  kind: true
+}).shape;
+var TOOLS = [
+  {
+    name: "opencara_issue_body_set",
+    kind: "issue.body.set",
+    title: "Update an issue body draft",
+    description: "Replace the draft Markdown body of an issue in the run's project. The change goes to the draft store \u2014 the user must publish to GitHub from the canvas. Reject with reason if the issue isn't in the run's project scope.",
+    inputShape: issueBodySetShape
+  },
+  {
+    name: "opencara_flow_node_config_set",
+    kind: "flow.node.config.set",
+    title: "Update a flow node's config",
+    description: "Replace the config blob of a node in the named flow within the run's project. Reject with reason if the flow or node doesn't exist or is out of scope.",
+    inputShape: flowNodeConfigSetShape
+  },
+  {
+    name: "opencara_template_node_config_set",
+    kind: "template.node.config.set",
+    title: "Update a flow-template draft node's config",
+    description: "Replace the config blob of a node in the user's draft of the named flow template. Per-user scope, not per-project. Reject with reason if the template draft isn't owned by the run's user.",
+    inputShape: templateNodeConfigSetShape
+  }
+];
+function registerOpencaraTools(server, router) {
+  for (const tool of TOOLS) {
+    server.registerTool(
+      tool.name,
+      {
+        title: tool.title,
+        description: tool.description,
+        inputSchema: tool.inputShape
+      },
+      async (args) => {
+        const result = await router.call(tool.kind, args);
+        if (result.ok) {
+          return {
+            content: [{ type: "text", text: "ok" }]
+          };
+        }
+        return {
+          content: [{ type: "text", text: `rejected: ${result.reason}` }],
+          isError: true
+        };
+      }
+    );
+  }
+}
+var TOOL_NAMES = TOOLS.map((t) => ({ name: t.name, kind: t.kind }));
+
+// src/bin/opencara-mcp.ts
+async function main() {
+  const socketPath = env[IPC_SOCKET_ENV];
+  if (!socketPath) {
+    stderr.write(
+      `[opencara-mcp] missing ${IPC_SOCKET_ENV} env \u2014 this binary is meant to be spawned by the opencara CLI device, not run directly.
+`
+    );
+    exit(2);
+  }
+  const ipc = new IpcClient(socketPath);
+  try {
+    await ipc.connect();
+  } catch (err) {
+    const e = err instanceof Error ? err.message : String(err);
+    stderr.write(`[opencara-mcp] ipc connect failed: ${e}
+`);
+    exit(3);
+  }
+  const router = {
+    async call(kind, args) {
+      return ipc.call(kind, args);
+    }
+  };
+  const server = new McpServer(
+    { name: "opencara", version: "0.0.0" },
+    { capabilities: { tools: {} } }
+  );
+  registerOpencaraTools(server, router);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+main().catch((err) => {
+  const e = err instanceof Error ? err.stack ?? err.message : String(err);
+  stderr.write(`[opencara-mcp] fatal: ${e}
+`);
+  exit(1);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencara",
-  "version": "0.101.0",
+  "version": "0.103.0",
   "description": "OpenCara agent-host CLI: register a machine as an agent host and run dispatched agents.",
   "license": "MIT",
   "repository": {
@@ -11,15 +11,19 @@
   "homepage": "https://opencara.com",
   "type": "module",
   "bin": {
-    "opencara": "./dist/bin.js"
+    "opencara": "./dist/bin.js",
+    "opencara-mcp": "./dist/opencara-mcp.js"
   },
   "main": "./dist/bin.js",
   "files": [
-    "dist/bin.js"
+    "dist/bin.js",
+    "dist/opencara-mcp.js"
   ],
   "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@zed-industries/codex-acp": "^0.13.0",
     "ws": "^8.18.0",
-    "zod": "^3.24.1"
+    "zod": "^3.25.0"
   },
   "devDependencies": {
     "@types/ws": "^8.5.13",
@@ -32,6 +36,9 @@
     "dev": "tsx watch src/bin.ts",
     "start": "node dist/bin.js",
     "typecheck": "tsc -b",
+    "test": "node --import tsx --test --test-reporter=spec src/acp/__tests__/*.test.ts src/mcp/__tests__/*.test.ts src/runner/__tests__/*.test.ts",
+    "acp:spike": "tsx src/acp/spike.ts",
+    "mcp:smoke": "tsx src/mcp/smoke.ts",
     "clean": "rm -rf dist *.tsbuildinfo"
   }
 }