@sellable/install 0.1.794 → 0.1.795-wip.runtime-ux.20261004.1

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

@@ -0,0 +1,563 @@
+import { execFile, 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",
+      },
+    },
+  };
+}
+
+// Uses the same isolated environment as generation. Only a typed status leaves
+// this boundary; CLI stdout can contain account identity and is never forwarded.
+export function readClaudeAuthentication({
+  root,
+  execFileImpl = execFile,
+  timeoutMs = 8_000,
+} = {}) {
+  const invocation = claudeInvocation(
+    { instructions: "", input: "", model: "claude-opus", effort: "high" },
+    root
+  );
+  return new Promise((resolve) => {
+    execFileImpl(
+      invocation.command,
+      ["auth", "status"],
+      {
+        cwd: invocation.options.cwd,
+        env: invocation.options.env,
+        timeout: timeoutMs,
+        maxBuffer: 16 * 1024,
+        encoding: "utf8",
+      },
+      (error, stdout) => {
+        try {
+          const value = JSON.parse(stdout);
+          if (value.loggedIn === false) return resolve("SIGN_IN_REQUIRED");
+          if (!error && value.loggedIn === true) return resolve("READY");
+        } catch {
+          /* A missing or incompatible CLI is unavailable, never ready. */
+        }
+        resolve("UNAVAILABLE");
+      }
+    );
+  });
+}
+
+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) => {
+    let activeRun;
+    let stopped = false;
+    return {
+      promise: (async () => {
+        const state = await checkAuthentication();
+        if (stopped) throw new Error("claude_runs_cancelled");
+        if (state !== "READY")
+          throw new Error(
+            state === "SIGN_IN_REQUIRED"
+              ? "claude_runs_sign_in_required"
+              : "claude_runs_auth_check_unavailable"
+          );
+        activeRun = startClaudeRun(request, { root: connection.localRoot });
+        return activeRun.promise;
+      })(),
+      stop() {
+        stopped = true;
+        activeRun?.stop();
+      },
+    };
+  },
+  audit = () => {},
+  maxConcurrency = 2,
+  checkAuthentication = () =>
+    readClaudeAuthentication({ root: connection.localRoot }),
+} = {}) {
+  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") {
+      const authentication = await checkAuthentication().catch(
+        () => "UNAVAILABLE"
+      );
+      return json(res, 200, {
+        ok: authentication === "READY",
+        authentication,
+        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_sign_in_required",
+                        "claude_runs_auth_check_unavailable",
+                      ].includes(error.message)
+                        ? error.message
+                        : "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();
+        });
+      }
+    },
+  };
+}

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

@@ -93,12 +93,12 @@ import {
   validateEndpointUatCompletionControl,
 } from "./endpoint-uat-completion-gate.mjs";
 import {
-  createHermesRunsClient,
   createHermesSessionRetention,
   HERMES_RUNS_FIXTURE_IDENTITY,
   validateEndpointModelSelection,
   validateOpenerOutputContract,
 } from "./hermes-runs-client.mjs";
+import { createConfiguredRunsClient } from "./runs-api-connections.mjs";
 import {
   createOpenerStageExecution,
   usesOpenerDraftStrategy,
@@ -126,7 +126,7 @@ const RUNTIME_GENERATION = Number(
 const BOOT_SESSION_ID = randomUUID();
 const HERMES_VERSION = process.env.SELLABLE_AGENT_HERMES_VERSION ?? "0.21.5";
 const INSTALLER_PACKAGE =
-  process.env.SELLABLE_AGENT_INSTALLER_PACKAGE ?? "@sellable/install@0.1.794";
+  process.env.SELLABLE_AGENT_INSTALLER_PACKAGE ?? "@sellable/install@0.1.795-wip.runtime-ux.20261004.1";
 const MCP_PACKAGE =
   process.env.SELLABLE_AGENT_MCP_PACKAGE ?? "@sellable/mcp@0.1.957";
 export const ENDPOINT_MAX_CONCURRENT_RUNS = 10;
@@ -1605,8 +1605,7 @@ export function createCustomerEndpointRelay(options = {}) {
     runtimeGeneration,
     getApiKeyFile = ({ claim }) =>
       join(SECRET_ROOT, claim.runtime.profileId, "api-server-key"),
-    createRunsClient = ({ apiKeyFile }) =>
-      createHermesRunsClient({ apiKeyFile }),
+    createRunsClient = createConfiguredRunsClient,
     now = () => new Date(),
     sleepImpl = sleep,
     diagnostic = () => {},

package/lib/sellable-agent/fly-customer-image/endpoint-model-selection.d.mts

@@ -0,0 +1,26 @@
+export const ENDPOINT_MODEL_SELECTION_ALLOWLIST: Readonly<{
+  openrouter: readonly [
+    "anthropic/claude-opus-5.5",
+    "deepseek/deepseek-v4-flash-0731",
+    "openai/gpt-6-luna",
+    "anthropic/claude-sonnet-5.5",
+  ];
+}>;
+export const ENDPOINT_MODEL_REASONING_EFFORTS: readonly [
+  "none",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+];
+export type EndpointModelSelection = Readonly<{
+  provider: string;
+  model: string;
+  reasoningEffort: (typeof ENDPOINT_MODEL_REASONING_EFFORTS)[number];
+  runsApiBaseUrl?: string;
+  fallbackPolicy?: "STOP" | "PRODUCT_DEFAULT";
+}>;
+export function normalizeRunsApiBaseUrl(value: unknown): string | null;
+export function compileEndpointModelSelection(
+  value: unknown
+): EndpointModelSelection | null | "invalid";