@sellable/install 0.1.358 → 0.1.359-phase111.20260720052618

package/lib/sellable-agent/hermes-bridge.mjs

@@ -1,497 +0,0 @@
-import { createHash } from "node:crypto";
-import {
-  closeSync,
-  constants,
-  existsSync,
-  fchmodSync,
-  fchownSync,
-  fsyncSync,
-  lstatSync,
-  openSync,
-  readFileSync,
-  realpathSync,
-  renameSync,
-  unlinkSync,
-  writeFileSync,
-} from "node:fs";
-import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
-
-export const HERMES_AGENT_BRIDGE_ID = "sellable-agent-hermes-bridge/v1";
-export const HERMES_AGENT_BRIDGE_MARKER = "SELLABLE_AGENT_HERMES_BRIDGE_V1";
-
-const sha256 = (value) => createHash("sha256").update(value).digest("hex");
-const isSha256 = (value) => typeof value === "string" && /^[a-f0-9]{64}$/.test(value);
-
-export class HermesAgentBridgeError extends Error {
-  constructor(code, message, details = {}) {
-    super(message);
-    this.name = "HermesAgentBridgeError";
-    this.code = code;
-    this.details = details;
-  }
-}
-
-function replaceExactlyOnce(source, needle, replacement, label) {
-  const first = source.indexOf(needle);
-  const last = source.lastIndexOf(needle);
-  if (first < 0 || first !== last) {
-    throw new HermesAgentBridgeError(
-      "HERMES_BRIDGE_PATCH_ANCHOR_MISMATCH",
-      `Expected exactly one ${label} patch anchor`,
-      { label },
-    );
-  }
-  return `${source.slice(0, first)}${replacement}${source.slice(first + needle.length)}`;
-}
-
-const SECRET_FD_HELPER = `
-# ${HERMES_AGENT_BRIDGE_MARKER}: inherited Slack secret reader.
-_SELLABLE_AGENT_SECRET_CACHE = {}
-
-def _sellable_agent_read_slack_secret(fd: int, env_name: str, prefix: str):
-    if os.getenv("SELLABLE_AGENT_RUNTIME", "") != "1":
-        return os.getenv(env_name)
-    if env_name in os.environ:
-        raise RuntimeError(f"{env_name} must not be present in the Sellable runtime environment")
-    cache_key = (fd, env_name, prefix)
-    if cache_key in _SELLABLE_AGENT_SECRET_CACHE:
-        return _SELLABLE_AGENT_SECRET_CACHE[cache_key]
-    try:
-        duplicate = os.dup(fd)
-    except OSError as exc:
-        raise RuntimeError(f"required inherited descriptor {fd} is unavailable") from exc
-    try:
-        chunks = []
-        size = 0
-        while True:
-            chunk = os.read(duplicate, min(1024, 4097 - size))
-            if not chunk:
-                break
-            chunks.append(chunk)
-            size += len(chunk)
-            if size > 4096:
-                raise RuntimeError(f"secret on descriptor {fd} exceeds the size limit")
-    finally:
-        os.close(duplicate)
-    try:
-        value = b"".join(chunks).decode("utf-8").strip()
-    except UnicodeDecodeError as exc:
-        raise RuntimeError(f"secret on descriptor {fd} is not valid UTF-8") from exc
-    if not value or "\\x00" in value or "\\n" in value or "\\r" in value:
-        raise RuntimeError(f"secret on descriptor {fd} is malformed")
-    if not value.startswith(prefix):
-        raise RuntimeError(f"secret on descriptor {fd} has the wrong credential class")
-    _SELLABLE_AGENT_SECRET_CACHE[cache_key] = value
-    return value
-`;
-
-const MCP_META_HELPER = `
-# ${HERMES_AGENT_BRIDGE_MARKER}: request-scoped Sellable MCP metadata.
-def _sellable_agent_call_meta():
-    if os.getenv("SELLABLE_AGENT_RUNTIME", "") != "1":
-        return None
-    import json
-    gate_path = os.getenv("SELLABLE_AGENT_RUNTIME_GATE_FILE", "")
-    if not gate_path.startswith("/"):
-        raise RuntimeError("Sellable runtime gate path is not pinned")
-    try:
-        with open(gate_path, "r", encoding="utf-8") as gate_file:
-            gates = json.load(gate_file)
-    except (OSError, ValueError) as exc:
-        raise RuntimeError("Sellable runtime gates are unavailable") from exc
-    if gates != {"lifecycle": "ON", "dispatch": "ENABLED", "route": "OPEN", "output": "OPEN"}:
-        raise RuntimeError("Sellable runtime dispatch is fenced")
-    from gateway.session_context import get_session_env, session_context_engaged
-    if not session_context_engaged():
-        raise RuntimeError("Sellable MCP calls require an active Hermes session context")
-    legacy_names = (
-        "HERMES_SESSION_PLATFORM",
-        "HERMES_SESSION_CHAT_ID",
-        "HERMES_SESSION_USER_ID",
-        "HERMES_SESSION_MESSAGE_ID",
-    )
-    if any(os.getenv(name) for name in legacy_names):
-        raise RuntimeError("Sellable MCP identity must not come from process-global session variables")
-    platform = get_session_env("HERMES_SESSION_PLATFORM", "").strip().lower()
-    channel_id = get_session_env("HERMES_SESSION_CHAT_ID", "").strip()
-    requester_id = get_session_env("HERMES_SESSION_USER_ID", "").strip()
-    message_id = get_session_env("HERMES_SESSION_MESSAGE_ID", "").strip()
-    if platform != "slack" or not channel_id or not requester_id or not message_id:
-        raise RuntimeError("Sellable MCP calls require a bound Slack requester, channel, and message")
-    return {
-        "sellableAgent": {
-            "requesterId": requester_id,
-            "channelId": channel_id,
-            "providerRequestId": message_id,
-        }
-    }
-`;
-
-export function patchHermesSourceFile(patchKind, source) {
-  if (typeof source !== "string") {
-    throw new HermesAgentBridgeError("HERMES_BRIDGE_INVALID_SOURCE", "Hermes source must be UTF-8 text");
-  }
-  if (source.includes(HERMES_AGENT_BRIDGE_MARKER)) {
-    throw new HermesAgentBridgeError(
-      "HERMES_BRIDGE_ALREADY_PATCHED_SOURCE",
-      "Refusing to transform source that already contains the bridge marker",
-      { patchKind },
-    );
-  }
-
-  if (patchKind === "gateway-config") {
-    let patched = replaceExactlyOnce(
-      source,
-      "logger = logging.getLogger(__name__)\n",
-      `logger = logging.getLogger(__name__)\n${SECRET_FD_HELPER}`,
-      "gateway helper",
-    );
-    patched = replaceExactlyOnce(
-      patched,
-      '    slack_token = os.getenv("SLACK_BOT_TOKEN")',
-      '    slack_token = _sellable_agent_read_slack_secret(9, "SLACK_BOT_TOKEN", "xoxb-")',
-      "Slack bot token",
-    );
-    return patched;
-  }
-
-  if (patchKind === "slack-adapter") {
-    let patched = replaceExactlyOnce(
-      source,
-      "logger = logging.getLogger(__name__)\n",
-      `logger = logging.getLogger(__name__)\n${SECRET_FD_HELPER}`,
-      "Slack adapter helper",
-    );
-    patched = replaceExactlyOnce(
-      patched,
-      '        app_token = os.getenv("SLACK_APP_TOKEN")',
-      '        app_token = _sellable_agent_read_slack_secret(8, "SLACK_APP_TOKEN", "xapp-")',
-      "Slack app token",
-    );
-    patched = replaceExactlyOnce(
-      patched,
-      "        tokens_file = get_hermes_home() / \"slack_tokens.json\"\n        if tokens_file.exists():",
-      "        tokens_file = get_hermes_home() / \"slack_tokens.json\"\n        if tokens_file.exists() and os.getenv(\"SELLABLE_AGENT_RUNTIME\", \"\") != \"1\":",
-      "legacy Slack token file",
-    );
-    return patched;
-  }
-
-  if (patchKind === "mcp-tool") {
-    let patched = replaceExactlyOnce(
-      source,
-      "logger = logging.getLogger(__name__)\n",
-      `logger = logging.getLogger(__name__)\n${MCP_META_HELPER}`,
-      "MCP metadata helper",
-    );
-    patched = replaceExactlyOnce(
-      patched,
-      "                    result = await server.session.call_tool(tool_name, arguments=args)",
-      [
-        "                    sellable_meta = _sellable_agent_call_meta()",
-        "                    call_kwargs = {\"arguments\": args}",
-        "                    if sellable_meta is not None:",
-        "                        call_kwargs[\"meta\"] = sellable_meta",
-        "                    result = await server.session.call_tool(tool_name, **call_kwargs)",
-      ].join("\n"),
-      "MCP call metadata",
-    );
-    return patched;
-  }
-
-  throw new HermesAgentBridgeError(
-    "HERMES_BRIDGE_UNKNOWN_PATCH_KIND",
-    `Unknown Hermes bridge patch kind: ${patchKind}`,
-    { patchKind },
-  );
-}
-
-function normalizeContract(input) {
-  if (!input || typeof input !== "object") {
-    throw new HermesAgentBridgeError("HERMES_BRIDGE_INVALID_CONTRACT", "Bridge contract is required");
-  }
-  const versionFile = input.versionFile;
-  if (
-    !input.hermesVersion ||
-    !versionFile ||
-    typeof versionFile.path !== "string" ||
-    !isSha256(versionFile.sha256) ||
-    !Array.isArray(input.files) ||
-    input.files.length === 0
-  ) {
-    throw new HermesAgentBridgeError("HERMES_BRIDGE_INVALID_CONTRACT", "Bridge contract is malformed");
-  }
-  const seen = new Set([versionFile.path]);
-  const files = input.files.map((file) => {
-    if (
-      !file ||
-      typeof file.path !== "string" ||
-      typeof file.patchKind !== "string" ||
-      !isSha256(file.sourceSha256) ||
-      !isSha256(file.patchedSha256) ||
-      seen.has(file.path)
-    ) {
-      throw new HermesAgentBridgeError("HERMES_BRIDGE_INVALID_CONTRACT", "Bridge file contract is malformed");
-    }
-    seen.add(file.path);
-    return Object.freeze({ ...file });
-  });
-  const normalized = {
-    bridgeId: HERMES_AGENT_BRIDGE_ID,
-    hermesVersion: String(input.hermesVersion),
-    versionFile: Object.freeze({ ...versionFile }),
-    files: Object.freeze(files),
-  };
-  return Object.freeze({
-    ...normalized,
-    contractDigest: sha256(JSON.stringify(normalized)),
-  });
-}
-
-export function createHermesBridgeContractFromSources({
-  hermesVersion,
-  versionFilePath = "hermes_cli/__init__.py",
-  versionFileSource,
-  files,
-}) {
-  if (typeof versionFileSource !== "string" || !Array.isArray(files)) {
-    throw new HermesAgentBridgeError("HERMES_BRIDGE_INVALID_CONTRACT", "Source-backed contract is malformed");
-  }
-  return normalizeContract({
-    hermesVersion,
-    versionFile: { path: versionFilePath, sha256: sha256(versionFileSource) },
-    files: files.map((file) => ({
-      path: file.path,
-      patchKind: file.patchKind,
-      sourceSha256: sha256(file.source),
-      patchedSha256: sha256(patchHermesSourceFile(file.patchKind, file.source)),
-    })),
-  });
-}
-
-export const HERMES_AGENT_BRIDGE_CONTRACT = normalizeContract({
-  hermesVersion: "0.18.0",
-  versionFile: {
-    path: "hermes_cli/__init__.py",
-    sha256: "58b0e216b05a3db1ec84e6eff8087a611261b78f0d3004c31cd83d93c257bbc3",
-  },
-  files: [
-    {
-      path: "gateway/config.py",
-      patchKind: "gateway-config",
-      sourceSha256: "a08cf991bc6614539389936573b0d179fbe8169db05037df496123308f651b50",
-      patchedSha256: "6c629d4a95597c97e115a9d92f85d6f4da6312be7e5ffec81a110d0651961586",
-    },
-    {
-      path: "plugins/platforms/slack/adapter.py",
-      patchKind: "slack-adapter",
-      sourceSha256: "20b12d9bbff0f5b280e0be8e795c7327f4089c3fa8b04d7a6d346dabae591f2a",
-      patchedSha256: "548ab70f515e22830cbcbf6b0691768272dd708fd0118f7c601e1e1232bb016b",
-    },
-    {
-      path: "tools/mcp_tool.py",
-      patchKind: "mcp-tool",
-      sourceSha256: "1bcceccaeb8ec8894c83819d389a64258517f4b48db1c8fea5c486633e56fe8b",
-      patchedSha256: "44bf5dfeca47bf91fc5e68ecd6455c33f41afd2b04fa16d213f59115ddb38f21",
-    },
-  ],
-});
-
-function assertRelativeContractPath(path) {
-  if (!path || isAbsolute(path) || path.split(/[\\/]+/).some((part) => part === ".." || part === "")) {
-    throw new HermesAgentBridgeError("HERMES_BRIDGE_UNSAFE_PATH", "Bridge contract path is unsafe", { path });
-  }
-}
-
-function resolveConfined(root, path) {
-  assertRelativeContractPath(path);
-  const candidate = resolve(root, path);
-  const rel = relative(root, candidate);
-  if (!rel || rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel)) {
-    throw new HermesAgentBridgeError("HERMES_BRIDGE_UNSAFE_PATH", "Bridge path escapes source root", { path });
-  }
-  return candidate;
-}
-
-function assertSafeRegularFile(root, path) {
-  const candidate = resolveConfined(root, path);
-  let cursor = root;
-  for (const component of relative(root, candidate).split(sep)) {
-    cursor = join(cursor, component);
-    const info = lstatSync(cursor);
-    if (info.isSymbolicLink()) {
-      throw new HermesAgentBridgeError("HERMES_BRIDGE_SYMLINK", "Hermes bridge paths may not contain symlinks", { path });
-    }
-    if (cursor !== candidate && (!info.isDirectory() || (info.mode & 0o022) !== 0)) {
-      throw new HermesAgentBridgeError(
-        "HERMES_BRIDGE_UNSAFE_DIRECTORY",
-        "Hermes bridge parent directories must be real and not group/world writable",
-        { path },
-      );
-    }
-  }
-  const info = lstatSync(candidate);
-  if (!info.isFile()) {
-    throw new HermesAgentBridgeError("HERMES_BRIDGE_NOT_REGULAR", "Hermes bridge target is not a regular file", { path });
-  }
-  if ((info.mode & 0o022) !== 0) {
-    throw new HermesAgentBridgeError("HERMES_BRIDGE_WRITABLE_SOURCE", "Hermes bridge target is group/world writable", { path });
-  }
-  return { candidate, info };
-}
-
-function validateSourceRoot(sourceRoot) {
-  if (typeof sourceRoot !== "string" || !isAbsolute(sourceRoot) || resolve(sourceRoot) !== sourceRoot) {
-    throw new HermesAgentBridgeError("HERMES_BRIDGE_UNSAFE_ROOT", "Hermes source root must be an absolute normalized path");
-  }
-  const rootInfo = lstatSync(sourceRoot);
-  if (!rootInfo.isDirectory() || rootInfo.isSymbolicLink() || realpathSync(sourceRoot) !== sourceRoot) {
-    throw new HermesAgentBridgeError("HERMES_BRIDGE_UNSAFE_ROOT", "Hermes source root must be a real directory");
-  }
-  if ((rootInfo.mode & 0o022) !== 0) {
-    throw new HermesAgentBridgeError("HERMES_BRIDGE_WRITABLE_ROOT", "Hermes source root is group/world writable");
-  }
-  return sourceRoot;
-}
-
-function readVersion(source) {
-  const match = source.match(/^__version__\s*=\s*["']([^"']+)["']/m);
-  return match?.[1] ?? null;
-}
-
-function publicFileReceipts(files) {
-  return files.map(({ path, sha256: digest }) => ({ path, sha256: digest }));
-}
-
-export function inspectHermesAgentBridge({ sourceRoot, contract = HERMES_AGENT_BRIDGE_CONTRACT }) {
-  const pinned = normalizeContract(contract);
-  const root = validateSourceRoot(sourceRoot);
-  const versionTarget = assertSafeRegularFile(root, pinned.versionFile.path);
-  const versionBytes = readFileSync(versionTarget.candidate);
-  const versionSource = versionBytes.toString("utf8");
-  const versionDigest = sha256(versionBytes);
-  const version = readVersion(versionSource);
-  const reasons = [];
-  if (versionDigest !== pinned.versionFile.sha256) reasons.push("VERSION_FILE_HASH_MISMATCH");
-  if (version !== pinned.hermesVersion) reasons.push("HERMES_VERSION_MISMATCH");
-
-  const files = pinned.files.map((file) => {
-    const target = assertSafeRegularFile(root, file.path);
-    const digest = sha256(readFileSync(target.candidate));
-    const state = digest === file.sourceSha256 ? "source" : digest === file.patchedSha256 ? "patched" : "unknown";
-    if (state === "unknown") reasons.push(`UNKNOWN_SOURCE:${file.path}`);
-    return { ...file, absolutePath: target.candidate, mode: target.info.mode & 0o777, sha256: digest, state };
-  });
-  const knownStates = new Set(files.map((file) => file.state));
-  if (knownStates.has("source") && knownStates.has("patched")) reasons.push("MIXED_BRIDGE_STATE");
-
-  let state = "blocked";
-  if (reasons.length === 0 && knownStates.size === 1 && knownStates.has("source")) state = "needs_install";
-  if (reasons.length === 0 && knownStates.size === 1 && knownStates.has("patched")) state = "installed";
-  return Object.freeze({
-    bridgeId: pinned.bridgeId,
-    contractDigest: pinned.contractDigest,
-    hermesVersion: version,
-    state,
-    reasons: Object.freeze(reasons),
-    files: Object.freeze(publicFileReceipts(files)),
-  });
-}
-
-function fsyncDirectory(path) {
-  const fd = openSync(path, constants.O_RDONLY);
-  try {
-    fsyncSync(fd);
-  } finally {
-    closeSync(fd);
-  }
-}
-
-function atomicReplace(candidate, bytes, { mode, uid, gid }) {
-  const temp = join(dirname(candidate), `.${candidate.split(sep).at(-1)}.sellable-agent-${process.pid}-${Date.now()}.tmp`);
-  let fd;
-  try {
-    fd = openSync(temp, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY | constants.O_NOFOLLOW, mode);
-    writeFileSync(fd, bytes);
-    fchmodSync(fd, mode);
-    fchownSync(fd, uid, gid);
-    fsyncSync(fd);
-    closeSync(fd);
-    fd = undefined;
-    renameSync(temp, candidate);
-    fsyncDirectory(dirname(candidate));
-  } finally {
-    if (fd !== undefined) closeSync(fd);
-    if (existsSync(temp)) unlinkSync(temp);
-  }
-}
-
-export function installHermesAgentBridge({ sourceRoot, contract = HERMES_AGENT_BRIDGE_CONTRACT }) {
-  const pinned = normalizeContract(contract);
-  const before = inspectHermesAgentBridge({ sourceRoot, contract: pinned });
-  if (before.state === "installed") return Object.freeze({ ...before, status: "already_current" });
-  if (before.state !== "needs_install") {
-    throw new HermesAgentBridgeError(
-      "HERMES_BRIDGE_SOURCE_REJECTED",
-      "Hermes source does not match the pinned bridge preimage",
-      { state: before.state, reasons: before.reasons },
-    );
-  }
-
-  const staged = pinned.files.map((file) => {
-    const { candidate, info } = assertSafeRegularFile(sourceRoot, file.path);
-    const original = readFileSync(candidate);
-    const patched = Buffer.from(patchHermesSourceFile(file.patchKind, original.toString("utf8")), "utf8");
-    const digest = sha256(patched);
-    if (digest !== file.patchedSha256) {
-      throw new HermesAgentBridgeError(
-        "HERMES_BRIDGE_PATCH_DIGEST_MISMATCH",
-        "Generated Hermes patch does not match the pinned postimage",
-        { path: file.path },
-      );
-    }
-    return { ...file, candidate, ownership: { mode: info.mode & 0o777, uid: info.uid, gid: info.gid }, original, patched };
-  });
-
-  const replaced = [];
-  try {
-    for (const file of staged) {
-      atomicReplace(file.candidate, file.patched, file.ownership);
-      replaced.push(file);
-    }
-  } catch (error) {
-    const rollbackErrors = [];
-    for (const file of replaced.reverse()) {
-      try {
-        atomicReplace(file.candidate, file.original, file.ownership);
-      } catch (rollbackError) {
-        rollbackErrors.push({ path: file.path, message: rollbackError instanceof Error ? rollbackError.message : String(rollbackError) });
-      }
-    }
-    throw new HermesAgentBridgeError(
-      rollbackErrors.length ? "HERMES_BRIDGE_ROLLBACK_FAILED" : "HERMES_BRIDGE_INSTALL_FAILED",
-      rollbackErrors.length ? "Hermes bridge install and rollback failed" : "Hermes bridge install failed and was rolled back",
-      { rollbackErrors, cause: error instanceof Error ? error.message : String(error) },
-    );
-  }
-
-  const after = inspectHermesAgentBridge({ sourceRoot, contract: pinned });
-  if (after.state !== "installed") {
-    throw new HermesAgentBridgeError("HERMES_BRIDGE_VERIFY_FAILED", "Hermes bridge post-install verification failed", {
-      state: after.state,
-      reasons: after.reasons,
-    });
-  }
-  return Object.freeze({ ...after, status: "installed" });
-}
-
-export function verifyHermesAgentBridge({ sourceRoot, contract = HERMES_AGENT_BRIDGE_CONTRACT }) {
-  const observation = inspectHermesAgentBridge({ sourceRoot, contract });
-  if (observation.state !== "installed") {
-    throw new HermesAgentBridgeError("HERMES_BRIDGE_NOT_INSTALLED", "Pinned Hermes bridge is not installed", {
-      state: observation.state,
-      reasons: observation.reasons,
-    });
-  }
-  return Object.freeze({ ...observation, status: "verified" });
-}