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

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

@@ -0,0 +1,245 @@
+import { createHash } from "node:crypto";
+import {
+  compileEndpointModelSelection,
+  normalizeRunsApiBaseUrl,
+} from "./endpoint-model-selection.mjs";
+import { createHermesRunsClient } from "./hermes-runs-client.mjs";
+import { createOpenAiRunsClient } from "./openai-runs-client.mjs";
+
+export const RUNS_API_CONNECTIONS_ENV =
+  "SELLABLE_AGENT_RUNS_API_CONNECTIONS_JSON";
+const id = (value) =>
+  typeof value === "string" && /^[A-Za-z0-9_.:-]{1,128}$/.test(value);
+const record = (value) =>
+  value && typeof value === "object" && !Array.isArray(value);
+const stable = (value) =>
+  Array.isArray(value)
+    ? `[${value.map(stable).join(",")}]`
+    : record(value)
+      ? `{${Object.keys(value)
+          .sort()
+          .map((key) => `${JSON.stringify(key)}:${stable(value[key])}`)
+          .join(",")}}`
+      : JSON.stringify(value);
+const fail = () => {
+  throw new Error("runs_api_connection_configuration_rejected");
+};
+
+// Only the control plane's machine configuration supplies this registry. It
+// contains credential file references, never credentials or request input.
+export function parseRunsApiConnections(raw) {
+  if (raw === undefined || raw === "") return [];
+  if (typeof raw !== "string" || Buffer.byteLength(raw) > 64 * 1024) fail();
+  let entries;
+  try {
+    entries = JSON.parse(raw);
+  } catch {
+    fail();
+  }
+  if (!Array.isArray(entries) || entries.length > 32) fail();
+  const seen = new Set();
+  return entries.map((entry) => {
+    if (
+      !record(entry) ||
+      Object.keys(entry).some(
+        (key) =>
+          ![
+            "runtimeId",
+            "workspaceId",
+            "agentId",
+            "baseUrl",
+            "apiKeyFile",
+            "endpointIds",
+            "workKinds",
+            "models",
+            "localRoot",
+            "name",
+            "protocol",
+            "structuredOutputs",
+          ].includes(key)
+      ) ||
+      ![entry.runtimeId, entry.workspaceId, entry.agentId].every(id) ||
+      (entry.protocol !== undefined &&
+        !["runs-api", "openai-chat", "openai-responses"].includes(
+          entry.protocol
+        )) ||
+      (entry.structuredOutputs !== undefined &&
+        typeof entry.structuredOutputs !== "boolean") ||
+      (entry.name !== undefined &&
+        (typeof entry.name !== "string" ||
+          !/^[\p{L}\p{N} .()_-]{1,80}$/u.test(entry.name))) ||
+      typeof entry.apiKeyFile !== "string" ||
+      !/^\/(?:opt\/data|run\/secrets)\/[A-Za-z0-9_./-]{1,250}$/.test(
+        entry.apiKeyFile
+      ) ||
+      entry.apiKeyFile
+        .split("/")
+        .some((part) => part === "." || part === "..") ||
+      !Array.isArray(entry.endpointIds) ||
+      !entry.endpointIds.length ||
+      entry.endpointIds.length > 64 ||
+      !entry.endpointIds.every(id) ||
+      !Array.isArray(entry.workKinds) ||
+      !entry.workKinds.length ||
+      !entry.workKinds.every((kind) =>
+        ["STANDARD", "OPENER", "REPLY", "FOLLOW_UP"].includes(kind)
+      ) ||
+      !Array.isArray(entry.models) ||
+      !entry.models.length ||
+      entry.models.length > 16
+    )
+      fail();
+    const baseUrl = normalizeRunsApiBaseUrl(entry.baseUrl);
+    if (!baseUrl) fail();
+    const identity = `${entry.runtimeId}:${baseUrl}`;
+    if (seen.has(identity)) fail();
+    seen.add(identity);
+    const models = entry.models.map((model) => {
+      if (
+        !record(model) ||
+        Object.keys(model).sort().join(",") !==
+          "model,provider,reasoningEfforts" ||
+        !Array.isArray(model.reasoningEfforts) ||
+        !model.reasoningEfforts.length ||
+        model.reasoningEfforts.some(
+          (reasoningEffort) =>
+            compileEndpointModelSelection({
+              provider: model.provider,
+              model: model.model,
+              reasoningEffort,
+              runsApiBaseUrl: baseUrl,
+            }) === "invalid"
+        )
+      )
+        fail();
+      return { ...model, reasoningEfforts: [...model.reasoningEfforts] };
+    });
+    if (entry.localRoot !== undefined) {
+      const url = new URL(baseUrl);
+      if (
+        (entry.protocol !== undefined && entry.protocol !== "runs-api") ||
+        typeof entry.localRoot !== "string" ||
+        !/^\/opt\/data\/[A-Za-z0-9_-]{1,80}$/.test(entry.localRoot) ||
+        entry.apiKeyFile !== `${entry.localRoot}/api-key` ||
+        url.hostname !== "127.0.0.1" ||
+        url.protocol !== "http:" ||
+        url.pathname !== "/" ||
+        !url.port ||
+        Number(url.port) < 1024 ||
+        models.some(
+          (model) =>
+            model.provider !== "claude-code" ||
+            !/^claude-[a-z0-9-]{1,100}$/.test(model.model) ||
+            model.reasoningEfforts.some(
+              (effort) => !["low", "medium", "high"].includes(effort)
+            )
+        )
+      )
+        fail();
+    }
+    return Object.freeze({
+      ...entry,
+      baseUrl,
+      models,
+      endpointIds: [...entry.endpointIds],
+      workKinds: [...entry.workKinds],
+    });
+  });
+}
+
+export function runsApiConnectionId(connection) {
+  return `runs_${createHash("sha256")
+    .update(
+      JSON.stringify([
+        connection.runtimeId,
+        connection.workspaceId,
+        connection.agentId,
+        connection.baseUrl,
+      ])
+    )
+    .digest("hex")
+    .slice(0, 24)}`;
+}
+
+export function runsApiConnectionsForRuntime(raw, runtime) {
+  return parseRunsApiConnections(raw).filter(
+    (connection) =>
+      connection.runtimeId === runtime.runtimeId &&
+      connection.workspaceId === runtime.workspaceId &&
+      connection.agentId === runtime.agentId
+  );
+}
+
+/** @param {any} options */
+export function createConfiguredRunsClient({
+  apiKeyFile,
+  claim,
+  env = process.env,
+  clientFactory = createHermesRunsClient,
+}) {
+  const selection = claim?.run?.modelSelection;
+  if (!selection?.runsApiBaseUrl) return clientFactory({ apiKeyFile });
+  const model = compileEndpointModelSelection(selection);
+  if (!model || model === "invalid") throw new Error("runs_api_model_rejected");
+  const connection = runsApiConnectionsForRuntime(
+    env[RUNS_API_CONNECTIONS_ENV],
+    {
+      runtimeId: claim.runtime?.runtimeId,
+      workspaceId: claim.attempt?.workspaceId,
+      agentId: claim.attempt?.agentId,
+    }
+  ).find((value) => value.baseUrl === model.runsApiBaseUrl);
+  const workKind = claim.run.productExecution?.workKind ?? "STANDARD";
+  if (
+    !connection ||
+    env.SELLABLE_RUNTIME_ID !== connection.runtimeId ||
+    !connection.endpointIds.includes(claim.attempt.endpointId) ||
+    !connection.workKinds.includes(workKind) ||
+    !connection.models.some(
+      (allowed) =>
+        allowed.provider === model.provider &&
+        allowed.model === model.model &&
+        allowed.reasoningEfforts.includes(model.reasoningEffort)
+    )
+  )
+    throw new Error("runs_api_connection_not_authorized");
+  // This client instance retains one destination and one credential for the
+  // entire attempt, including stream/status/stop, even if settings later change.
+  const client = connection.protocol?.startsWith("openai-")
+    ? createOpenAiRunsClient({
+        connection,
+        responseSchema: claim.revision?.outputSchema,
+        modelSelection: model,
+      })
+    : clientFactory({
+        baseUrl: connection.baseUrl,
+        apiKeyFile: connection.apiKeyFile,
+        scopeHeaders: {
+          "x-sellable-workspace-id": connection.workspaceId,
+          "x-sellable-agent-id": connection.agentId,
+        },
+      });
+  return Object.freeze({
+    ...client,
+    submit(compiled, options) {
+      // Public semantic endpoints have a published schema but no product tuple.
+      // Preserve that existing contract when calling a custom Runs service.
+      const schema = claim.revision?.outputSchema;
+      if (compiled.outputContract || !schema?.properties?.proposal)
+        return client.submit(compiled, options);
+      return client.submit(
+        {
+          ...compiled,
+          outputContract: {
+            schemaVersion: "sellable-opener-output-contract/v1",
+            schema,
+            nativeProposalSchemaDigest: createHash("sha256")
+              .update(stable(schema.properties.proposal))
+              .digest("hex"),
+          },
+        },
+        options
+      );
+    },
+  });
+}

package/lib/sellable-agent/fly-customer-image/runs-api-health-check.d.mts

@@ -0,0 +1,9 @@
+export function checkRunsApiConnection(
+  request: any,
+  options?: any
+): Promise<{ connectionId: string; state: string; checkedAt: string }>;
+
+export function verifyRunsApiSelection(
+  request: any,
+  options?: any
+): Promise<any>;

package/lib/sellable-agent/fly-customer-image/runs-api-health-check.mjs

@@ -0,0 +1,261 @@
+import { randomUUID } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { pathToFileURL } from "node:url";
+import { compileEndpointModelSelection } from "./endpoint-model-selection.mjs";
+import { createHermesRunsClient } from "./hermes-runs-client.mjs";
+import {
+  createConfiguredRunsClient,
+  RUNS_API_CONNECTIONS_ENV,
+  runsApiConnectionId,
+  runsApiConnectionsForRuntime,
+} from "./runs-api-connections.mjs";
+
+// Fixed read-only machine command. Callers supply identities, never a URL,
+// credential path, shell command, or prompt. The installed registry authorizes
+// the destination again on the machine before a credential is read.
+export async function checkRunsApiConnection(
+  request,
+  {
+    env = process.env,
+    fetchImpl = fetch,
+    readToken = (path) => readFile(path, "utf8"),
+  } = {}
+) {
+  const checkedAt = new Date().toISOString();
+  const result = (state) => ({
+    connectionId: request.connectionId,
+    state,
+    checkedAt,
+  });
+  if (request.runtimeId !== env.SELLABLE_RUNTIME_ID)
+    return result("NOT_CONFIGURED");
+  const connection = runsApiConnectionsForRuntime(
+    env[RUNS_API_CONNECTIONS_ENV],
+    request
+  ).find(
+    (candidate) =>
+      runsApiConnectionId(candidate) === request.connectionId &&
+      candidate.endpointIds.includes(request.endpointId)
+  );
+  if (!connection) return result("NOT_CONFIGURED");
+  try {
+    const token = (await readToken(connection.apiKeyFile)).trim();
+    if (!token || token.length > 8192 || /[\r\n]/.test(token))
+      return result("UNAVAILABLE");
+    const response = await fetchImpl(
+      `${connection.baseUrl}/${connection.protocol?.startsWith("openai-") ? "models" : "health"}`,
+      {
+        headers: {
+          authorization: `Bearer ${token}`,
+          ...(connection.protocol?.startsWith("openai-") ? {} : {
+            "x-sellable-workspace-id": connection.workspaceId,
+            "x-sellable-agent-id": connection.agentId,
+          }),
+        },
+        redirect: "error",
+        signal: AbortSignal.timeout(12_000),
+      }
+    );
+    if (response.status === 401 || response.status === 403)
+      return result("ACCESS_DENIED");
+    if (!response.ok) return result("UNAVAILABLE");
+    const reader = response.body?.getReader();
+    if (!reader) return result("UNAVAILABLE");
+    let text = "";
+    let size = 0;
+    try {
+      const decoder = new TextDecoder();
+      while (true) {
+        const chunk = await reader.read();
+        if (chunk.done) break;
+        size += chunk.value.byteLength;
+        if (size > 16_384) {
+          await reader.cancel();
+          return result("UNAVAILABLE");
+        }
+        text += decoder.decode(chunk.value, { stream: true });
+      }
+      text += decoder.decode();
+    } finally {
+      reader.releaseLock();
+    }
+    const health = JSON.parse(text);
+    if (connection.localRoot) {
+      if (
+        health.provider !== "claude-code" ||
+        health.scope?.workspaceId !== connection.workspaceId ||
+        health.scope?.agentId !== connection.agentId
+      )
+        return result("ACCESS_DENIED");
+      if (health.authentication === "SIGN_IN_REQUIRED")
+        return result("SIGN_IN_REQUIRED");
+      return result(
+        health.authentication === "READY" && health.ok === true
+          ? "READY"
+          : "UNAVAILABLE"
+      );
+    }
+    return result(
+      (
+        connection.protocol?.startsWith("openai-")
+          ? Array.isArray(health.data)
+          : health.ok === true
+      )
+        ? "REACHABLE"
+        : "UNAVAILABLE"
+    );
+  } catch {
+    return result("UNAVAILABLE");
+  }
+}
+
+export async function verifyRunsApiSelection(
+  request,
+  {
+    env = process.env,
+    makeDefaultClient = createHermesRunsClient,
+    makeConfiguredClient = createConfiguredRunsClient,
+    health = checkRunsApiConnection,
+  } = {}
+) {
+  const result = (state, servedRuntime) => ({
+    connectionId: request.connectionId,
+    state,
+    checkedAt: new Date().toISOString(),
+    ...(servedRuntime ? { servedRuntime } : {}),
+  });
+  if (
+    request.runtimeId !== env.SELLABLE_RUNTIME_ID ||
+    !/^[A-Za-z0-9_-]{1,128}$/.test(request.profileId ?? "")
+  )
+    return result("NOT_CONFIGURED");
+  const selection = compileEndpointModelSelection(request.modelSelection);
+  if (selection === "invalid") return result("NOT_CONFIGURED");
+  let verificationWorkKind = "STANDARD";
+  if (selection?.runsApiBaseUrl) {
+    const connection = runsApiConnectionsForRuntime(
+      env[RUNS_API_CONNECTIONS_ENV],
+      request
+    ).find(
+      (item) =>
+        runsApiConnectionId(item) === request.connectionId &&
+        item.baseUrl === selection.runsApiBaseUrl
+    );
+    if (!connection?.endpointIds.includes(request.endpointId))
+      return result("NOT_CONFIGURED");
+    verificationWorkKind = connection.workKinds.includes("STANDARD")
+      ? "STANDARD"
+      : connection.workKinds[0];
+    if (connection.localRoot) {
+      const readiness = await health(request, { env });
+      if (readiness.state !== "READY") return readiness;
+    }
+  } else if (request.connectionId !== (selection ? "openrouter" : "default"))
+    return result("NOT_CONFIGURED");
+  const apiKeyFile =
+    env.SELLABLE_AGENT_SERVER_AUTHENTICATED_KIND === "ADMIN"
+      ? "/run/sellable-agent/admin-runtime/api-server-key"
+      : `/run/sellable-agent/${request.profileId}/api-server-key`;
+  let client;
+  let run;
+  try {
+    client = selection?.runsApiBaseUrl
+      ? makeConfiguredClient({
+          apiKeyFile,
+          env,
+          claim: {
+            runtime: { runtimeId: request.runtimeId },
+            attempt: {
+              workspaceId: request.workspaceId,
+              agentId: request.agentId,
+              endpointId: request.endpointId,
+            },
+            run: {
+              modelSelection: selection,
+              productExecution: { workKind: verificationWorkKind },
+            },
+          },
+        })
+      : makeDefaultClient({ apiKeyFile });
+    const compiled = {
+      input: "Connection verification. Reply with SELLABLE_CONNECTION_OK.",
+      instructions:
+        "This is a connection check. Do not use tools or take actions. Return exactly SELLABLE_CONNECTION_OK and nothing else.",
+      conversationHistory: [],
+      correlation: `connection-check-${randomUUID()}`,
+      ...(selection ? { modelSelection: selection } : {}),
+    };
+    const signal = AbortSignal.timeout(70_000);
+    // Default Hermes gets the tool-free verification prefix. A Runs service
+    // owns its own tool policy; the Claude and OpenAI adapters are tool-free.
+    run = await (
+      selection?.runsApiBaseUrl ? client.submit : client.submitVerification
+    )(compiled, { signal });
+    await client.streamEvents(run.runId, { signal, onEvent: async () => {} });
+    const status = await client.status(run.runId, { signal });
+    const served = status.servedRuntime;
+    if (
+      status.status !== "completed" ||
+      typeof status.output !== "string" ||
+      status.output.trim() !== "SELLABLE_CONNECTION_OK" ||
+      !served
+    )
+      return result("UNAVAILABLE");
+    if (
+      selection &&
+      (served.provider !== selection.provider ||
+        (served.model !== selection.model &&
+          !served.model.startsWith(`${selection.model}-`)))
+    )
+      return result("UNAVAILABLE");
+    return result("READY", served);
+  } catch {
+    if (client && run)
+      await client
+        .stop(run.runId, { signal: AbortSignal.timeout(3_000) })
+        .catch(() => {});
+    return result("UNAVAILABLE");
+  }
+}
+
+if (
+  process.argv[1] &&
+  import.meta.url === pathToFileURL(process.argv[1]).href
+) {
+  try {
+    const raw = process.argv[2];
+    if (!raw || raw.length > 4096) throw new Error();
+    const request = JSON.parse(Buffer.from(raw, "base64url").toString("utf8"));
+    const verify = request.action === "VERIFY";
+    if (
+      Object.keys(request)
+        .filter(
+          (key) => !["action", "profileId", "modelSelection"].includes(key)
+        )
+        .sort()
+        .join(",") !==
+        "agentId,connectionId,endpointId,runtimeId,workspaceId" ||
+      [
+        request.agentId,
+        request.connectionId,
+        request.endpointId,
+        request.runtimeId,
+        request.workspaceId,
+      ].some(
+        (value) =>
+          typeof value !== "string" || !/^[A-Za-z0-9_.:-]{1,128}$/.test(value)
+      ) ||
+      (request.action !== undefined && !verify)
+    )
+      throw new Error();
+    process.stdout.write(
+      JSON.stringify(
+        await (verify
+          ? verifyRunsApiSelection(request)
+          : checkRunsApiConnection(request))
+      )
+    );
+  } catch {
+    process.exitCode = 1;
+  }
+}

package/lib/sellable-agent/host-bootstrap.mjs

@@ -38,7 +38,7 @@ import { installAgentHostServices } from "./service-installer.mjs";
 const PACKAGE_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "../..");
 const VERSION = "sellable-agent-host-bootstrap/v1";
 const RECEIPT_VERSION = "sellable-agent-host-registration/v1";
-const INSTALLER_PACKAGE = "@sellable/install@0.1.794";
+const INSTALLER_PACKAGE = "@sellable/install@0.1.795-wip.runtime-ux.20261004.1";
 const MCP_PACKAGE = "@sellable/mcp@0.1.957";
 const HERMES_VERSION = "0.18.0";
 const SHA256 = /^[a-f0-9]{64}$/;

package/lib/sellable-agent/host-worker.mjs

@@ -1546,7 +1546,7 @@ export function compileClaimToProfileDesired(activeClaim, config) {
       ]) ||
       pinned.hermesCli !== "hermes" ||
       pinned.hermesVersion !== "0.18.0" ||
-      pinned.installerPackage !== "@sellable/install@0.1.794" ||
+      pinned.installerPackage !== "@sellable/install@0.1.795-wip.runtime-ux.20261004.1" ||
       pinned.mcpPackage !== "@sellable/mcp@0.1.957" ||
       !Array.isArray(policy.toolInclude) ||
       policy.toolInclude.length === 0 ||

package/lib/sellable-agent/profile-materializer.mjs

@@ -312,7 +312,7 @@ function validateDesired(desired) {
     desired.serviceCredentialGeneration < 1 ||
     desired.hermesCli !== "hermes" ||
     desired.hermesVersion !== "0.18.0" ||
-    desired.installerPackage !== "@sellable/install@0.1.794" ||
+    desired.installerPackage !== "@sellable/install@0.1.795-wip.runtime-ux.20261004.1" ||
     desired.mcpPackage !== "@sellable/mcp@0.1.957" ||
     !Array.isArray(desired.toolInclude) ||
     desired.toolInclude.length === 0 ||

package/lib/sellable-agent/provisioning-adapter.mjs

@@ -25,7 +25,7 @@ import { fileURLToPath } from "node:url";
 import { deriveContainedProfileId } from "./profile-materializer.mjs";
 
 export const PROVISIONING_ACTION = "PROVISION_HERMES_PROFILE";
-export const PINNED_INSTALL_PACKAGE = "@sellable/install@0.1.794";
+export const PINNED_INSTALL_PACKAGE = "@sellable/install@0.1.795-wip.runtime-ux.20261004.1";
 export const PINNED_MCP_PACKAGE = "@sellable/mcp@0.1.957";
 const PINNED_INSTALL_VERSION = PINNED_INSTALL_PACKAGE.slice(
   PINNED_INSTALL_PACKAGE.lastIndexOf("@") + 1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sellable/install",
-  "version": "0.1.794",
+  "version": "0.1.795-wip.runtime-ux.20261004.1",
   "type": "module",
   "description": "One-command installer for Sellable MCP in Claude Code, Codex, and Hermes",
   "bin": {