opencara 0.100.3 → 0.102.0

package/dist/bin.js

@@ -177,16 +177,47 @@ var HelloAckSchema = z4.object({
 });
 var PingSchema = z4.object({ type: z4.literal("ping") });
 var PongSchema = z4.object({ type: z4.literal("pong") });
+var AgentCallEnvelope = {
+  type: z4.literal("agent-call"),
+  runId: z4.string(),
+  callId: z4.string()
+};
+var IssueBodySetCallSchema = z4.object({
+  ...AgentCallEnvelope,
+  kind: z4.literal("issue.body.set"),
+  issueNumber: z4.number().int(),
+  bodyMd: z4.string()
+});
+var FlowNodeConfigSetCallSchema = z4.object({
+  ...AgentCallEnvelope,
+  kind: z4.literal("flow.node.config.set"),
+  flowSlug: z4.string().min(1),
+  nodeId: z4.string().min(1),
+  config: z4.record(z4.string(), z4.unknown())
+});
+var TemplateNodeConfigSetCallSchema = z4.object({
+  ...AgentCallEnvelope,
+  kind: z4.literal("template.node.config.set"),
+  templateSlug: z4.string().min(1),
+  nodeId: z4.string().min(1),
+  config: z4.record(z4.string(), z4.unknown())
+});
+var AgentCallSchema = z4.discriminatedUnion("kind", [
+  IssueBodySetCallSchema,
+  FlowNodeConfigSetCallSchema,
+  TemplateNodeConfigSetCallSchema
+]);
 var ServerToDeviceMessageSchema = z4.discriminatedUnion("type", [
   JobAssignmentSchema,
   HelloAckSchema,
   PingSchema
 ]);
-var DeviceToServerMessageSchema = z4.discriminatedUnion("type", [
+var DeviceToServerMessageSchema = z4.union([
   HelloMessageSchema,
   LogFrameSchema,
   RunDoneSchema,
-  PongSchema
+  PongSchema,
+  AgentCallSchema
 ]);
 var HostRegisterRequestSchema = z4.object({
   hostId: z4.string(),
@@ -199,6 +230,36 @@ var HostRegisterResponseSchema = z4.object({
   pollIntervalMs: z4.number().int().positive()
 });
 
+// ../shared/dist/issues.js
+import { z as z5 } from "zod";
+var IssueLabelSchema = z5.object({
+  name: z5.string(),
+  color: z5.string()
+});
+var IssueAssigneeSchema = z5.object({
+  login: z5.string(),
+  id: z5.number()
+});
+var IssueSummarySchema = z5.object({
+  id: z5.string(),
+  number: z5.number().int(),
+  title: z5.string(),
+  state: z5.string(),
+  stateReason: z5.string().nullable(),
+  labels: z5.array(IssueLabelSchema),
+  assignees: z5.array(IssueAssigneeSchema),
+  authorLogin: z5.string().nullable(),
+  htmlUrl: z5.string(),
+  createdAt: z5.string().datetime(),
+  updatedAt: z5.string().datetime(),
+  closedAt: z5.string().datetime().nullable()
+});
+var IssueDetailSchema = IssueSummarySchema.extend({
+  bodyMd: z5.string().nullable(),
+  draftBodyMd: z5.string().nullable(),
+  draftUpdatedAt: z5.string().datetime().nullable()
+});
+
 // src/commands/register.ts
 var POLL_INTERVAL_MS = 2e3;
 async function register(opts = {}) {
@@ -366,8 +427,72 @@ function runJob(spec, stdinJson, handlers) {
   });
 }
 
+// src/runner/agentCallParser.ts
+import { z as z6 } from "zod";
+var MAX_BUFFER_BYTES = 64 * 1024;
+var FENCE_RE = /```opencara-call\r?\n([\s\S]*?)\r?\n```/;
+var VARIANT_SCHEMAS = {
+  "issue.body.set": IssueBodySetCallSchema.omit({ type: true, runId: true }),
+  "flow.node.config.set": FlowNodeConfigSetCallSchema.omit({
+    type: true,
+    runId: true
+  }),
+  "template.node.config.set": TemplateNodeConfigSetCallSchema.omit({
+    type: true,
+    runId: true
+  })
+};
+var KindSchema = z6.enum([
+  "issue.body.set",
+  "flow.node.config.set",
+  "template.node.config.set"
+]);
+var AgentCallParser = class {
+  constructor(emit) {
+    this.emit = emit;
+  }
+  emit;
+  buffer = "";
+  feed(chunk) {
+    this.buffer += chunk;
+    if (this.buffer.length > MAX_BUFFER_BYTES) {
+      const cutoff = Math.floor(MAX_BUFFER_BYTES / 2);
+      const nl = this.buffer.indexOf("\n", this.buffer.length - cutoff);
+      this.buffer = nl >= 0 ? this.buffer.slice(nl + 1) : this.buffer.slice(-cutoff);
+    }
+    while (true) {
+      const m = FENCE_RE.exec(this.buffer);
+      if (!m) break;
+      const inner = m[1] ?? "";
+      const consumedTo = m.index + m[0].length;
+      this.buffer = this.buffer.slice(consumedTo);
+      this.tryEmit(inner);
+    }
+  }
+  tryEmit(inner) {
+    let parsed;
+    try {
+      parsed = JSON.parse(inner);
+    } catch {
+      return;
+    }
+    if (!parsed || typeof parsed !== "object") return;
+    const raw = parsed;
+    const kindResult = KindSchema.safeParse(raw.kind);
+    if (!kindResult.success) return;
+    const withCallId = {
+      ...raw,
+      callId: typeof raw.callId === "string" && raw.callId.length > 0 ? raw.callId : `call_${Date.now().toString(36)}`
+    };
+    const schema = VARIANT_SCHEMAS[kindResult.data];
+    const result = schema.safeParse(withCallId);
+    if (!result.success) return;
+    this.emit(result.data);
+  }
+};
+
 // src/commands/run.ts
-var PKG_VERSION = "0.100.3";
+var PKG_VERSION = "0.102.0";
 var LOG_FLUSH_MS = 800;
 var MAX_CHUNK_SIZE = 4 * 1024;
 async function run(opts = {}) {
@@ -387,7 +512,12 @@ async function run(opts = {}) {
         type: "hello",
         platform: platform(),
         version: PKG_VERSION,
-        capabilities: [],
+        // Advertise the new opencara-call stdout protocol so the
+        // server can later gate the skill prompt to capable CLIs.
+        // Older CLIs without this capability would still be sent the
+        // skill markdown today (it doesn't crash; the fenced block
+        // just shows up in stdout unparsed).
+        capabilities: ["agent-call"],
         systemInfo: collectSystemInfo()
       });
     },
@@ -433,11 +563,29 @@ async function executeJob(job, client) {
     if (flushTimer) return;
     flushTimer = setTimeout(flush, LOG_FLUSH_MS);
   };
+  const callParser = new AgentCallParser((call) => {
+    switch (call.kind) {
+      case "issue.body.set":
+        client.send({ type: "agent-call", runId, ...call });
+        return;
+      case "flow.node.config.set":
+        client.send({ type: "agent-call", runId, ...call });
+        return;
+      case "template.node.config.set":
+        client.send({ type: "agent-call", runId, ...call });
+        return;
+      default: {
+        const exhaustive = call;
+        void exhaustive;
+      }
+    }
+  });
   try {
     const result = await runJob(job.spec, job.stdinJson, {
       onLog: (stream, chunk) => {
         pending[stream] += chunk;
         scheduleFlush();
+        if (stream === "stdout") callParser.feed(chunk);
       }
     });
     flush();
@@ -540,6 +688,97 @@ async function logout() {
   console.log("Removed local credentials.");
 }
 
+// src/commands/internal.ts
+import { execFileSync } from "node:child_process";
+import { mkdtempSync, rmSync, existsSync as existsSync2, realpathSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join as join2, sep } from "node:path";
+async function internal(argv) {
+  const sub = argv[0];
+  const rest = argv.slice(1);
+  if (sub === "worktree") {
+    const op = rest[0];
+    const opArgs = rest.slice(1);
+    if (op === "create") return worktreeCreate(opArgs);
+    if (op === "remove") return worktreeRemove(opArgs);
+    fail(`unknown worktree op: ${op ?? "(none)"}`);
+  }
+  fail(`unknown internal subcommand: ${sub ?? "(none)"}`);
+}
+function worktreeCreate(args) {
+  const repo = pickFlag(args, "--repo");
+  const branch = pickFlag(args, "--branch");
+  const fromRaw = pickFlag(args, "--from-branch") ?? "";
+  const fromBranch = fromRaw.length > 0 ? fromRaw : null;
+  if (!repo || !branch) {
+    fail("worktree create requires --repo OWNER/NAME and --branch <name>");
+  }
+  if (!/^[\w.-]+\/[\w.-]+$/.test(repo)) {
+    fail(`invalid --repo '${repo}' (expected OWNER/NAME)`);
+  }
+  const token = process.env["GH_TOKEN"];
+  if (!token) {
+    fail("worktree create needs GH_TOKEN in env (the orchestrator injects this per run)");
+  }
+  if (!/^[\w-]+$/.test(token)) {
+    fail("GH_TOKEN contains unexpected characters; refusing to use");
+  }
+  const dir = mkdtempSync(join2(tmpdir(), "opencara-wt-"));
+  const HELPER_SNIPPET = '!f() { echo username=x-access-token; echo "password=$GH_TOKEN"; }; f';
+  const cleanUrl = `https://github.com/${repo}.git`;
+  const cloneArgs = ["-c", `credential.helper=${HELPER_SNIPPET}`, "clone", "--depth=1"];
+  if (fromBranch) {
+    cloneArgs.push("--branch", fromBranch);
+  }
+  cloneArgs.push(cleanUrl, ".");
+  try {
+    git(dir, cloneArgs);
+    git(dir, ["checkout", "-b", branch]);
+    git(dir, ["config", "credential.helper", HELPER_SNIPPET]);
+  } catch (err) {
+    try {
+      rmSync(dir, { recursive: true, force: true });
+    } catch {
+    }
+    throw err;
+  }
+  process.stdout.write(`${JSON.stringify({ workdir: dir, branch })}
+`);
+}
+function worktreeRemove(args) {
+  const workdir = pickFlag(args, "--workdir");
+  if (!workdir) {
+    fail("worktree remove requires --workdir <path>");
+  }
+  if (!existsSync2(workdir)) {
+    return;
+  }
+  const tmp = realpathSync(tmpdir());
+  let resolved;
+  try {
+    resolved = realpathSync(workdir);
+  } catch (err) {
+    if (err.code === "ENOENT") return;
+    fail(`worktree remove: cannot resolve ${workdir}: ${err.message}`);
+  }
+  if (resolved !== tmp && !resolved.startsWith(tmp + sep)) {
+    fail(`worktree remove: refuses to remove ${resolved} (not under ${tmp})`);
+  }
+  rmSync(resolved, { recursive: true, force: true });
+}
+function git(cwd, args) {
+  execFileSync("git", args, { cwd, stdio: ["ignore", "ignore", "inherit"] });
+}
+function pickFlag(argv, name) {
+  const i = argv.indexOf(name);
+  if (i === -1) return void 0;
+  return argv[i + 1];
+}
+function fail(msg) {
+  console.error(msg);
+  process.exit(1);
+}
+
 // src/bin.ts
 async function main() {
   const argv = process.argv.slice(2);
@@ -553,6 +792,9 @@ async function main() {
     case "logout":
       await logout();
       return;
+    case "internal":
+      await internal(argv.slice(1));
+      return;
     case "--help":
     case "-h":
       printHelp();
@@ -566,10 +808,10 @@ async function main() {
   }
   await run({
     forcePair: argv.includes("--force-pair"),
-    url: pickFlag(argv, "--url")
+    url: pickFlag2(argv, "--url")
   });
 }
-function pickFlag(argv, name) {
+function pickFlag2(argv, name) {
   const i = argv.indexOf(name);
   if (i === -1) return void 0;
   return argv[i + 1];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencara",
-  "version": "0.100.3",
+  "version": "0.102.0",
   "description": "OpenCara agent-host CLI: register a machine as an agent host and run dispatched agents.",
   "license": "MIT",
   "repository": {