@sellable/install 0.1.793 → 0.1.795-wip.runs-api.20261004.1

package/container/Dockerfile

@@ -3,12 +3,12 @@ FROM ${HERMES_IMAGE}
 
 USER root
 
-ARG INSTALLER_PACKAGE=@sellable/install@0.1.793
+ARG INSTALLER_PACKAGE=@sellable/install@0.1.795-wip.runs-api.20261004.1
 ARG MCP_PACKAGE=@sellable/mcp@0.1.957
 ARG INSTALLER_INTEGRITY
 ARG MCP_INTEGRITY=sha512-tIZuO5IEanT/afamDIWdorUNMdqZA6xnjL9jGAmGqYIlIqkXdHB9slWiwfLfmM44iEp7OT98IBHJlvbpMThk6A==
 
-RUN test "${INSTALLER_PACKAGE}" = "@sellable/install@0.1.793" \
+RUN test "${INSTALLER_PACKAGE}" = "@sellable/install@0.1.795-wip.runs-api.20261004.1" \
     && test "${MCP_PACKAGE}" = "@sellable/mcp@0.1.957" \
     && test -n "${INSTALLER_INTEGRITY}" \
     && test "$(npm view "${INSTALLER_PACKAGE}" dist.integrity)" = "${INSTALLER_INTEGRITY}" \
@@ -23,9 +23,9 @@ RUN test "${INSTALLER_PACKAGE}" = "@sellable/install@0.1.793" \
     && mkdir -p /opt/sellable-agent/install-root /opt/sellable-agent/mcp-root \
     && npm install --prefix /opt/sellable-agent/install-root --omit=dev --ignore-scripts --no-audit --no-fund "${INSTALLER_PACKAGE}" \
     && npm install --prefix /opt/sellable-agent/mcp-root --omit=dev --ignore-scripts --no-audit --no-fund "${MCP_PACKAGE}" \
-    && node --input-type=module -e "import { readFileSync } from 'node:fs'; const install = JSON.parse(readFileSync('/opt/sellable-agent/install-root/node_modules/@sellable/install/package.json')); const mcp = JSON.parse(readFileSync('/opt/sellable-agent/mcp-root/node_modules/@sellable/mcp/package.json')); if (install.name !== '@sellable/install' || install.version !== '0.1.793' || mcp.name !== '@sellable/mcp' || mcp.version !== '0.1.957') throw new Error('package identity rejected');" \
+    && node --input-type=module -e "import { readFileSync } from 'node:fs'; const install = JSON.parse(readFileSync('/opt/sellable-agent/install-root/node_modules/@sellable/install/package.json')); const mcp = JSON.parse(readFileSync('/opt/sellable-agent/mcp-root/node_modules/@sellable/mcp/package.json')); if (install.name !== '@sellable/install' || install.version !== '0.1.795-wip.runs-api.20261004.1' || mcp.name !== '@sellable/mcp' || mcp.version !== '0.1.957') throw new Error('package identity rejected');" \
     && node --input-type=module -e "import { buildExternalRuntimeClosure } from '/opt/sellable-agent/install-root/node_modules/@sellable/install/lib/sellable-agent/external-runtime-builder.mjs'; const built = buildExternalRuntimeClosure({ mcpPackageRoot: '/opt/sellable-agent/mcp-root/node_modules/@sellable/mcp', mcpNodeModulesRoot: '/opt/sellable-agent/mcp-root/node_modules', hermesSourceRoot: '/opt/hermes', ownerUid: 0, ownerGid: 0 }); if (!built.closureDigest) throw new Error('runtime closure rejected');" \
-    && node --input-type=module -e "import { chmodSync, writeFileSync } from 'node:fs'; const release = { installerPackage: '@sellable/install@0.1.793', installerIntegrity: process.argv[1], mcpPackage: '@sellable/mcp@0.1.957', mcpIntegrity: process.argv[2] }; writeFileSync('/opt/sellable-agent/release.json', JSON.stringify(release) + '\\n', { mode: 0o444 }); chmodSync('/opt/sellable-agent/release.json', 0o444);" "${INSTALLER_INTEGRITY}" "${MCP_INTEGRITY}" \
+    && node --input-type=module -e "import { chmodSync, writeFileSync } from 'node:fs'; const release = { installerPackage: '@sellable/install@0.1.795-wip.runs-api.20261004.1', installerIntegrity: process.argv[1], mcpPackage: '@sellable/mcp@0.1.957', mcpIntegrity: process.argv[2] }; writeFileSync('/opt/sellable-agent/release.json', JSON.stringify(release) + '\\n', { mode: 0o444 }); chmodSync('/opt/sellable-agent/release.json', 0o444);" "${INSTALLER_INTEGRITY}" "${MCP_INTEGRITY}" \
     && npm cache clean --force
 
 COPY entrypoint.sh /usr/local/bin/sellable-agent-container-entrypoint

package/container/README.md

@@ -3,7 +3,7 @@
 This image is a dedicated Agent worker/runtime boundary beside an existing Hermes dashboard. It never replaces or reconfigures the dashboard container.
 
 Build from this directory after
-`@sellable/install@0.1.793` is
+`@sellable/install@0.1.795-wip.runs-api.20261004.1` is
 published:
 
 ```sh

package/lib/sellable-agent/fly-admin-image/Dockerfile

@@ -169,6 +169,7 @@ COPY fly-admin-image/start-admin-runtime /usr/local/lib/sellable-agent/admin-run
 COPY fly-customer-image/customer-runtime.mjs /usr/local/lib/sellable-agent/fly-customer-image/customer-runtime.mjs
 COPY hermes-first-welcome.mjs /usr/local/lib/sellable-agent/hermes-first-welcome.mjs
 COPY fly-customer-image/hermes-runs-client.mjs /usr/local/lib/sellable-agent/fly-customer-image/hermes-runs-client.mjs
+COPY fly-customer-image/endpoint-model-selection.mjs fly-customer-image/runs-api-connections.mjs fly-customer-image/claude-code-runs-api.mjs /usr/local/lib/sellable-agent/fly-customer-image/
 COPY fly-customer-image/opener-stage-execution.mjs /usr/local/lib/sellable-agent/fly-customer-image/opener-stage-execution.mjs
 COPY fly-customer-image/endpoint-uat-completion-gate.mjs /usr/local/lib/sellable-agent/fly-customer-image/endpoint-uat-completion-gate.mjs
 COPY fly-customer-image/customer-runtime-phase-telemetry.mjs /usr/local/lib/sellable-agent/fly-customer-image/customer-runtime-phase-telemetry.mjs
@@ -272,6 +273,9 @@ RUN set -eux; \
       /usr/local/lib/sellable-agent/fly-customer-image/customer-runtime.mjs \
       /usr/local/lib/sellable-agent/fly-customer-image/customer-runtime-phase-telemetry.mjs \
       /usr/local/lib/sellable-agent/fly-customer-image/hermes-runs-client.mjs \
+      /usr/local/lib/sellable-agent/fly-customer-image/endpoint-model-selection.mjs \
+      /usr/local/lib/sellable-agent/fly-customer-image/runs-api-connections.mjs \
+      /usr/local/lib/sellable-agent/fly-customer-image/claude-code-runs-api.mjs \
       /usr/local/lib/sellable-agent/fly-customer-image/opener-stage-execution.mjs \
       /usr/local/lib/sellable-agent/fly-customer-image/endpoint-uat-completion-gate.mjs \
       /usr/local/lib/sellable-agent/admin-native-gateway-supervisor.mjs \

package/lib/sellable-agent/fly-admin-image/admin-runtime.mjs

@@ -63,6 +63,7 @@ import {
 } from "../fly-capabilities-bridge.mjs";
 import { createCustomerEndpointRelay } from "../fly-customer-image/customer-runtime.mjs";
 import { createHermesSessionRetention } from "../fly-customer-image/hermes-runs-client.mjs";
+import { startConfiguredClaudeRunsApis } from "../fly-customer-image/claude-code-runs-api.mjs";
 import {
   claimWithSoulObservation,
   createFlyCustomerControlClient,
@@ -3817,6 +3818,14 @@ async function runAdminProduction() {
   let activeLaunch = null;
   let activeModelHealthReporter = null;
   let shutdownMemorySnapshot = null;
+  let customRunsServices = null;
+  try {
+    customRunsServices = await startConfiguredClaudeRunsApis({
+      diagnostic: value => process.stderr.write(`${JSON.stringify(value)}\n`),
+    });
+  } catch {
+    process.stderr.write(`${JSON.stringify({ ok: false, code: "custom_runs_api_start_failed" })}\n`);
+  }
   const endpointRelay = createCustomerEndpointRelay({
     getControlClient: () => client,
     getActiveRuntime: () =>
@@ -4453,6 +4462,7 @@ async function runAdminProduction() {
     );
   }
   await endpointLoop;
+  await customRunsServices?.stop();
   await activeModelHealthReporter?.stop();
   await stopNativeGateway(activeGateway);
   await clearRuntimeSecrets();

package/lib/sellable-agent/fly-customer-image/Dockerfile

@@ -8,7 +8,7 @@ ENV PLAYWRIGHT_BROWSERS_PATH=/opt/hermes/.playwright
 
 ARG MCP_PACKAGE=@sellable/mcp@0.1.957
 ARG MCP_INTEGRITY=sha512-tIZuO5IEanT/afamDIWdorUNMdqZA6xnjL9jGAmGqYIlIqkXdHB9slWiwfLfmM44iEp7OT98IBHJlvbpMThk6A==
-ARG INSTALLER_PACKAGE=@sellable/install@0.1.793
+ARG INSTALLER_PACKAGE=@sellable/install@0.1.795-wip.runs-api.20261004.1
 ARG ADMIN_MCP_PACKAGE=@sellable/admin-mcp@0.1.202
 ARG ADMIN_MCP_INTEGRITY=sha512-ym3aye/0vQ8tfULJlKz9JFOxvIQsl1G+n3np+TTgK/tecwNblBo/j3AkTnRqH9iomKzPbZzP+n4tEQsvsU8ByA==
 ARG TUS_JS_CLIENT_VERSION=4.3.1
@@ -98,6 +98,7 @@ COPY hermes-memory-reconcile.sh /opt/sellable/share/hermes-memory-reconcile.sh
 COPY hermes-endpoint-cron.mjs /opt/sellable/bin/hermes-endpoint-cron
 COPY fly-customer-image/model-auth-store.mjs /usr/local/lib/sellable-agent/fly-customer-image/model-auth-store.mjs
 COPY fly-customer-image/hermes-runs-client.mjs /usr/local/lib/sellable-agent/fly-customer-image/hermes-runs-client.mjs
+COPY fly-customer-image/endpoint-model-selection.mjs fly-customer-image/runs-api-connections.mjs /usr/local/lib/sellable-agent/fly-customer-image/
 COPY fly-customer-image/opener-stage-execution.mjs /usr/local/lib/sellable-agent/fly-customer-image/opener-stage-execution.mjs
 COPY fly-customer-image/endpoint-uat-completion-gate.mjs /usr/local/lib/sellable-agent/fly-customer-image/endpoint-uat-completion-gate.mjs
 COPY fly-customer-image/customer-runtime-phase-telemetry.mjs /usr/local/lib/sellable-agent/fly-customer-image/customer-runtime-phase-telemetry.mjs

package/lib/sellable-agent/fly-customer-image/claude-code-runs-api.d.mts

@@ -0,0 +1,48 @@
+import type { SpawnOptions } from "node:child_process";
+import type { Server } from "node:http";
+import type { RunsApiConnection } from "./runs-api-connections.mjs";
+
+export type ClaudeRunsRequest = {
+  input: string;
+  instructions: string;
+  schema: Record<string, unknown> | null;
+  model: string;
+  effort: string;
+};
+export type ClaudeRunsResult = {
+  output: string;
+  runtime: { provider: string; model: string };
+  usage: Record<string, number>;
+};
+export type ClaudeRunsServer = Server & { stopActiveRuns(): Promise<void> };
+export type ClaudeRunsApiOptions = {
+  token: string;
+  connection: RunsApiConnection;
+  execute?: (request: ClaudeRunsRequest) => {
+    promise: Promise<ClaudeRunsResult>;
+    stop(): void;
+  };
+  audit?: (entry: Record<string, unknown>) => void;
+  maxConcurrency?: number;
+};
+export function validateClaudeRunsRequest(
+  body: unknown,
+  models: RunsApiConnection["models"]
+): ClaudeRunsRequest;
+export function claudeInvocation(
+  request: ClaudeRunsRequest,
+  root: string
+): { command: string; args: string[]; options: SpawnOptions };
+export function parseClaudeResult(
+  stdout: string,
+  request: ClaudeRunsRequest
+): ClaudeRunsResult;
+export function createClaudeRunsApi(
+  options: ClaudeRunsApiOptions
+): ClaudeRunsServer;
+export function startConfiguredClaudeRunsApis(options?: {
+  env?: Record<string, string | undefined>;
+  diagnostic?: (entry: Record<string, unknown>) => void;
+  createApi?: typeof createClaudeRunsApi;
+  readToken?: (path: string) => string;
+}): Promise<{ stop(): Promise<void> }>;

package/lib/sellable-agent/fly-customer-image/claude-code-runs-api.mjs

@@ -0,0 +1,492 @@
+import { spawn } from "node:child_process";
+import { createHash, randomBytes, timingSafeEqual } from "node:crypto";
+import { appendFileSync, readFileSync } from "node:fs";
+import { createServer } from "node:http";
+import { validateOpenerOutputContract } from "./hermes-runs-client.mjs";
+import {
+  parseRunsApiConnections,
+  RUNS_API_CONNECTIONS_ENV,
+} from "./runs-api-connections.mjs";
+
+const MAX_BODY = 320 * 1024;
+const MAX_OUTPUT = 48 * 1024;
+const MAX_CLI_OUTPUT = 512 * 1024;
+const hash = (s) => createHash("sha256").update(s).digest("hex");
+const record = (v) => v && typeof v === "object" && !Array.isArray(v);
+
+export function validateClaudeRunsRequest(body, models) {
+  const allowed = [
+    "input",
+    "instructions",
+    "conversation_history",
+    "session_id",
+    "provider",
+    "model",
+    "model_options",
+  ];
+  if (
+    !record(body) ||
+    Object.keys(body).some((k) => !allowed.includes(k)) ||
+    typeof body.input !== "string" ||
+    !body.input.length ||
+    Buffer.byteLength(body.input) > 128 * 1024 ||
+    typeof body.instructions !== "string" ||
+    !body.instructions.length ||
+    Buffer.byteLength(body.instructions) > 128 * 1024 ||
+    !Array.isArray(body.conversation_history) ||
+    body.conversation_history.length > 64 ||
+    Buffer.byteLength(JSON.stringify(body.conversation_history)) > 128 * 1024 ||
+    body.conversation_history.some(
+      (item) =>
+        !record(item) ||
+        Object.keys(item).sort().join(",") !== "content,role" ||
+        !["user", "assistant"].includes(item.role) ||
+        typeof item.content !== "string"
+    ) ||
+    !/^sellable_endpoint_[a-f0-9]{32}$/.test(body.session_id ?? "") ||
+    body.provider !== "claude-code" ||
+    !record(body.model_options) ||
+    Object.keys(body.model_options).some(
+      (key) =>
+        !["reasoning_effort", "sellable_opener_output_contract"].includes(key)
+    ) ||
+    !models.some(
+      (model) =>
+        model.provider === body.provider &&
+        model.model === body.model &&
+        model.reasoningEfforts.includes(body.model_options.reasoning_effort)
+    )
+  )
+    throw new Error("claude_runs_request_rejected");
+  const contract = body.model_options.sellable_opener_output_contract;
+  const schema =
+    contract === undefined
+      ? null
+      : validateOpenerOutputContract(contract).schema;
+  return {
+    input: body.conversation_history.length
+      ? JSON.stringify({
+          conversation_history: body.conversation_history,
+          input: body.input,
+        })
+      : body.input,
+    instructions: body.instructions,
+    schema,
+    model: body.model,
+    effort: body.model_options.reasoning_effort,
+  };
+}
+
+export function claudeInvocation(request, root) {
+  return {
+    command: `${root}/cli/node_modules/.bin/claude`,
+    args: [
+      "-p",
+      "--model",
+      request.model,
+      "--effort",
+      request.effort,
+      "--output-format",
+      "json",
+      ...(request.schema
+        ? ["--json-schema", JSON.stringify(request.schema)]
+        : []),
+      "--tools",
+      "",
+      "--permission-mode",
+      "dontAsk",
+      "--strict-mcp-config",
+      "--mcp-config",
+      '{"mcpServers":{}}',
+      "--setting-sources",
+      "",
+      "--settings",
+      '{"disableAllHooks":true,"autoMemoryEnabled":false}',
+      "--disable-slash-commands",
+      "--no-session-persistence",
+      "--max-turns",
+      "3",
+      "--system-prompt",
+      request.instructions,
+    ],
+    // Whitelist instead of inheriting the runtime's provider keys, URLs, hooks,
+    // plugin paths, NODE_OPTIONS, or workspace access credentials.
+    options: {
+      cwd: `${root}/work`,
+      detached: true,
+      stdio: ["pipe", "pipe", "pipe"],
+      env: {
+        PATH: "/usr/local/bin:/usr/bin:/bin",
+        HOME: `${root}/claude`,
+        CLAUDE_CONFIG_DIR: `${root}/claude`,
+        LANG: "C.UTF-8",
+        CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: "1",
+      },
+    },
+  };
+}
+
+export function parseClaudeResult(stdout, request) {
+  const result = JSON.parse(stdout);
+  const models = Object.keys(result.modelUsage ?? {});
+  if (
+    result.type !== "result" ||
+    result.is_error !== false ||
+    result.subtype !== "success" ||
+    (request.schema
+      ? !record(result.structured_output)
+      : typeof result.result !== "string") ||
+    (result.permission_denials ?? []).length ||
+    !models.length ||
+    models.some(
+      (model) =>
+        model !== request.model && !model.startsWith(`${request.model}-`)
+    )
+  )
+    throw new Error("claude_runs_output_rejected");
+  const output = request.schema
+    ? JSON.stringify(result.structured_output)
+    : result.result;
+  if (!output.trim()) throw new Error("claude_runs_output_empty");
+  if (Buffer.byteLength(output) > MAX_OUTPUT)
+    throw new Error("claude_runs_output_too_large");
+  return {
+    output,
+    runtime: { provider: "claude-code", model: models[0] },
+    usage: {
+      input_tokens: result.usage?.input_tokens ?? 0,
+      output_tokens: result.usage?.output_tokens ?? 0,
+      cache_read_tokens: result.usage?.cache_read_input_tokens ?? 0,
+      cache_write_tokens: result.usage?.cache_creation_input_tokens ?? 0,
+    },
+  };
+}
+
+export function startClaudeRun(
+  request,
+  { root, spawnImpl = spawn, timeoutMs = 750_000 } = {}
+) {
+  const invocation = claudeInvocation(request, root);
+  const child = spawnImpl(
+    invocation.command,
+    invocation.args,
+    invocation.options
+  );
+  let reason = null;
+  let killTimer;
+  const stop = (code = "claude_runs_cancelled") => {
+    reason ??= code;
+    try {
+      process.kill(-child.pid, "SIGTERM");
+    } catch {
+      child.kill("SIGTERM");
+    }
+    killTimer ??= setTimeout(() => {
+      try {
+        process.kill(-child.pid, "SIGKILL");
+      } catch {
+        child.kill("SIGKILL");
+      }
+    }, 5_000);
+    killTimer.unref();
+  };
+  const promise = new Promise((resolve, reject) => {
+    const chunks = [];
+    let bytes = 0;
+    const timer = setTimeout(() => stop("claude_runs_timeout"), timeoutMs);
+    child.stdout.on("data", (chunk) => {
+      bytes += chunk.length;
+      if (bytes > MAX_CLI_OUTPUT) stop("claude_runs_output_too_large");
+      else chunks.push(chunk);
+    });
+    // Drain diagnostics without logging prompts, credentials, or message bodies.
+    child.stderr.on("data", () => {});
+    child.once("error", () => {
+      clearTimeout(timer);
+      reject(new Error("claude_runs_cli_unavailable"));
+    });
+    child.once("close", (code) => {
+      clearTimeout(timer);
+      clearTimeout(killTimer);
+      if (reason || code !== 0)
+        return reject(new Error(reason ?? "claude_runs_cli_failed"));
+      try {
+        resolve(
+          parseClaudeResult(Buffer.concat(chunks).toString("utf8"), request)
+        );
+      } catch {
+        reject(new Error("claude_runs_output_rejected"));
+      }
+    });
+    child.stdin.on("error", () => {});
+    child.stdin.end(request.input);
+  });
+  return { promise, stop };
+}
+
+export function createClaudeRunsApi({
+  token,
+  connection,
+  execute = (request) =>
+    startClaudeRun(request, { root: connection.localRoot }),
+  audit = () => {},
+  maxConcurrency = 2,
+} = {}) {
+  if (!/^[a-f0-9]{64}$/.test(token ?? ""))
+    throw new Error("claude_runs_key_rejected");
+  const recordAudit = (entry) => {
+    try {
+      audit(entry);
+    } catch {
+      /* Logging cannot crash the Admin runtime. */
+    }
+  };
+  const runs = new Map();
+  let active = 0;
+  const json = (res, status, body) => {
+    res.writeHead(status, {
+      "content-type": "application/json",
+      "cache-control": "no-store",
+      "retry-after": "2",
+    });
+    res.end(JSON.stringify(body));
+  };
+  const terminal = (run, event, fields) => {
+    Object.assign(run, fields);
+    run.event = {
+      event,
+      run_id: run.run_id,
+      timestamp: new Date().toISOString(),
+      ...(run.status === "completed"
+        ? { output: run.output, runtime: run.runtime, usage: run.usage }
+        : run.status === "failed"
+          ? { error: run.error }
+          : {}),
+    };
+    for (const res of run.listeners)
+      res.end(`data: ${JSON.stringify(run.event)}\n\n`);
+    run.listeners.clear();
+    recordAudit({
+      runId: run.run_id,
+      status: run.status,
+      servedRuntime: run.runtime ?? null,
+      usage: run.usage ?? null,
+      durationMs: Date.now() - run.startedAt,
+      outputDigest: run.output ? hash(run.output) : null,
+    });
+    setTimeout(() => runs.delete(run.run_id), 3_600_000).unref();
+  };
+  const server = createServer(async (req, res) => {
+    const provided = Buffer.from(req.headers.authorization ?? "");
+    const expected = Buffer.from(`Bearer ${token}`);
+    if (
+      provided.length !== expected.length ||
+      !timingSafeEqual(provided, expected)
+    )
+      return json(res, 401, { error: "claude_runs_auth_required" });
+    if (
+      req.headers["x-sellable-workspace-id"] !== connection.workspaceId ||
+      req.headers["x-sellable-agent-id"] !== connection.agentId
+    )
+      return json(res, 403, { error: "claude_runs_scope_rejected" });
+    if (req.method === "GET" && req.url === "/health")
+      return json(res, 200, {
+        ok: true,
+        provider: "claude-code",
+        active,
+        scope: {
+          workspaceId: connection.workspaceId,
+          agentId: connection.agentId,
+        },
+      });
+    if (req.method === "POST" && req.url === "/v1/runs") {
+      if (active >= maxConcurrency || runs.size >= 200)
+        return json(res, 429, { error: "claude_runs_busy" });
+      let request;
+      try {
+        let size = 0;
+        const chunks = [];
+        for await (const chunk of req) {
+          size += chunk.length;
+          if (size > MAX_BODY) {
+            json(res, 413, { error: "claude_runs_input_too_large" });
+            return;
+          }
+          chunks.push(chunk);
+        }
+        const body = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+        request = validateClaudeRunsRequest(body, connection.models);
+      } catch (error) {
+        recordAudit({
+          status: "request-rejected",
+          reason: /^claude_runs_[a-z_]+$/.test(error.message ?? "")
+            ? error.message
+            : "claude_runs_invalid_request",
+        });
+        return json(res, 400, { error: "claude_runs_request_rejected" });
+      }
+      // Check again after reading: concurrent uploads cannot over-admit.
+      if (active >= maxConcurrency || runs.size >= 200)
+        return json(res, 429, { error: "claude_runs_busy" });
+      const run = {
+        run_id: `run_${randomBytes(16).toString("hex")}`,
+        status: "running",
+        startedAt: Date.now(),
+        listeners: new Set(),
+        consumed: false,
+      };
+      active++;
+      runs.set(run.run_id, run);
+      try {
+        run.execution = execute(request);
+        run.execution.promise
+          .then(
+            (result) =>
+              terminal(run, "run.completed", {
+                status: "completed",
+                ...result,
+              }),
+            (error) =>
+              terminal(
+                run,
+                run.stopping && error.message === "claude_runs_cancelled"
+                  ? "run.cancelled"
+                  : "run.failed",
+                run.stopping && error.message === "claude_runs_cancelled"
+                  ? { status: "cancelled" }
+                  : { status: "failed", error: "claude_runs_generation_failed" }
+              )
+          )
+          .finally(() => active--);
+      } catch {
+        active--;
+        terminal(run, "run.failed", {
+          status: "failed",
+          error: "claude_runs_cli_unavailable",
+        });
+      }
+      return json(res, 202, { run_id: run.run_id, status: "started" });
+    }
+    const match =
+      /^\/v1\/runs\/(run_[a-f0-9]{32})(?:\/(events|stop|approval))?$/.exec(
+        req.url ?? ""
+      );
+    const run = match && runs.get(match[1]);
+    if (!run) return json(res, 404, { error: "claude_runs_run_missing" });
+    if (req.method === "GET" && !match[2])
+      return json(res, 200, {
+        run_id: run.run_id,
+        status: run.status,
+        ...(run.output
+          ? { output: run.output, runtime: run.runtime, usage: run.usage }
+          : {}),
+        ...(run.error ? { error: run.error } : {}),
+      });
+    if (req.method === "GET" && match[2] === "events") {
+      if (run.consumed)
+        return json(res, 404, { error: "claude_runs_events_consumed" });
+      run.consumed = true;
+      res.writeHead(200, {
+        "content-type": "text/event-stream",
+        "cache-control": "no-store",
+      });
+      res.flushHeaders();
+      if (run.event) return res.end(`data: ${JSON.stringify(run.event)}\n\n`);
+      run.listeners.add(res);
+      const heartbeat = setInterval(
+        () => res.write(": keep-alive\n\n"),
+        15_000
+      );
+      res.once("close", () => {
+        clearInterval(heartbeat);
+        run.listeners.delete(res);
+      });
+      return;
+    }
+    if (req.method === "POST" && match[2] === "stop") {
+      if (run.event)
+        return json(res, 200, {
+          run_id: run.run_id,
+          status: run.status,
+          ...(run.output
+            ? { output: run.output, runtime: run.runtime, usage: run.usage }
+            : {}),
+        });
+      run.stopping = true;
+      run.execution.stop();
+      return json(res, 200, { run_id: run.run_id, status: "stopping" });
+    }
+    return json(res, 405, { error: "claude_runs_method_rejected" });
+  });
+  server.stopActiveRuns = async () => {
+    const activeRuns = [...runs.values()].filter(
+      (run) => !run.event && run.execution
+    );
+    for (const run of activeRuns) {
+      run.stopping = true;
+      run.execution.stop();
+    }
+    await Promise.allSettled(activeRuns.map((run) => run.execution.promise));
+  };
+  return server;
+}
+
+// The Admin runtime owns these listeners for its lifetime. Image-owned startup
+// plus the persistent CLI/auth directory makes normal restarts repeatable.
+export async function startConfiguredClaudeRunsApis({
+  env = process.env,
+  diagnostic = () => {},
+  createApi = createClaudeRunsApi,
+  readToken = (path) => readFileSync(path, "utf8").trim(),
+} = {}) {
+  const services = [];
+  for (const connection of parseRunsApiConnections(
+    env[RUNS_API_CONNECTIONS_ENV]
+  )) {
+    if (
+      !connection.localRoot ||
+      connection.runtimeId !== env.SELLABLE_RUNTIME_ID
+    )
+      continue;
+    try {
+      const token = readToken(connection.apiKeyFile);
+      const server = createApi({
+        token,
+        connection,
+        audit: (entry) =>
+          appendFileSync(
+            `${connection.localRoot}/audit.jsonl`,
+            `${JSON.stringify({ at: new Date().toISOString(), ...entry })}\n`,
+            { mode: 0o600 }
+          ),
+      });
+      await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(
+          Number(new URL(connection.baseUrl).port),
+          "127.0.0.1",
+          resolve
+        );
+      });
+      services.push(server);
+      diagnostic({
+        ok: true,
+        code: "claude_runs_api_ready",
+        baseUrl: connection.baseUrl,
+      });
+    } catch {
+      diagnostic({ ok: false, code: "claude_runs_api_unavailable" });
+    }
+  }
+  return {
+    async stop() {
+      for (const server of services) {
+        await server.stopActiveRuns();
+        await new Promise((resolve) => {
+          server.close(resolve);
+          server.closeAllConnections();
+        });
+      }
+    },
+  };
+}