opencara 0.100.3 → 0.101.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.101.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();

package/package.json

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