@sellable/install 0.1.483 → 0.1.486-wip.phase169.20260804.2

package/lib/sellable-agent/model-health-reporter.mjs

@@ -0,0 +1,377 @@
+import { randomUUID } from "node:crypto";
+import {
+  chmodSync,
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  writeFileSync,
+} from "node:fs";
+import { dirname } from "node:path";
+
+const SHA256 = /^[a-f0-9]{64}$/;
+const SAFE_ID = /^[A-Za-z0-9_.:-]{1,256}$/;
+const FINGERPRINT = /^[a-f0-9]{16,64}$/;
+const SAFE_REASON = /^[a-z0-9_.:-]{1,128}$/;
+
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+function rejectIdentity() {
+  throw new Error("model_health_report_identity_rejected");
+}
+
+function safeOrigin(value, allowHttpLoopback) {
+  try {
+    const parsed = new URL(value);
+    const testHttp =
+      allowHttpLoopback === true &&
+      parsed.protocol === "http:" &&
+      ["127.0.0.1", "localhost", "host.docker.internal"].includes(
+        parsed.hostname
+      );
+    if (
+      (parsed.protocol !== "https:" && !testHttp) ||
+      parsed.username ||
+      parsed.password ||
+      parsed.pathname !== "/" ||
+      parsed.search ||
+      parsed.hash
+    ) {
+      return null;
+    }
+    return parsed.origin;
+  } catch {
+    return null;
+  }
+}
+
+function safeSnapshot(snapshot) {
+  if (
+    !isRecord(snapshot) ||
+    snapshot.schemaVersion !== "sellable-agent-model-auth-readback/v2" ||
+    !SAFE_ID.test(snapshot.activationId ?? "") ||
+    !Number.isSafeInteger(snapshot.bundleGeneration) ||
+    snapshot.bundleGeneration < 1 ||
+    !SHA256.test(snapshot.policyHash ?? "") ||
+    snapshot.provider !== "openai-codex" ||
+    !SAFE_ID.test(snapshot.model ?? "") ||
+    !Number.isSafeInteger(snapshot.fallbackDepth) ||
+    snapshot.fallbackDepth < 0 ||
+    snapshot.fallbackDepth > 8 ||
+    !["converged", "unknown"].includes(snapshot.desiredStatus) ||
+    !["current", "pending_start"].includes(snapshot.materializedStatus) ||
+    !Array.isArray(snapshot.slots) ||
+    snapshot.slots.length > 2 ||
+    !isRecord(snapshot.openrouter) ||
+    !FINGERPRINT.test(snapshot.openrouter.keyFingerprint ?? "") ||
+    !["ok", "exhausted", "dead"].includes(snapshot.openrouter.state) ||
+    (snapshot.activeProvider !== undefined &&
+      snapshot.activeProvider !== null &&
+      !["openai-codex", "openrouter"].includes(snapshot.activeProvider)) ||
+    (snapshot.activeFallbackModelId !== undefined &&
+      snapshot.activeFallbackModelId !== null &&
+      (typeof snapshot.activeFallbackModelId !== "string" ||
+        snapshot.activeFallbackModelId.length < 1 ||
+        snapshot.activeFallbackModelId.length > 256))
+  ) {
+    throw new Error("model_health_snapshot_rejected");
+  }
+  const slots = snapshot.slots.map((slot) => {
+    if (
+      !isRecord(slot) ||
+      !["dittto-primary", "kaigo-secondary"].includes(slot.slotId) ||
+      !FINGERPRINT.test(slot.grantFingerprint ?? "") ||
+      !Number.isFinite(Date.parse(slot.expiresAt ?? "")) ||
+      !["ok", "exhausted", "dead"].includes(slot.state) ||
+      (slot.lastErrorReason !== null &&
+        !SAFE_REASON.test(slot.lastErrorReason ?? "")) ||
+      (slot.lastErrorResetAt !== null &&
+        !Number.isFinite(Date.parse(slot.lastErrorResetAt ?? "")))
+    ) {
+      throw new Error("model_health_snapshot_rejected");
+    }
+    return Object.freeze({
+      slotId: slot.slotId,
+      grantFingerprint: slot.grantFingerprint,
+      expiresAt: new Date(slot.expiresAt).toISOString(),
+      state: slot.state,
+      lastErrorReason: slot.lastErrorReason,
+      lastErrorResetAt:
+        slot.lastErrorResetAt === null
+          ? null
+          : new Date(slot.lastErrorResetAt).toISOString(),
+    });
+  });
+  return Object.freeze({
+    activationId: snapshot.activationId,
+    bundleGeneration: snapshot.bundleGeneration,
+    policyHash: snapshot.policyHash,
+    provider: snapshot.provider,
+    model: snapshot.model,
+    fallbackDepth: snapshot.fallbackDepth,
+    desiredStatus: snapshot.desiredStatus,
+    materializedStatus: snapshot.materializedStatus,
+    slots: Object.freeze(slots),
+    openrouter: Object.freeze({
+      keyFingerprint: snapshot.openrouter.keyFingerprint,
+      state: snapshot.openrouter.state,
+    }),
+    activeProvider: snapshot.activeProvider ?? null,
+    activeFallbackModelId: snapshot.activeFallbackModelId ?? null,
+  });
+}
+
+function codexHealthState(slot) {
+  if (slot.state === "ok") return "HEALTHY";
+  if (slot.state === "exhausted") return "REFRESHING";
+  if (/revok/.test(slot.lastErrorReason ?? "")) return "REVOKED";
+  if (/(?:auth|unauthor|invalid|expired)/.test(slot.lastErrorReason ?? "")) {
+    return "REAUTH_REQUIRED";
+  }
+  return "DEAD";
+}
+
+function fallbackHealthState(snapshot) {
+  const allFailed =
+    snapshot.slots.length === 2 &&
+    snapshot.slots.every((slot) => slot.state === "dead") &&
+    snapshot.openrouter.state === "dead";
+  if (allFailed) return Object.freeze({ state: "ALL_FAILED", modelId: null });
+  if (snapshot.activeProvider === "openrouter") {
+    return Object.freeze({
+      state: "OPENROUTER_ACTIVE",
+      modelId:
+        typeof snapshot.activeFallbackModelId === "string"
+          ? snapshot.activeFallbackModelId
+          : null,
+    });
+  }
+  return Object.freeze({ state: "CODEX_ACTIVE", modelId: null });
+}
+
+function loadSequence(path, identity) {
+  if (!path || !existsSync(path)) return 0;
+  const stat = lstatSync(path);
+  if (stat.isSymbolicLink() || !stat.isFile() || (stat.mode & 0o077) !== 0) {
+    throw new Error("model_health_sequence_store_rejected");
+  }
+  try {
+    const value = JSON.parse(readFileSync(path, "utf8"));
+    if (
+      value?.schemaVersion !== "sellable-agent-model-health-sequence/v1" ||
+      value.runtimeGeneration !== identity.runtimeGeneration ||
+      value.workloadKeyHash !== identity.workloadKeyHash
+    ) {
+      return 0;
+    }
+    if (!Number.isSafeInteger(value.sequence) || value.sequence < 0) {
+      throw new Error("model_health_sequence_store_rejected");
+    }
+    return value.sequence;
+  } catch (error) {
+    if (
+      error instanceof Error &&
+      error.message === "model_health_sequence_store_rejected"
+    ) {
+      throw error;
+    }
+    throw new Error("model_health_sequence_store_rejected");
+  }
+}
+
+function persistSequence(path, identity, sequence) {
+  if (!path) return;
+  mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+  const temporary = `${path}.${process.pid}.${randomUUID()}.tmp`;
+  writeFileSync(
+    temporary,
+    `${JSON.stringify({
+      schemaVersion: "sellable-agent-model-health-sequence/v1",
+      runtimeGeneration: identity.runtimeGeneration,
+      workloadKeyHash: identity.workloadKeyHash,
+      sequence,
+    })}\n`,
+    { flag: "wx", mode: 0o600 }
+  );
+  chmodSync(temporary, 0o600);
+  renameSync(temporary, path);
+  chmodSync(path, 0o600);
+}
+
+export function modelHealthCadenceMs(workloadKeyHash) {
+  if (!SHA256.test(workloadKeyHash ?? "")) rejectIdentity();
+  const jitter = Number.parseInt(workloadKeyHash.slice(0, 8), 16) % 60_001;
+  return 240_000 + jitter;
+}
+
+export function buildModelHealthReport(input) {
+  if (
+    !["CUSTOMER", "ADMIN"].includes(input?.kind) ||
+    !Number.isSafeInteger(input.runtimeGeneration) ||
+    input.runtimeGeneration < 1 ||
+    !SHA256.test(input.workloadKeyHash ?? "") ||
+    !SAFE_ID.test(input.machineId ?? "") ||
+    !Number.isSafeInteger(input.sequence) ||
+    input.sequence < 1 ||
+    !Number.isFinite(Date.parse(input.observedAt ?? "")) ||
+    (input.kind === "ADMIN"
+      ? !SAFE_ID.test(input.adminRuntimeGenerationId ?? "") ||
+        !/^[1-9][0-9]{0,19}$/.test(input.adminRuntimeGenerationFence ?? "")
+      : input.adminRuntimeGenerationId !== null ||
+        input.adminRuntimeGenerationFence !== null)
+  ) {
+    rejectIdentity();
+  }
+  const snapshot = safeSnapshot(input.snapshot);
+  const slots = new Map(snapshot.slots.map((slot) => [slot.slotId, slot]));
+  const primary = slots.get("dittto-primary");
+  const secondary = slots.get("kaigo-secondary");
+  if (!primary || !secondary) throw new Error("model_health_snapshot_rejected");
+  return Object.freeze({
+    schemaVersion: "sellable-agent-model-health/v1",
+    sequence: input.sequence,
+    observedAt: new Date(input.observedAt).toISOString(),
+    machineId: input.machineId,
+    runtimeGeneration: input.runtimeGeneration,
+    workloadKeyHash: input.workloadKeyHash,
+    kind: input.kind,
+    adminRuntimeGenerationId: input.adminRuntimeGenerationId,
+    adminRuntimeGenerationFence: input.adminRuntimeGenerationFence,
+    activationId: snapshot.activationId,
+    bundleGeneration: snapshot.bundleGeneration,
+    policyHash: snapshot.policyHash,
+    codex: Object.freeze({
+      primary: codexHealthState(primary),
+      secondary: codexHealthState(secondary),
+    }),
+    fallback: fallbackHealthState(snapshot),
+  });
+}
+
+/**
+ * @param {{
+ *   origin: string,
+ *   identity: Record<string, unknown>,
+ *   observe: () => unknown,
+ *   authorize: (body: unknown) => string,
+ *   fetchImpl?: typeof fetch,
+ *   now?: () => Date,
+ *   onError?: (error: unknown) => void,
+ *   setIntervalImpl?: typeof setInterval,
+ *   clearIntervalImpl?: typeof clearInterval,
+ *   allowHttpLoopback?: boolean,
+ *   sequencePath?: string | null,
+ * }} input
+ */
+export function createModelHealthReporter({
+  origin,
+  identity,
+  observe,
+  authorize,
+  fetchImpl = fetch,
+  now = () => new Date(),
+  onError = () => {},
+  setIntervalImpl = setInterval,
+  clearIntervalImpl = clearInterval,
+  allowHttpLoopback = false,
+  sequencePath = null,
+}) {
+  const endpoint = safeOrigin(origin, allowHttpLoopback);
+  if (
+    !endpoint ||
+    !isRecord(identity) ||
+    typeof observe !== "function" ||
+    typeof authorize !== "function" ||
+    typeof fetchImpl !== "function" ||
+    typeof now !== "function" ||
+    (sequencePath !== null &&
+      (typeof sequencePath !== "string" || !sequencePath))
+  ) {
+    rejectIdentity();
+  }
+  // Validate the workload binding before any timer or network side effect.
+  const cadenceMs = modelHealthCadenceMs(identity.workloadKeyHash);
+  buildModelHealthReport({
+    ...identity,
+    sequence: 1,
+    observedAt: now().toISOString(),
+    snapshot: observe(),
+  });
+  let sequence = loadSequence(sequencePath, identity);
+  let inFlight = null;
+  let timer = null;
+  let stopped = false;
+
+  const emit = (_transition = "periodic") => {
+    if (stopped)
+      return Promise.reject(new Error("model_health_reporter_stopped"));
+    if (inFlight) return inFlight;
+    const nextSequence = sequence + 1;
+    const snapshot = observe();
+    const body = buildModelHealthReport({
+      ...identity,
+      sequence: nextSequence,
+      observedAt: now().toISOString(),
+      snapshot,
+    });
+    persistSequence(sequencePath, identity, nextSequence);
+    sequence = nextSequence;
+    const authorization = authorize(body);
+    if (
+      typeof authorization !== "string" ||
+      !authorization.startsWith("Worker ")
+    ) {
+      return Promise.reject(new Error("model_health_report_unsigned"));
+    }
+    inFlight = (async () => {
+      const response = await fetchImpl(
+        `${endpoint}/api/v3/sellable-agent/worker/model-health`,
+        {
+          method: "POST",
+          headers: { authorization, "content-type": "application/json" },
+          body: JSON.stringify(body),
+          signal: AbortSignal.timeout(20_000),
+        }
+      );
+      let result;
+      try {
+        result = await response.json();
+      } catch {
+        throw new Error("model_health_report_response_rejected");
+      }
+      if (!response.ok || result?.accepted !== true) {
+        throw new Error("model_health_report_rejected");
+      }
+      return Object.freeze({ accepted: true, sequence });
+    })().finally(() => {
+      inFlight = null;
+    });
+    return inFlight;
+  };
+
+  return Object.freeze({
+    cadenceMs,
+    emit,
+    async start(transition = "materialized") {
+      try {
+        return await emit(transition);
+      } finally {
+        if (!timer && !stopped) {
+          timer = setIntervalImpl(() => {
+            emit("periodic").catch(onError);
+          }, cadenceMs);
+          timer?.unref?.();
+        }
+      }
+    },
+    async stop() {
+      stopped = true;
+      if (timer) clearIntervalImpl(timer);
+      timer = null;
+      await inFlight;
+    },
+  });
+}

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

@@ -197,7 +197,7 @@ function validateDesired(desired) {
     desired.serviceCredentialGeneration < 1 ||
     desired.hermesCli !== "hermes" ||
     desired.hermesVersion !== "0.18.0" ||
-    desired.installerPackage !== "@sellable/install@0.1.483" ||
+    desired.installerPackage !== "@sellable/install@0.1.486-wip.phase169.20260804.2" ||
     desired.mcpPackage !==
       "@sellable/mcp@0.1.760-wip.phase143.20260727100513" ||
     !Array.isArray(desired.toolInclude) ||
@@ -2023,6 +2023,9 @@ const NATIVE_SLACK_KEYS = [
   "membershipGeneration",
   "serviceCredentialGeneration",
   "modelCredentialGeneration",
+  "modelActivationId",
+  "modelBundleGeneration",
+  "modelPolicyHash",
   "runtimeGeneration",
   "selectedChannelIds",
   "defaultChannelId",
@@ -2062,8 +2065,12 @@ function validateNativeSlackDesired(desired) {
       "membershipGeneration",
       "serviceCredentialGeneration",
       "modelCredentialGeneration",
+      "modelBundleGeneration",
       "runtimeGeneration",
     ].some((key) => !Number.isSafeInteger(desired[key]) || desired[key] < 1) ||
+    desired.modelCredentialGeneration !== desired.modelBundleGeneration ||
+    !SAFE_ID.test(desired.modelActivationId ?? "") ||
+    !SHA256.test(desired.modelPolicyHash ?? "") ||
     !Array.isArray(desired.selectedChannelIds) ||
     desired.selectedChannelIds.length < 1 ||
     desired.selectedChannelIds.some(
@@ -2117,6 +2124,9 @@ function nativeSlackCustomerFiles(desired) {
     membershipGeneration: desired.membershipGeneration,
     serviceCredentialGeneration: desired.serviceCredentialGeneration,
     modelCredentialGeneration: desired.modelCredentialGeneration,
+    modelActivationId: desired.modelActivationId,
+    modelBundleGeneration: desired.modelBundleGeneration,
+    modelPolicyHash: desired.modelPolicyHash,
     runtimeGeneration: desired.runtimeGeneration,
     selectedChannelIds: [...desired.selectedChannelIds],
     memberAllowlist: [...desired.memberAllowlist],
@@ -2140,7 +2150,9 @@ function nativeSlackCustomerFiles(desired) {
       provider: FLY_CUSTOMER_MODEL_PROVIDER,
       default: FLY_CUSTOMER_MODEL_ID,
       reasoning_effort: FLY_CUSTOMER_MODEL_REASONING_EFFORT,
-      generation: desired.modelCredentialGeneration,
+      generation: desired.modelBundleGeneration,
+      activation_id: desired.modelActivationId,
+      policy_hash: desired.modelPolicyHash,
     },
     slack: {
       require_mention: true,
@@ -2237,6 +2249,9 @@ function nativeSlackManifest(desired, files) {
     membershipGeneration: desired.membershipGeneration,
     serviceCredentialGeneration: desired.serviceCredentialGeneration,
     modelCredentialGeneration: desired.modelCredentialGeneration,
+    modelActivationId: desired.modelActivationId,
+    modelBundleGeneration: desired.modelBundleGeneration,
+    modelPolicyHash: desired.modelPolicyHash,
     runtimeGeneration: desired.runtimeGeneration,
     installerPackage: desired.installerPackage,
     mcpPackage: desired.mcpPackage,

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.483";
+export const PINNED_INSTALL_PACKAGE = "@sellable/install@0.1.486-wip.phase169.20260804.2";
 export const PINNED_MCP_PACKAGE =
   "@sellable/mcp@0.1.760-wip.phase143.20260727100513";
 
@@ -612,7 +612,7 @@ function inspectProvisionedProfile({
       !matchesReadback(manifest, request) ||
       manifest.serviceCredentialReference !== serviceCredentialReference ||
       manifest.installerPackage !== PINNED_INSTALL_PACKAGE ||
-      manifest.installerVersion !== "0.1.483" ||
+      manifest.installerVersion !== "0.1.486-wip.phase169.20260804.2" ||
       manifest.mcpPackage !== PINNED_MCP_PACKAGE ||
       manifest.credentialKeyVersion !== credentialKeyVersion ||
       !/^[a-f0-9]{16}$/.test(manifest.credentialFingerprint) ||
@@ -826,7 +826,7 @@ function successReceipt({
     subject: `agent-profile:${observed.profileId}`,
     cli: {
       installPackage: PINNED_INSTALL_PACKAGE,
-      installVersion: "0.1.483",
+      installVersion: "0.1.486-wip.phase169.20260804.2",
       mcpPackage: PINNED_MCP_PACKAGE,
       command: "hermes profile bootstrap",
     },
@@ -874,7 +874,7 @@ function failure(code, stages, extra = {}, request = null) {
       : "agent-profile:unbound",
     cli: {
       installPackage: PINNED_INSTALL_PACKAGE,
-      installVersion: "0.1.483",
+      installVersion: "0.1.486-wip.phase169.20260804.2",
       mcpPackage: PINNED_MCP_PACKAGE,
       command: "hermes profile bootstrap",
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sellable/install",
-  "version": "0.1.483",
+  "version": "0.1.486-wip.phase169.20260804.2",
   "type": "module",
   "description": "One-command installer for Sellable MCP in Claude Code, Codex, and Hermes",
   "bin": {