@agentproto/driver-agent-cli 0.2.0 → 0.3.0

package/dist/{chunk-YQHVLX6O.mjs → chunk-KHHRPQ2Q.mjs}

@@ -2,8 +2,11 @@ import { z } from 'zod';
 import { Writable, Readable } from 'stream';
 import { createAcpClient } from '@agentproto/acp/client';
 import { spawn } from 'child_process';
+import { existsSync, readFileSync, mkdirSync, writeFileSync, rmSync, rmdirSync, mkdtempSync } from 'fs';
 import { createInterface } from 'readline';
+import { join } from 'path';
 import { randomUUID } from 'crypto';
+import { tmpdir } from 'os';
 import { createDoctype } from '@agentproto/define-doctype';
 
 /**
@@ -150,6 +153,11 @@ var authSchema = z.object({
 var sessionSchema = z.object({
   mode: z.enum(["ephemeral", "persistent", "resumable"]).default("ephemeral"),
   idle_timeout_ms: z.number().int().min(1e3).default(6e5),
+  // No default: undefined disables the per-turn watchdog entirely. Only
+  // adapters known to sometimes drop the final `prompt` response (e.g.
+  // hermes) should declare this — applying it broadly would risk
+  // false-positiving on another adapter's legitimately long turns.
+  turn_idle_timeout_ms: z.number().int().min(1e3).optional(),
   max_turns: z.number().int().positive().optional(),
   context_carryover: z.boolean().default(true)
 }).strict();
@@ -225,6 +233,16 @@ var mcpBlockSchema = z.object({
   transport: z.enum(["stdio", "http", "sse"]),
   url: z.string().url().optional()
 }).strict();
+var printConfigSchema = z.object({
+  prompt_flag: z.string().optional(),
+  output_format: z.array(z.string()).optional(),
+  pre_prompt: z.array(z.string()).optional(),
+  resume: z.object({
+    flag: z.string(),
+    kind: z.enum(["value", "boolean"])
+  }).strict().optional(),
+  event_schema: z.enum(["claude-stream-json", "mastra-jsonl"]).optional()
+}).strict().optional();
 var agentCliFrontmatterSchema = z.object({
   name: z.string().min(1).max(80),
   id: z.string().regex(ID_PATTERN),
@@ -242,6 +260,7 @@ var agentCliFrontmatterSchema = z.object({
   acp: z.string().optional(),
   mcp: mcpBlockSchema.optional(),
   adapter: z.string().regex(ADAPTER_PATTERN).optional(),
+  print: printConfigSchema,
   session: sessionSchema.optional(),
   models: modelsSchema.optional(),
   capabilities: capabilitiesSchema.optional(),
@@ -325,6 +344,21 @@ var autoAllowPermissionHandler = ({
   const allow = options.find((o) => typeof o.kind === "string" && o.kind.startsWith("allow_")) ?? options[0];
   return { outcome: { outcome: "selected", optionId: allow.optionId } };
 };
+var PLAN_MODE_EXIT_TOOL_CALL_KIND = "switch_mode";
+var planModePermissionHandler = (params) => {
+  const { options, toolCall } = params;
+  if (!options || options.length === 0) {
+    return { outcome: { outcome: "cancelled" } };
+  }
+  if (toolCall?.kind === PLAN_MODE_EXIT_TOOL_CALL_KIND) {
+    const keepPlanning = options.find((o) => o.kind === "reject_once");
+    return keepPlanning ? { outcome: { outcome: "selected", optionId: keepPlanning.optionId } } : { outcome: { outcome: "cancelled" } };
+  }
+  return autoAllowPermissionHandler(params);
+};
+function defaultPermissionHandlerForMode(requestedMode) {
+  return requestedMode === "plan" ? planModePermissionHandler : autoAllowPermissionHandler;
+}
 function createAcpProtocolArm(options) {
   const { child, cwd } = options;
   if (!child.stdin || !child.stdout) {
@@ -342,7 +376,7 @@ function createAcpProtocolArm(options) {
       return session?.sessionId;
     },
     async connect(opts) {
-      const permissionHandler = options.onPermissionRequest ?? autoAllowPermissionHandler;
+      const permissionHandler = options.onPermissionRequest ?? defaultPermissionHandlerForMode(options.requestedMode);
       client = await createAcpClient({
         output,
         input,
@@ -350,6 +384,8 @@ function createAcpProtocolArm(options) {
         capabilities: {
           fs: { readTextFile: true, writeTextFile: true }
         },
+        onActivity: opts.onActivity,
+        turnIdleTimeoutMs: opts.turnIdleTimeoutMs,
         // Wire the permission handler so the agent's `session/request_permission`
         // callbacks get a real answer instead of bubbling up as
         // "AcpClient.requestPermission: no handler configured" → which
@@ -395,9 +431,29 @@ function createAcpProtocolArm(options) {
     }
   };
 }
+
+// src/mcp-servers.ts
+function toFileBasedMcpServers(servers) {
+  if (!servers || servers.length === 0) return void 0;
+  const out = {};
+  for (const s of servers) {
+    out[s.name] = s.transport === "stdio" ? { command: s.ref ?? "" } : { url: s.ref ?? "" };
+  }
+  return out;
+}
+var DEFAULT_OUTPUT = ["--output-format", "stream-json"];
+var DEFAULT_PRE_PROMPT = ["--no-interactive"];
+var DEFAULT_RESUME = { flag: "--resume", kind: "value" };
 function createPrintSession(opts) {
+  const config = opts.printConfig;
+  const outputFormat = config?.output_format ?? DEFAULT_OUTPUT;
+  const prePrompt = config?.pre_prompt ?? DEFAULT_PRE_PROMPT;
+  const promptFlag = config?.prompt_flag;
+  const resumeCfg = config?.resume ?? DEFAULT_RESUME;
+  const eventSchema = config?.event_schema ?? "claude-stream-json";
   let sessionId = opts.resumeSessionId ?? "";
   let activeChild = null;
+  const mcpRestore = setupMcpConfigFile(opts, eventSchema);
   return {
     get sessionId() {
       return sessionId;
@@ -406,13 +462,18 @@ function createPrintSession(opts) {
       const prompt = extractPromptText(message);
       const args = [
         ...opts.baseArgs,
-        "--print",
-        "--output-format",
-        "stream-json",
-        "--no-interactive",
-        ...sessionId ? ["--resume", sessionId] : [],
-        prompt
+        ...outputFormat,
+        ...prePrompt
       ];
+      if (sessionId) {
+        args.push(resumeCfg.flag);
+        if (resumeCfg.kind === "value") args.push(sessionId);
+      }
+      if (promptFlag) {
+        args.push(promptFlag, prompt);
+      } else {
+        args.push(prompt);
+      }
       const child = spawn(opts.bin, args, {
         cwd: opts.cwd,
         env: opts.env,
@@ -430,9 +491,11 @@ function createPrintSession(opts) {
         }
       });
       try {
-        if (!child.stdout) throw new Error("print-arm: child has no stdout pipe");
+        if (!child.stdout)
+          throw new Error("print-arm: child has no stdout pipe");
         const rl = createInterface({ input: child.stdout, crlfDelay: Infinity });
         let capturedSessionId = "";
+        const mastraState = eventSchema === "mastra-jsonl" ? createMastraMapperState() : void 0;
         for await (const line of rl) {
           if (!line.trim()) continue;
           let evt;
@@ -441,21 +504,21 @@ function createPrintSession(opts) {
           } catch {
             continue;
           }
-          if (evt.type === "result" && typeof evt.session_id === "string" && evt.session_id) {
-            capturedSessionId = evt.session_id;
-          }
+          const csid = captureSessionId(evt, eventSchema);
+          if (csid) capturedSessionId = csid;
           const sid = capturedSessionId || sessionId || "";
-          const mapped = mapEvent(evt, sid, stderrLines);
+          const mapped = mapEvent(evt, sid, stderrLines, eventSchema, mastraState);
           if (!mapped) continue;
           yield mapped;
         }
         const exitCode = await waitForExit(child);
         if (capturedSessionId) sessionId = capturedSessionId;
         if (exitCode !== 0 && exitCode !== null) {
+          const binLabel = eventSchema === "mastra-jsonl" ? "mastracode" : "claude";
           const errEvt = {
             kind: "error",
             error: {
-              message: `claude exited with code ${exitCode}`,
+              message: `${binLabel} exited with code ${exitCode}`,
               ...stderrLines.length ? { data: { stderr: stderrLines.join("\n") } } : {}
             }
           };
@@ -470,6 +533,75 @@ function createPrintSession(opts) {
     },
     async close() {
       activeChild?.kill("SIGTERM");
+      mcpRestore?.();
+    }
+  };
+}
+function setupMcpConfigFile(opts, eventSchema) {
+  if (eventSchema !== "mastra-jsonl") return void 0;
+  if (!opts.mcpServers || opts.mcpServers.length === 0) return void 0;
+  const dir = join(opts.cwd, ".mastracode");
+  const file = join(dir, "mcp.json");
+  const injected = toFileBasedMcpServers(opts.mcpServers);
+  if (!injected) return void 0;
+  const fileExisted = existsSync(file);
+  let originalContent;
+  if (fileExisted) {
+    try {
+      originalContent = readFileSync(file, "utf8");
+    } catch {
+      originalContent = void 0;
+    }
+  }
+  const dirExisted = existsSync(dir);
+  if (!dirExisted) {
+    mkdirSync(dir, { recursive: true });
+  }
+  let existingServers = {};
+  if (originalContent !== void 0) {
+    try {
+      const parsed = JSON.parse(originalContent);
+      if (parsed && typeof parsed.mcpServers === "object" && parsed.mcpServers !== null) {
+        existingServers = parsed.mcpServers;
+      }
+    } catch {
+      existingServers = {};
+    }
+  }
+  const merged = { ...existingServers, ...injected };
+  const output = JSON.stringify({ mcpServers: merged }, null, 2);
+  writeFileSync(file, output, "utf8");
+  return () => {
+    try {
+      if (!fileExisted) {
+        rmSync(file, { force: true });
+        if (!dirExisted) {
+          try {
+            rmdirSync(dir);
+          } catch {
+          }
+        }
+      } else if (originalContent !== void 0) {
+        let current = {};
+        try {
+          const parsed = JSON.parse(readFileSync(file, "utf8"));
+          if (parsed && typeof parsed.mcpServers === "object" && parsed.mcpServers !== null) {
+            current = parsed.mcpServers;
+          }
+        } catch {
+          writeFileSync(file, originalContent, "utf8");
+          return;
+        }
+        for (const key of Object.keys(injected)) {
+          delete current[key];
+        }
+        if (Object.keys(current).length === 0) {
+          writeFileSync(file, originalContent, "utf8");
+        } else {
+          writeFileSync(file, JSON.stringify({ mcpServers: current }, null, 2), "utf8");
+        }
+      }
+    } catch {
     }
   };
 }
@@ -484,7 +616,33 @@ function extractPromptText(message) {
   }
   return JSON.stringify(message);
 }
-function mapEvent(evt, sessionId, stderrLines) {
+function captureSessionId(evt, schema) {
+  switch (schema) {
+    case "claude-stream-json":
+      if (evt.type === "result" && typeof evt.session_id === "string" && evt.session_id)
+        return evt.session_id;
+      return null;
+    case "mastra-jsonl":
+      if (evt.type === "result" && typeof evt.threadId === "string" && evt.threadId)
+        return evt.threadId;
+      return null;
+  }
+}
+function mapEvent(evt, sessionId, stderrLines, schema, mastraState) {
+  switch (schema) {
+    case "claude-stream-json":
+      return mapClaudeEvent(evt, sessionId, stderrLines);
+    case "mastra-jsonl": {
+      if (!mastraState) {
+        return mapClaudeEvent(evt, sessionId, stderrLines);
+      }
+      return mapMastraEvent(evt, sessionId, stderrLines, mastraState);
+    }
+    default:
+      return mapClaudeEvent(evt, sessionId, stderrLines);
+  }
+}
+function mapClaudeEvent(evt, sessionId, stderrLines) {
   switch (evt.type) {
     case "text":
       return typeof evt.text === "string" ? { kind: "text-delta", sessionId, text: evt.text } : null;
@@ -528,6 +686,127 @@ function mapEvent(evt, sessionId, stderrLines) {
       return null;
   }
 }
+function createMastraMapperState() {
+  return { lastTextLength: 0 };
+}
+function extractTextFromBlocks(content) {
+  if (!Array.isArray(content)) return "";
+  return content.filter((c) => c.type === "text" && typeof c.text === "string").map((c) => c.text).join("");
+}
+function mapMastraEvent(evt, sessionId, stderrLines, state) {
+  switch (evt.type) {
+    // ── Text streaming ──────────────────────────────────────────
+    case "message_update": {
+      const content = evt.message?.content;
+      const fullText = extractTextFromBlocks(content);
+      if (fullText.length > state.lastTextLength) {
+        const delta = fullText.slice(state.lastTextLength);
+        state.lastTextLength = fullText.length;
+        return delta ? { kind: "text-delta", sessionId, text: delta } : null;
+      }
+      return null;
+    }
+    case "message_end": {
+      const msg = evt.message;
+      if (msg?.role !== "assistant") return null;
+      const fullText = extractTextFromBlocks(msg?.content);
+      if (fullText.length > state.lastTextLength) {
+        const delta = fullText.slice(state.lastTextLength);
+        state.lastTextLength = fullText.length;
+        return delta ? { kind: "text-delta", sessionId, text: delta } : null;
+      }
+      return null;
+    }
+    // ── Tool calls ──────────────────────────────────────────────
+    case "tool_start":
+      return {
+        kind: "tool-call",
+        sessionId,
+        toolCallId: typeof evt.toolCallId === "string" ? evt.toolCallId : "",
+        toolName: typeof evt.toolName === "string" ? evt.toolName : "?",
+        // Mastra's controller event carries the tool call payload under
+        // `args`, not `input` (that's the Claude Code stream-json field
+        // name used by the sibling mapClaudeEvent tool_use case below).
+        arguments: evt.args ?? {}
+      };
+    case "tool_end":
+      return {
+        kind: "tool-result",
+        sessionId,
+        toolCallId: typeof evt.toolCallId === "string" ? evt.toolCallId : "",
+        result: evt.result ?? null,
+        isError: evt.isError === true
+      };
+    // ── Turn end ────────────────────────────────────────────────
+    case "agent_end": {
+      const rawReason = typeof evt.reason === "string" ? evt.reason : "complete";
+      const reason = mapMastraFinishReason(rawReason);
+      return { kind: "turn-end", sessionId, reason };
+    }
+    // ── Final result line ────────────────────────────────────────
+    // Always written last, once, whether or not `agent_end` fired —
+    // pre-flight failures (bad model, unresolvable thread, missing API
+    // key) call straight into this without ever streaming an
+    // `agent_end` or `error` event. `turn-end` already came from
+    // `agent_end` on the success path, so this only needs to surface
+    // an error for the pre-flight-failure path.
+    case "result": {
+      const err = evt.error;
+      if (!err) return null;
+      return {
+        kind: "error",
+        sessionId,
+        error: {
+          message: typeof err.message === "string" ? err.message : "Unknown error",
+          ...stderrLines.length ? { data: { stderr: stderrLines.join("\n") } } : {}
+        }
+      };
+    }
+    // ── Errors ─────────────────────────────────────────────────
+    case "error": {
+      const err = evt.error;
+      return {
+        kind: "error",
+        sessionId,
+        error: {
+          message: typeof err?.message === "string" ? err.message : "Unknown error",
+          ...stderrLines.length ? { data: { stderr: stderrLines.join("\n") } } : {}
+        }
+      };
+    }
+    // ── Shell output (tool-like) ────────────────────────────────
+    case "shell_output":
+      return typeof evt.output === "string" ? {
+        kind: "tool-result",
+        sessionId,
+        toolCallId: "",
+        result: evt.output,
+        isError: false
+      } : null;
+    // ── Skipped events ─────────────────────────────────────────
+    case "agent_start":
+    case "subagent_start":
+    case "subagent_end":
+    case "tool_approval_required":
+    case "tool_suspended":
+      return null;
+    default:
+      return null;
+  }
+}
+function mapMastraFinishReason(raw) {
+  switch (raw) {
+    case "complete":
+      return "completed";
+    case "aborted":
+    case "suspended":
+      return "cancelled";
+    case "error":
+      return "error";
+    default:
+      return "completed";
+  }
+}
 function waitForExit(child) {
   return new Promise((resolve) => {
     child.once("exit", (code) => resolve(code));
@@ -535,6 +814,27 @@ function waitForExit(child) {
   });
 }
 
+// src/protocol/proprietary.ts
+async function createProprietaryProtocolArm(options) {
+  let mod;
+  try {
+    mod = await import(options.adapter);
+  } catch (err) {
+    const cause = err instanceof Error ? err.message : String(err);
+    throw new Error(
+      `createProprietaryProtocolArm: could not load adapter package '${options.adapter}'. Install it with: npm i ${options.adapter}
+  cause: ${cause}`
+    );
+  }
+  const candidate = "createAgentCliClient" in mod ? mod.createAgentCliClient : mod.default;
+  if (typeof candidate !== "function") {
+    throw new Error(
+      `createProprietaryProtocolArm: adapter package '${options.adapter}' does not export a 'createAgentCliClient' factory function (or a default export function). A protocol="proprietary" adapter must export createAgentCliClient(definition: AgentCliHandle): AgentCliClient | Promise<AgentCliClient>.`
+    );
+  }
+  return await candidate(options.definition);
+}
+
 // src/manifest/compose.ts
 var RuntimeConfigError = class extends Error {
   code;
@@ -735,32 +1035,51 @@ function createAgentCliRuntime(definition) {
         ...composed.env,
         ...opts?.env ?? {}
       };
+      const permissionMode = resolveClaudeCodePermissionMode(
+        definition,
+        opts?.config?.mode
+      );
+      if (permissionMode) {
+        const configDir = mkdtempSync(
+          join(tmpdir(), "agentproto-claude-config-")
+        );
+        writeFileSync(
+          join(configDir, "settings.json"),
+          JSON.stringify({ permissions: { defaultMode: permissionMode } })
+        );
+        env.CLAUDE_CONFIG_DIR = configDir;
+      }
       if (definition.protocol === "print") {
         return createPrintSession({
           bin: definition.bin,
           baseArgs: composed.binArgs,
           cwd,
           env,
-          ...opts?.resumeSessionId ? { resumeSessionId: opts.resumeSessionId } : {}
+          ...opts?.resumeSessionId ? { resumeSessionId: opts.resumeSessionId } : {},
+          ...opts?.mcpServers ? { mcpServers: opts.mcpServers } : {},
+          printConfig: definition.print
         });
       }
-      const child = spawn(definition.bin, composed.binArgs, {
-        cwd,
-        env,
-        stdio: ["pipe", "pipe", "pipe"],
-        signal: opts?.signal
-      });
+      let child;
       const stderrBuf = [];
-      const STDERR_KEEP_LINES = 80;
-      child.stderr?.setEncoding("utf8");
-      child.stderr?.on("data", (chunk) => {
-        for (const line of chunk.split(/\r?\n/)) {
-          if (!line) continue;
-          stderrBuf.push(line);
-          if (stderrBuf.length > STDERR_KEEP_LINES) stderrBuf.shift();
-        }
-      });
-      const arm = buildProtocolArm(definition, child, cwd);
+      if (definition.protocol !== "proprietary") {
+        child = spawn(definition.bin, composed.binArgs, {
+          cwd,
+          env,
+          stdio: ["pipe", "pipe", "pipe"],
+          signal: opts?.signal
+        });
+        const STDERR_KEEP_LINES = 80;
+        child.stderr?.setEncoding("utf8");
+        child.stderr?.on("data", (chunk) => {
+          for (const line of chunk.split(/\r?\n/)) {
+            if (!line) continue;
+            stderrBuf.push(line);
+            if (stderrBuf.length > STDERR_KEEP_LINES) stderrBuf.shift();
+          }
+        });
+      }
+      const arm = await buildProtocolArm(definition, child, cwd, opts?.config?.mode);
       arm._stderrTail = () => stderrBuf.join("\n");
       const abortController = new AbortController();
       if (opts?.signal) {
@@ -772,6 +1091,7 @@ function createAgentCliRuntime(definition) {
       const optEffort = opts?.config?.options?.effort;
       const modelApply = definition.models?.apply ?? "config";
       const configModel = optModel && modelApply === "config" ? String(optModel) : void 0;
+      const turnIdleTimeoutMs = opts?.turnIdleTimeoutMs ?? definition.session?.turn_idle_timeout_ms;
       await arm.connect({
         cwd,
         env,
@@ -779,7 +1099,9 @@ function createAgentCliRuntime(definition) {
         ...opts?.resumeSessionId ? { resumeSessionId: opts.resumeSessionId } : {},
         ...opts?.mcpServers ? { mcpServers: opts.mcpServers } : {},
         ...configModel ? { model: configModel } : {},
-        ...optEffort ? { effort: String(optEffort) } : {}
+        ...optEffort ? { effort: String(optEffort) } : {},
+        ...opts?.onActivity ? { onActivity: opts.onActivity } : {},
+        ...turnIdleTimeoutMs !== void 0 ? { turnIdleTimeoutMs } : {}
       });
       if (optModel && modelApply === "command") {
         await applyModelCommand(arm, String(optModel));
@@ -787,6 +1109,7 @@ function createAgentCliRuntime(definition) {
       const sessionId = arm.sessionId ?? randomUUID();
       return {
         sessionId,
+        pid: child?.pid,
         send(message) {
           const turnId = randomUUID();
           return promptTurn(arm, turnId, message);
@@ -796,7 +1119,7 @@ function createAgentCliRuntime(definition) {
         },
         async close() {
           await arm.close();
-          if (!child.killed) child.kill("SIGTERM");
+          if (child && !child.killed) child.kill("SIGTERM");
         }
       };
     }
@@ -839,24 +1162,39 @@ async function* promptTurn(arm, turnId, message) {
     yield evt;
   }
 }
-function buildProtocolArm(def, child, cwd) {
+async function buildProtocolArm(def, child, cwd, requestedMode) {
   switch (def.protocol) {
     case "acp":
+      if (!child) {
+        throw new Error("createAgentCliRuntime: acp protocol requires a spawned subprocess");
+      }
       return createAcpProtocolArm({
         child,
         cwd,
-        clientInfo: { name: def.id, version: def.version }
+        clientInfo: { name: def.id, version: def.version },
+        requestedMode
       });
     case "mcp":
       throw new Error("createAgentCliRuntime: mcp protocol arm not yet implemented");
     case "proprietary":
-      throw new Error(
-        "createAgentCliRuntime: proprietary protocol arm not yet implemented"
-      );
+      if (!def.adapter) {
+        throw new Error(
+          "createAgentCliRuntime: proprietary protocol requires manifest.adapter"
+        );
+      }
+      return createProprietaryProtocolArm({ adapter: def.adapter, definition: def });
     case "print":
       throw new Error("createAgentCliRuntime: print arm bypasses buildProtocolArm");
   }
 }
+function resolveClaudeCodePermissionMode(definition, configMode) {
+  if (definition.id !== "claude-code" || !configMode) return void 0;
+  const mode = (definition.modes ?? []).find((m) => m.id === configMode);
+  const args = mode?.bin_args_append ?? [];
+  const flagIndex = args.indexOf("--permission-mode");
+  if (flagIndex === -1 || flagIndex + 1 >= args.length) return void 0;
+  return args[flagIndex + 1];
+}
 function filterStringEnv(env) {
   const out = {};
   for (const [k, v] of Object.entries(env)) {
@@ -865,6 +1203,6 @@ function filterStringEnv(env) {
   return out;
 }
 
-export { RuntimeConfigError, agentCliFrontmatterSchema, autoAllowPermissionHandler, composeSpawn, createAcpProtocolArm, createAgentCliRuntime, createPrintSession, defineAgentCli, resolveContinuationStrategy, runtimeConfigSchema };
-//# sourceMappingURL=chunk-YQHVLX6O.mjs.map
-//# sourceMappingURL=chunk-YQHVLX6O.mjs.map
+export { RuntimeConfigError, agentCliFrontmatterSchema, autoAllowPermissionHandler, composeSpawn, createAcpProtocolArm, createAgentCliRuntime, createMastraMapperState, createPrintSession, createProprietaryProtocolArm, defineAgentCli, mapMastraEvent, planModePermissionHandler, resolveContinuationStrategy, runtimeConfigSchema, toFileBasedMcpServers };
+//# sourceMappingURL=chunk-KHHRPQ2Q.mjs.map
+//# sourceMappingURL=chunk-KHHRPQ2Q.mjs.map