@pome-sh/cli 0.43.1 → 0.45.0

package/dist/twinTape-5P3HQ27N.js

@@ -0,0 +1,418 @@
+import { STANDALONE_STATUS_PATH, standaloneStatusEntries, readStandaloneStatusFile, readStandaloneInitialState, standaloneInitialStatePath } from './chunk-AGZOWSLG.js';
+import './chunk-4LQ4IJOC.js';
+import './chunk-M7ATJ423.js';
+import { TWIN_NAMES } from './chunk-BXYPNEJY.js';
+import './chunk-NBOQN5VX.js';
+import './chunk-YBWG5JK2.js';
+import { recorderEventSchema } from './chunk-7VZBAHQ2.js';
+import './chunk-SG6ZTIMT.js';
+import './chunk-2K6BJ3PI.js';
+import './chunk-FBSA5L36.js';
+
+// src/twin/stateDiff.ts
+var IDENTITY_KEYS = ["full_name", "number", "name", "login", "email", "path", "ts", "key", "id"];
+function isRow(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isPrimitive(value) {
+  return value === null || ["string", "number", "boolean"].includes(typeof value);
+}
+function isCollection(value) {
+  return Array.isArray(value) && value.length > 0 && value.every(isRow);
+}
+function isMembership(value) {
+  return Array.isArray(value) && value.length > 0 && value.every(isPrimitive);
+}
+function identityKeyOf(...sides) {
+  const rows = sides.flat();
+  if (rows.length === 0) return void 0;
+  for (const key of IDENTITY_KEYS) {
+    if (!rows.every((row) => row[key] !== void 0 && row[key] !== null)) continue;
+    const unique = sides.every((side) => {
+      const values = side.map((row) => String(row[key]));
+      return new Set(values).size === values.length;
+    });
+    if (unique) return key;
+  }
+  return void 0;
+}
+function label(row, key, _index) {
+  const value = String(row[key]);
+  if (key === "number") return `#${value}`;
+  return value;
+}
+function scalarsOf(row) {
+  const out = {};
+  for (const [key, value] of Object.entries(row)) {
+    if (Array.isArray(value) && (value.length === 0 || isCollection(value) || isMembership(value))) continue;
+    out[key] = value;
+  }
+  return out;
+}
+function contentLabel(row) {
+  const parts = Object.entries(scalarsOf(row)).slice(0, 3).map(([key, value]) => `${key}=${typeof value === "string" ? value : JSON.stringify(value)}`);
+  const text = `{${parts.join(", ")}}`;
+  return text.length > 60 ? `${text.slice(0, 59)}\u2026` : text;
+}
+function stableStringify(value) {
+  if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
+  if (isRow(value)) {
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`).join(",")}}`;
+  }
+  return JSON.stringify(value) ?? "undefined";
+}
+function sameScalars(a, b) {
+  return stableStringify(scalarsOf(a)) === stableStringify(scalarsOf(b));
+}
+function diffState(before, after) {
+  const out = [];
+  walk(before, after, "", out);
+  return out;
+}
+function walk(before, after, path, out) {
+  if (Array.isArray(before) || Array.isArray(after)) {
+    const b = Array.isArray(before) ? before : [];
+    const a = Array.isArray(after) ? after : [];
+    if (isMembership(b) || isMembership(a)) {
+      if ((b.length === 0 || isMembership(b)) && (a.length === 0 || isMembership(a))) {
+        diffMembership(b, a, path, out);
+      }
+      return;
+    }
+    if ((b.length === 0 || isCollection(b)) && (a.length === 0 || isCollection(a))) {
+      diffCollection(b, a, path, out);
+    }
+    return;
+  }
+  if (isRow(before) && isRow(after)) {
+    const keys = /* @__PURE__ */ new Set([...Object.keys(before), ...Object.keys(after)]);
+    for (const key of [...keys].sort()) {
+      walk(before[key], after[key], path === "" ? key : `${path}.${key}`, out);
+    }
+  }
+}
+function diffMembership(before, after, path, out) {
+  const count = (values) => {
+    const map = /* @__PURE__ */ new Map();
+    for (const value of values) map.set(String(value), (map.get(String(value)) ?? 0) + 1);
+    return map;
+  };
+  const b = count(before);
+  const a = count(after);
+  const entry = { path: path || "(root)", added: [], changed: [], removed: [] };
+  for (const [value, n] of a) for (let i = b.get(value) ?? 0; i < n; i += 1) entry.added.push(value);
+  for (const [value, n] of b) for (let i = a.get(value) ?? 0; i < n; i += 1) entry.removed.push(value);
+  if (entry.added.length || entry.removed.length) out.push(entry);
+}
+function diffCollection(before, after, path, out) {
+  const key = identityKeyOf(before, after);
+  const entry = { path: path || "(root)", added: [], changed: [], removed: [] };
+  const byId = (rows) => {
+    const seen = /* @__PURE__ */ new Map();
+    return new Map(
+      rows.map((row, index) => {
+        let id = key === void 0 ? stableStringify(scalarsOf(row)) : String(row[key]);
+        if (key === void 0) {
+          const n = seen.get(id) ?? 0;
+          seen.set(id, n + 1);
+          if (n > 0) id = `${id}#${n}`;
+        }
+        return [id, { row, index }];
+      })
+    );
+  };
+  const name = (row, index) => key === void 0 ? contentLabel(row) : label(row, key);
+  const beforeById = byId(before);
+  const afterById = byId(after);
+  const nested = [];
+  for (const [id, { row, index }] of afterById) {
+    const prior = beforeById.get(id);
+    if (prior === void 0) {
+      entry.added.push(name(row));
+    } else {
+      const rowName = name(row);
+      if (!sameScalars(prior.row, row)) entry.changed.push(rowName);
+      nested.push({ before: prior.row, after: row, label: rowName });
+    }
+  }
+  for (const [id, { row, index }] of beforeById) {
+    if (!afterById.has(id)) entry.removed.push(name(row));
+  }
+  if (entry.added.length || entry.changed.length || entry.removed.length) out.push(entry);
+  for (const pair of nested) {
+    const keys = /* @__PURE__ */ new Set([...Object.keys(pair.before), ...Object.keys(pair.after)]);
+    for (const field of [...keys].sort()) {
+      const b = pair.before[field];
+      const a = pair.after[field];
+      if (Array.isArray(b) || Array.isArray(a) || isRow(b) && isRow(a)) {
+        walk(b, a, `${path}[${pair.label}].${field}`, out);
+      }
+    }
+  }
+}
+function renderStateDiff(entries) {
+  if (entries.length === 0) return ["State: unchanged since boot."];
+  const lines = ["State diff since boot (seed \u2192 now):"];
+  const width = Math.max(...entries.map((entry) => entry.path.length));
+  for (const entry of entries) {
+    const parts = [];
+    if (entry.added.length) parts.push(`+${entry.added.length} added: ${entry.added.join(", ")}`);
+    if (entry.changed.length) parts.push(`~${entry.changed.length} changed: ${entry.changed.join(", ")}`);
+    if (entry.removed.length) parts.push(`-${entry.removed.length} removed: ${entry.removed.join(", ")}`);
+    lines.push(`  ${entry.path.padEnd(width)}  ${parts.join("; ")}`);
+  }
+  return lines;
+}
+
+// src/twin/twinTape.ts
+var READ_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD", "OPTIONS"]);
+var WRITE_VERBS = /* @__PURE__ */ new Set([
+  "create",
+  "update",
+  "delete",
+  "remove",
+  "add",
+  "set",
+  "post",
+  "send",
+  "merge",
+  "close",
+  "reopen",
+  "assign",
+  "unassign",
+  "apply",
+  "archive",
+  "unarchive",
+  "cancel",
+  "push",
+  "fork",
+  "star",
+  "unstar",
+  "label",
+  "unlabel",
+  "comment",
+  "reply",
+  "edit",
+  "move",
+  "rename",
+  "invite",
+  "kick",
+  "join",
+  "leave",
+  "pin",
+  "unpin",
+  "react",
+  "upload",
+  "trash",
+  "untrash",
+  "modify",
+  "insert",
+  "import",
+  "batch",
+  "submit",
+  "request",
+  "dismiss",
+  "approve",
+  "reject",
+  "resolve",
+  "transfer",
+  "attach",
+  "detach",
+  "refund",
+  "capture",
+  "confirm",
+  "void",
+  "finalize",
+  "pay"
+]);
+function isMcpTransport(path) {
+  return path === "/mcp" || path.startsWith("/mcp/");
+}
+function requestKind(method, path, tool) {
+  if (tool && isMcpTransport(path)) {
+    return tool.toLowerCase().split(/[_\-.]/).some((part) => WRITE_VERBS.has(part)) ? "write" : "read";
+  }
+  return READ_METHODS.has(method) ? "read" : "write";
+}
+function tapeRows(events, sessionPath) {
+  if (!Array.isArray(events)) {
+    throw new Error("pome twin tape: the twin answered /_pome/events with something other than a list.");
+  }
+  return events.map((raw, index) => {
+    const parsed = recorderEventSchema.safeParse(raw);
+    if (!parsed.success) {
+      throw new Error(
+        `pome twin tape: event ${index + 1} on the tape is not a recorded event \u2014 ${parsed.error.issues[0]?.message ?? "unrecognized shape"}.`
+      );
+    }
+    const event = parsed.data;
+    const method = event.method.toUpperCase();
+    const path = event.path.startsWith(sessionPath) ? event.path.slice(sessionPath.length) || "/" : event.path;
+    const kind = requestKind(method, path, event.tool ?? null);
+    let note = null;
+    if (event.fidelity === "unsupported" || event.status === 501) {
+      note = "not modelled by this twin";
+    } else if (event.idempotency_dedupe) {
+      note = "replayed from the idempotency cache";
+    } else if (kind === "write" && !event.state_mutation) {
+      note = event.status >= 400 ? `write did not land (${event.status})` : "write landed nothing";
+    }
+    if (event.error) note = note ? `${note}; error: ${event.error}` : `error: ${event.error}`;
+    return {
+      ts: event.ts,
+      method,
+      path,
+      tool: event.tool ?? null,
+      status: event.status,
+      fidelity: event.fidelity,
+      state_mutation: event.state_mutation,
+      error: event.error,
+      kind,
+      note
+    };
+  });
+}
+function tapeSummary(rows) {
+  return {
+    requests: rows.length,
+    changed_state: rows.filter((row) => row.state_mutation).length,
+    writes_not_landed: rows.filter((row) => row.note?.startsWith("write ")).length,
+    unsupported: rows.filter((row) => row.note?.startsWith("not modelled")).length,
+    reads: rows.filter((row) => row.kind === "read" && !row.note).length
+  };
+}
+function requestLabel(row) {
+  if (row.tool && isMcpTransport(row.path)) return row.tool;
+  if (row.tool) return `${row.method} ${row.path} (${row.tool})`;
+  return `${row.method} ${row.path}`;
+}
+function stateLabel(row) {
+  if (row.state_mutation) return "changed";
+  return row.kind === "read" ? "read" : "no change";
+}
+function renderTape(rows, where) {
+  const lines = [`${where.twin} twin at ${where.url} \u2014 ${rows.length} request${rows.length === 1 ? "" : "s"}`];
+  if (rows.length === 0) {
+    lines.push("(nothing recorded yet \u2014 connect an agent and ask it for something)");
+    return lines;
+  }
+  const cells = rows.map((row) => ({
+    time: row.ts.length >= 23 ? row.ts.slice(11, 23) : row.ts,
+    request: requestLabel(row),
+    status: String(row.status),
+    fidelity: row.fidelity,
+    state: stateLabel(row),
+    note: row.note
+  }));
+  const width = (pick, min) => Math.max(min, ...cells.map((cell) => pick(cell).length));
+  const w = {
+    time: width((c) => c.time, 4),
+    request: width((c) => c.request, 7),
+    status: width((c) => c.status, 6),
+    fidelity: width((c) => c.fidelity, 8),
+    state: width((c) => c.state, 5)
+  };
+  lines.push("");
+  lines.push(
+    [
+      "TIME".padEnd(w.time),
+      "REQUEST".padEnd(w.request),
+      "STATUS".padEnd(w.status),
+      "FIDELITY".padEnd(w.fidelity),
+      "STATE".padEnd(w.state)
+    ].join("  ").trimEnd()
+  );
+  for (const cell of cells) {
+    const line = [
+      cell.time.padEnd(w.time),
+      cell.request.padEnd(w.request),
+      cell.status.padEnd(w.status),
+      cell.fidelity.padEnd(w.fidelity),
+      cell.state.padEnd(w.state)
+    ].join("  ");
+    lines.push(cell.note ? `${line}  \u2190 ${cell.note}` : line.trimEnd());
+  }
+  const summary = tapeSummary(rows);
+  const parts = [`${summary.changed_state} changed state`];
+  if (summary.writes_not_landed) {
+    parts.push(`${summary.writes_not_landed} write${summary.writes_not_landed === 1 ? "" : "s"} did not land`);
+  }
+  if (summary.unsupported) parts.push(`${summary.unsupported} unsupported`);
+  parts.push(`${summary.reads} read${summary.reads === 1 ? "" : "s"}`);
+  lines.push("");
+  lines.push(`${summary.requests} request${summary.requests === 1 ? "" : "s"}: ${parts.join(" \xB7 ")}`);
+  return lines;
+}
+function pickRecordedTwin(entries, name) {
+  if (entries.length === 0) {
+    throw new Error(
+      `No standalone twin status found. Start one with \`pome twin start <${TWIN_NAMES.join("|")}>\`.`
+    );
+  }
+  if (name === void 0) {
+    if (entries.length === 1) return entries[0];
+    throw new Error(
+      `pome twin tape: ${entries.length} twins are recorded in ${STANDALONE_STATUS_PATH} (${entries.map((entry) => entry.name).join(", ")}) \u2014 name one: pome twin tape ${entries[0].name}`
+    );
+  }
+  const found = entries.find((entry) => entry.name === name);
+  if (found) return found;
+  throw new Error(
+    `pome twin tape: no ${name} twin is recorded in ${STANDALONE_STATUS_PATH} (recorded: ${entries.map((entry) => entry.name).join(", ")}). Start it with \`pome twin start ${name}\`.`
+  );
+}
+async function fetchTwin(entry, leaf) {
+  const url = `${entry.rest_url}/_pome/${leaf}`;
+  let res;
+  try {
+    res = await fetch(url, {
+      headers: { Authorization: `Bearer ${entry.auth_token}` },
+      signal: AbortSignal.timeout(5e3)
+    });
+  } catch {
+    throw new Error(
+      `pome twin tape: the ${entry.name} twin is not answering at ${entry.rest_url} \u2014 start it with \`pome twin start ${entry.name}\`.`
+    );
+  }
+  if (res.status === 401) {
+    throw new Error(
+      `pome twin tape: the ${entry.name} twin refused the token in ${STANDALONE_STATUS_PATH} (it may be from an earlier start) \u2014 restart it with \`pome twin start ${entry.name}\`.`
+    );
+  }
+  if (!res.ok) {
+    throw new Error(`pome twin tape: ${url} answered ${res.status}.`);
+  }
+  return await res.json();
+}
+async function runTwinTapeCommand(nameArg, options) {
+  const entry = pickRecordedTwin(standaloneStatusEntries(await readStandaloneStatusFile()), nameArg);
+  const rows = tapeRows(await fetchTwin(entry, "events"), new URL(entry.rest_url).pathname);
+  let diff;
+  if (options.diff) {
+    const initial = await readStandaloneInitialState(entry.name);
+    if (initial === void 0) {
+      throw new Error(
+        `pome twin tape --diff: no boot snapshot at ${standaloneInitialStatePath(entry.name)} \u2014 the ${entry.name} twin was started by an older pome. Restart it with \`pome twin start ${entry.name}\`.`
+      );
+    }
+    diff = diffState(initial, await fetchTwin(entry, "state"));
+  }
+  if (options.json) {
+    const envelope = {
+      twin: entry.name,
+      url: entry.rest_url,
+      requests: rows,
+      summary: tapeSummary(rows),
+      ...diff !== void 0 ? { diff } : {}
+    };
+    console.log(JSON.stringify(envelope, null, 2));
+    return;
+  }
+  for (const line of renderTape(rows, { twin: entry.name, url: entry.rest_url })) console.log(line);
+  if (diff !== void 0) {
+    console.log("");
+    for (const line of renderStateDiff(diff)) console.log(line);
+  }
+}
+
+export { pickRecordedTwin, renderTape, requestKind, requestLabel, runTwinTapeCommand, tapeRows, tapeSummary };

package/examples/agents/mcp-loop-agent.ts

@@ -24,7 +24,6 @@ import {
 import {
   preflightModel,
   preflightModelMessage,
-  resolveLlmHost,
   resolveModel,
 } from "../../src/scaffolds/mcp-loop/providers.js";
 
@@ -56,11 +55,6 @@ async function main() {
     mcp,
     task: contract.task,
     system,
-    signalsPath: contract.signalsPath,
-    // The verbatim slug is the LlmCallEvent.model label + the Tier-2 pricing
-    // key; host is the synthetic source for the emitted LLM-usage rows.
-    modelId: contract.model,
-    host: resolveLlmHost(contract.model, process.env),
   });
 
   console.log(

package/package.json

@@ -1,18 +1,24 @@
 {
   "name": "@pome-sh/cli",
-  "version": "0.43.1",
-  "description": "Test AI agents against digital twins of real SaaS APIs. Records tool-call traces and scores them on pome.sh.",
+  "version": "0.45.0",
+  "description": "Test mode for your integrations, built for the way agents build. Local, stateful twins of GitHub, Slack, Stripe, Gmail and Linear, over REST and MCP.",
   "keywords": [
-    "ai",
-    "agents",
-    "agent-testing",
+    "mcp",
+    "mcp-server",
+    "model-context-protocol",
+    "claude-code",
+    "codex",
+    "testing",
+    "test-mode",
+    "sandbox",
+    "api-mocking",
     "digital-twin",
-    "llm",
-    "evals",
-    "claude",
-    "anthropic",
+    "ai-agents",
     "github",
+    "slack",
     "stripe",
+    "gmail",
+    "linear",
     "cli"
   ],
   "homepage": "https://pome.sh",
@@ -54,19 +60,19 @@
     "check:manifest-schema": "node scripts/emit-manifest-schema.mjs --check"
   },
   "dependencies": {
-    "@ai-sdk/anthropic": "^4.0.29",
-    "@ai-sdk/gateway": "^4.0.40",
-    "@ai-sdk/google": "^4.0.33",
-    "@ai-sdk/openai": "^4.0.29",
-    "@anthropic-ai/sdk": "^0.115.0",
-    "@hono/node-server": "^2.1.0",
+    "@ai-sdk/anthropic": "^4.0.54",
+    "@ai-sdk/gateway": "^4.0.82",
+    "@ai-sdk/google": "^4.0.72",
+    "@ai-sdk/openai": "^4.0.67",
+    "@anthropic-ai/sdk": "^0.126.0",
+    "@hono/node-server": "^2.1.1",
     "@openrouter/ai-sdk-provider": "^3.0.0",
-    "ai": "^7.0.51",
+    "ai": "^7.0.102",
     "commander": "^15.0.0",
-    "graphql": "^16.11.0",
-    "hono": "^4.13.0",
-    "yaml": "^2.9.0",
-    "zod": "^4.4.3"
+    "graphql": "^16.14.2",
+    "hono": "^4.13.8",
+    "yaml": "^2.9.1",
+    "zod": "^4.6.5"
   },
   "devDependencies": {
     "@pome-sh/sdk": "*",
@@ -76,11 +82,11 @@
     "@pome-sh/twin-linear": "*",
     "@pome-sh/twin-slack": "*",
     "@pome-sh/twin-stripe": "*",
-    "@types/node": "^26.1.2",
-    "tsx": "^4.23.5",
+    "@types/node": "^26.6.1",
+    "tsx": "^4.23.13",
     "typescript": "^5.9.3",
-    "vitest": "^4.1.10",
-    "tsup": "^8.5.0"
+    "vitest": "^5.0.1",
+    "tsup": "^8.5.1"
   },
   "engines": {
     "node": ">=24"

package/dist/twinHarness-33MAVAXV.js

@@ -1,6 +0,0 @@
-export { UnsupportedTwinError, bootTwin } from './chunk-64AWQJ7R.js';
-export { STRIPE_LOCAL_ACCOUNT_ID } from './chunk-4DXTT3RV.js';
-import './chunk-TWURH7YM.js';
-import './chunk-5KFDRR53.js';
-import './chunk-SG6ZTIMT.js';
-import './chunk-FBSA5L36.js';