@titan-design/agent 0.3.0 → 0.4.0

package/dist/index.js

@@ -1,6 +1,6 @@
 // src/run.ts
 import { query } from "@anthropic-ai/claude-agent-sdk";
-import { toJSONSchema } from "zod";
+import { toJSONSchema as toJSONSchema2 } from "zod";
 
 // src/env.ts
 var ANTI_NESTING_VARS = ["CLAUDECODE", "CLAUDE_CODE_SSE_PORT", "CLAUDE_CODE_ENTRYPOINT"];
@@ -64,7 +64,7 @@ function assertAuthEnvOk(env, options = {}) {
       "pass the env through prepareEnv, or set allowApiKeyBilling to bill the API account on purpose"
     );
   }
-  if (!env.CLAUDE_CODE_OAUTH_TOKEN) {
+  if (options.requireOAuthToken !== false && !env.CLAUDE_CODE_OAUTH_TOKEN) {
     throw new AuthMisconfiguredError(
       "CLAUDE_CODE_OAUTH_TOKEN is not set; subscription auth will fail",
       "run `claude setup-token` once and export the printed token"
@@ -84,6 +84,86 @@ function assertApiKeySourceAllowed(observed) {
   }
 }
 
+// src/claude-print.ts
+import { spawn as spawn2 } from "child_process";
+import { accessSync, constants, statSync } from "fs";
+import { delimiter, join as join2 } from "path";
+import { toJSONSchema } from "zod";
+
+// src/codex-process.ts
+import { execFile, spawn } from "child_process";
+import { mkdtemp, rm, writeFile } from "fs/promises";
+import { tmpdir } from "os";
+import { join } from "path";
+import { createInterface } from "readline";
+async function inspectCodexVersion(executablePath, env, options) {
+  return new Promise((resolve, reject) => {
+    execFile(
+      executablePath,
+      ["--version"],
+      {
+        env,
+        encoding: "utf8",
+        signal: options.signal,
+        timeout: Math.max(1, Math.ceil(options.timeoutMs)),
+        killSignal: "SIGKILL"
+      },
+      (error, stdout) => {
+        if (error) reject(error);
+        else resolve(stdout);
+      }
+    );
+  });
+}
+function startCodexProcess(input) {
+  const child = spawn(input.executablePath, input.args, {
+    cwd: input.cwd,
+    env: input.env,
+    detached: process.platform !== "win32",
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  return {
+    stdout: lines(child.stdout),
+    stderr: lines(child.stderr),
+    completed: completionOf(child),
+    terminate: (signal) => terminateProcessGroup(child, signal)
+  };
+}
+async function createCodexSchemaFile(schema) {
+  const directory = await mkdtemp(join(tmpdir(), "titan-codex-schema-"));
+  const path = join(directory, "output-schema.json");
+  try {
+    await writeFile(path, JSON.stringify(schema), { encoding: "utf8", mode: 384 });
+    return { path, dispose: () => rm(directory, { recursive: true, force: true }) };
+  } catch (error) {
+    await rm(directory, { recursive: true, force: true });
+    throw error;
+  }
+}
+async function* lines(stream) {
+  const reader = createInterface({ input: stream });
+  for await (const line of reader) yield line;
+}
+function completionOf(child) {
+  return new Promise((resolve, reject) => {
+    child.once("error", reject);
+    child.once("close", (exitCode, signal) => resolve({ exitCode, signal }));
+  });
+}
+function terminateProcessGroup(child, signal) {
+  if (child.pid && process.platform !== "win32") {
+    try {
+      process.kill(-child.pid, signal);
+      return;
+    } catch {
+    }
+  }
+  try {
+    child.kill(signal);
+  } catch {
+  }
+}
+
 // src/failures.ts
 var RATE_LIMIT_PATTERNS = [
   /you'?ve hit your (session|weekly|opus|sonnet) limit/i,
@@ -146,18 +226,220 @@ function sumModelCost(modelUsage) {
   return Object.values(modelUsage).reduce((total, m) => total + (m.costUSD ?? 0), 0);
 }
 
+// src/harness-contracts.ts
+var CLAUDE_PRINT_UNSUPPORTED_OPTIONS = [
+  "allowedTools",
+  "disallowedTools",
+  "permissionMode",
+  "resumeSessionId",
+  "agents",
+  "mcpServers",
+  "hooks"
+];
+var CODEX_SANDBOXES = ["read-only", "workspace-write", "danger-full-access"];
+var CODEX_APPROVAL_POLICIES = ["untrusted", "on-failure", "on-request", "never"];
+var EXECUTION_CAPABILITIES = [
+  "fresh_run",
+  "resume",
+  "fork",
+  "structured_output",
+  "interactive_approvals",
+  "external_cancellation",
+  "semantic_interrupt",
+  "active_turn_steering",
+  "idle_turn_submission",
+  "persisted_transcript",
+  "process_reattachment",
+  "token_reporting"
+];
+
+// src/claude-print.ts
+var CLAUDE_PRINT_KILL_GRACE_MS = 5e3;
+var DEFAULT_TIMEOUT_MS = 6e5;
+var EMPTY_MCP_CONFIG = '{"mcpServers":{}}';
+var LOGIN_FAILURE = /not logged in|please run \/login|invalid api key/i;
+function claudePrintCapabilities() {
+  const capabilities = Object.fromEntries(EXECUTION_CAPABILITIES.map((capability) => [capability, {
+    status: "unsupported",
+    reason: "claude -p runs one turn with no tools, hooks, MCP or resume"
+  }]));
+  capabilities.fresh_run = { status: "supported", evidence: "spawns claude -p --max-turns 1 per call" };
+  capabilities.structured_output = { status: "supported", evidence: "--json-schema, then a local zod parse" };
+  capabilities.external_cancellation = { status: "supported", evidence: "abort kills the child process group" };
+  capabilities.token_reporting = { status: "supported", evidence: "usage and modelUsage from the JSON result" };
+  return {
+    harness: "claude-print",
+    adapter: { name: "claude-print", version: "1" },
+    capabilities,
+    limits: [{ unit: "milliseconds", scope: "execution", enforcement: "hard", assessment: {
+      status: "supported",
+      evidence: "inactivityTimeoutMs is a wall deadline that kills the child process group"
+    } }]
+  };
+}
+function assertClaudePrintConfig(config) {
+  const field = CLAUDE_PRINT_UNSUPPORTED_OPTIONS.find((name) => config[name] !== void 0) ?? (config.tools?.length ? "tools" : void 0) ?? (config.settingSources?.length ? "settingSources" : void 0);
+  if (field) throw new TypeError(`${field} is not supported by the claude-print harness (one turn, no tools, hooks or MCP)`);
+}
+function resolveClaudeBin(env) {
+  if (env.CLAUDE_BIN) return env.CLAUDE_BIN;
+  for (const dir of (env.PATH ?? "").split(delimiter)) {
+    if (dir && isExecutableFile(join2(dir, "claude"))) return join2(dir, "claude");
+  }
+  return void 0;
+}
+function isExecutableFile(path) {
+  try {
+    accessSync(path, constants.X_OK);
+    return statSync(path).isFile();
+  } catch {
+    return false;
+  }
+}
+function buildClaudePrintArgs(config) {
+  const args = [
+    "-p",
+    "--output-format",
+    "json",
+    "--tools",
+    "",
+    "--strict-mcp-config",
+    "--mcp-config",
+    EMPTY_MCP_CONFIG,
+    "--setting-sources",
+    "",
+    "--max-turns",
+    "1",
+    "--max-budget-usd",
+    String(config.maxBudgetUsd)
+  ];
+  if (config.model) args.push("--model", config.model);
+  if (config.systemPrompt !== void 0) args.push("--system-prompt", config.systemPrompt);
+  if (config.outputSchema) args.push("--json-schema", cliJsonSchema(config.outputSchema));
+  return args;
+}
+function cliJsonSchema(schema) {
+  const body = { ...toJSONSchema(schema) };
+  delete body.$schema;
+  return JSON.stringify(body);
+}
+async function runClaudePrint(config, env, clock) {
+  if (config.signal?.aborted) return { ok: false, failure: aborted(config.signal) };
+  const bin = resolveClaudeBin(env);
+  if (!bin) return { ok: false, failure: { kind: "runtime_error", reason: "claude binary not found on PATH; set CLAUDE_BIN" } };
+  const child = spawn2(bin, buildClaudePrintArgs(config), {
+    cwd: config.cwd,
+    env,
+    detached: process.platform !== "win32",
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  const outcome = await supervise(child, config);
+  return settle(outcome, config, clock.now() - clock.startedAt);
+}
+function supervise(child, config) {
+  const timeoutMs = config.inactivityTimeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const output = collectOutput(child);
+  let ended;
+  const stop = (failure) => {
+    ended ??= failure;
+    terminateProcessGroup(child, "SIGTERM");
+    setTimeout(() => terminateProcessGroup(child, "SIGKILL"), CLAUDE_PRINT_KILL_GRACE_MS).unref();
+  };
+  const timer = setTimeout(() => stop({ kind: "inactivity_timeout", reason: `claude -p ran past ${timeoutMs}ms`, timeoutMs }), timeoutMs);
+  const onAbort = () => stop(aborted(config.signal));
+  config.signal?.addEventListener("abort", onAbort, { once: true });
+  child.stdin?.on("error", () => {
+  });
+  child.stdin?.end(config.prompt);
+  return new Promise((resolve) => {
+    const finish = (code, signal, spawnError) => {
+      clearTimeout(timer);
+      config.signal?.removeEventListener("abort", onAbort);
+      resolve({ code, signal, ...output(), ...spawnError ? { spawnError } : {}, ...ended ? { ended } : {} });
+    };
+    child.once("error", (error) => finish(null, null, error));
+    child.once("close", (code, signal) => finish(code, signal));
+  });
+}
+function collectOutput(child) {
+  const stdout = [];
+  const stderr = [];
+  child.stdout?.on("data", (chunk) => stdout.push(chunk));
+  child.stderr?.on("data", (chunk) => stderr.push(chunk));
+  return () => ({ stdout: Buffer.concat(stdout).toString("utf8"), stderr: Buffer.concat(stderr).toString("utf8") });
+}
+function settle(outcome, config, durationMs) {
+  if (outcome.ended) return { ok: false, failure: outcome.ended };
+  if (outcome.spawnError) return { ok: false, failure: { kind: "runtime_error", reason: `claude -p failed to start: ${outcome.spawnError.message}`, raw: outcome.spawnError } };
+  const result = parseResult(outcome.stdout);
+  if (!result) return { ok: false, failure: exitFailure(outcome, "printed no JSON result") };
+  config.onMessage?.(result);
+  const usage = usageFromResult(result, durationMs);
+  const failure = loginFailure(result) ?? classifyResult(result) ?? (outcome.code === 0 ? void 0 : exitFailure(outcome, "reported success"));
+  const sessionId = typeof result.session_id === "string" ? result.session_id : void 0;
+  if (failure) return { ok: false, failure, ...sessionId ? { sessionId } : {}, usage };
+  if (!sessionId) return { ok: false, failure: { kind: "runtime_error", reason: "the JSON result carried no session_id", raw: result }, usage };
+  const output = readOutput(result, config);
+  if ("failure" in output) return { ok: false, failure: output.failure, sessionId, usage };
+  return { ok: true, output: output.value, sessionId, usage, init: initFrom(result) };
+}
+function parseResult(stdout) {
+  try {
+    const parsed = JSON.parse(stdout);
+    const isResult = typeof parsed === "object" && parsed !== null && parsed.type === "result";
+    return isResult ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function exitFailure(outcome, what) {
+  const exit = outcome.signal ? `signal ${outcome.signal}` : `code ${String(outcome.code)}`;
+  const stderr = outcome.stderr.trim();
+  return { kind: "runtime_error", reason: `claude -p exited with ${exit} and ${what}${stderr ? `: ${stderr}` : ""}`, raw: outcome };
+}
+function loginFailure(result) {
+  const text = result.subtype === "success" ? result.result : (result.errors ?? []).join("\n");
+  if (!result.is_error || !LOGIN_FAILURE.test(text)) return void 0;
+  return { kind: "auth_misconfigured", reason: text, hint: "run `claude` once interactively and /login", raw: result };
+}
+function readOutput(result, config) {
+  const text = result.subtype === "success" ? result.result : "";
+  if (!config.outputSchema) return { value: text };
+  const raw = (result.subtype === "success" ? result.structured_output : void 0) ?? parseJson(text);
+  const parsed = config.outputSchema.safeParse(raw);
+  if (parsed.success) return { value: parsed.data };
+  return { failure: { kind: "schema_invalid", reason: "structured output did not match the supplied schema", error: parsed.error, raw } };
+}
+function parseJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
+function initFrom(result) {
+  const models = Object.keys(result.modelUsage ?? {});
+  return { apiKeySource: void 0, model: models.length === 1 ? models[0] : void 0, tools: [], permissionMode: void 0, claudeCodeVersion: void 0 };
+}
+function aborted(signal) {
+  return { kind: "aborted", reason: String(signal?.reason ?? "aborted by caller") };
+}
+
 // src/run.ts
 var DEFAULT_INACTIVITY_MS = 6e5;
 async function runAgent(config, deps = {}) {
   assertBudgets(config);
+  if (config.harness === "claude-print") assertClaudePrintConfig(config);
   const now = deps.now ?? Date.now;
   const startedAt = now();
+  const print = config.harness === "claude-print";
   const env = prepareEnv(deps.env ?? process.env, { allowApiKeyBilling: config.allowApiKeyBilling });
   try {
-    assertAuthEnvOk(env, { allowApiKeyBilling: config.allowApiKeyBilling });
+    assertAuthEnvOk(env, { allowApiKeyBilling: config.allowApiKeyBilling, requireOAuthToken: !print });
   } catch (error) {
     return { ok: false, failure: authFailure(error) };
   }
+  if (print) return runClaudePrint(config, env, { now, startedAt });
   const session = new Session(config, env, deps);
   try {
     return await session.run(startedAt);
@@ -251,7 +533,7 @@ var Session = class {
     if (c.mcpServers) options.mcpServers = c.mcpServers;
     if (c.hooks) options.hooks = c.hooks;
     if (c.outputSchema) {
-      options.outputFormat = { type: "json_schema", schema: toJSONSchema(c.outputSchema) };
+      options.outputFormat = { type: "json_schema", schema: toJSONSchema2(c.outputSchema) };
     }
     return options;
   }
@@ -348,24 +630,6 @@ function describeEnd(reason) {
   return reason.kind === "aborted" ? reason.reason : `no message for ${reason.timeoutMs}ms`;
 }
 
-// src/harness-contracts.ts
-var CODEX_SANDBOXES = ["read-only", "workspace-write", "danger-full-access"];
-var CODEX_APPROVAL_POLICIES = ["untrusted", "on-failure", "on-request", "never"];
-var EXECUTION_CAPABILITIES = [
-  "fresh_run",
-  "resume",
-  "fork",
-  "structured_output",
-  "interactive_approvals",
-  "external_cancellation",
-  "semantic_interrupt",
-  "active_turn_steering",
-  "idle_turn_submission",
-  "persisted_transcript",
-  "process_reattachment",
-  "token_reporting"
-];
-
 // src/preflight.ts
 import { conversationRef } from "@titan-design/agent-protocol";
 function preflightHarnessRun(request, descriptor) {
@@ -660,7 +924,7 @@ var CodexExecSession = class {
     if (this.stopReason === "timeout") return this.failure(timeoutFailure(this.request.wallTimeMs));
     if (this.stopReason === "abort") return this.failure(abortFailure(this.request.signal));
     if (this.streamError) return this.failure(this.streamError);
-    if (exit.exitCode !== 0) return this.failure(exitFailure(exit, this.stderr));
+    if (exit.exitCode !== 0) return this.failure(exitFailure2(exit, this.stderr));
     return this.success();
   }
   success() {
@@ -811,7 +1075,7 @@ function cancelledUnknown(cause, request, exit) {
     native: { cause, requested, processExit: exit }
   };
 }
-function exitFailure(exit, stderr) {
+function exitFailure2(exit, stderr) {
   return {
     kind: "runtime_error",
     reason: stderr.trim() || `Codex exited with status ${String(exit.exitCode)}`,
@@ -830,80 +1094,6 @@ function messageOf3(error) {
   return error instanceof Error ? error.message : String(error);
 }
 
-// src/codex-process.ts
-import { execFile, spawn } from "child_process";
-import { mkdtemp, rm, writeFile } from "fs/promises";
-import { tmpdir } from "os";
-import { join } from "path";
-import { createInterface } from "readline";
-async function inspectCodexVersion(executablePath, env, options) {
-  return new Promise((resolve, reject) => {
-    execFile(
-      executablePath,
-      ["--version"],
-      {
-        env,
-        encoding: "utf8",
-        signal: options.signal,
-        timeout: Math.max(1, Math.ceil(options.timeoutMs)),
-        killSignal: "SIGKILL"
-      },
-      (error, stdout) => {
-        if (error) reject(error);
-        else resolve(stdout);
-      }
-    );
-  });
-}
-function startCodexProcess(input) {
-  const child = spawn(input.executablePath, input.args, {
-    cwd: input.cwd,
-    env: input.env,
-    detached: process.platform !== "win32",
-    stdio: ["ignore", "pipe", "pipe"]
-  });
-  return {
-    stdout: lines(child.stdout),
-    stderr: lines(child.stderr),
-    completed: completionOf(child),
-    terminate: (signal) => terminateProcessGroup(child, signal)
-  };
-}
-async function createCodexSchemaFile(schema) {
-  const directory = await mkdtemp(join(tmpdir(), "titan-codex-schema-"));
-  const path = join(directory, "output-schema.json");
-  try {
-    await writeFile(path, JSON.stringify(schema), { encoding: "utf8", mode: 384 });
-    return { path, dispose: () => rm(directory, { recursive: true, force: true }) };
-  } catch (error) {
-    await rm(directory, { recursive: true, force: true });
-    throw error;
-  }
-}
-async function* lines(stream) {
-  const reader = createInterface({ input: stream });
-  for await (const line of reader) yield line;
-}
-function completionOf(child) {
-  return new Promise((resolve, reject) => {
-    child.once("error", reject);
-    child.once("close", (exitCode, signal) => resolve({ exitCode, signal }));
-  });
-}
-function terminateProcessGroup(child, signal) {
-  if (child.pid && process.platform !== "win32") {
-    try {
-      process.kill(-child.pid, signal);
-      return;
-    } catch {
-    }
-  }
-  try {
-    child.kill(signal);
-  } catch {
-  }
-}
-
 // src/codex-exec.ts
 var DEFAULT_CODEX_EXECUTABLE = "/Applications/ChatGPT.app/Contents/Resources/codex";
 var SUPPORTED_CODEX_EXEC_VERSION = "0.154.0-alpha.6.1";
@@ -1792,6 +1982,8 @@ export {
   ANTI_NESTING_VARS,
   AuthMisconfiguredError,
   CLAUDE_CODE_PASSTHROUGH_VARS,
+  CLAUDE_PRINT_KILL_GRACE_MS,
+  CLAUDE_PRINT_UNSUPPORTED_OPTIONS,
   CODEX_APPROVAL_POLICIES,
   CODEX_SANDBOXES,
   DEFAULT_CODEX_EXECUTABLE,
@@ -1806,9 +1998,11 @@ export {
   SUPPORTED_CODEX_EXEC_VERSION,
   assertApiKeySourceAllowed,
   assertAuthEnvOk,
+  buildClaudePrintArgs,
   buildCodexExecArgs,
   classifyResult,
   claudeCodeCapabilities,
+  claudePrintCapabilities,
   codexExecCapabilities,
   createClaudeCodeAdapter,
   createCodexExecAdapter,
@@ -1817,6 +2011,7 @@ export {
   preflightHarnessRun,
   prepareCodexEnv,
   prepareEnv,
+  resolveClaudeBin,
   runAgent,
   sumModelCost,
   usageFromResult