peachsim 0.1.527

package/detox/record-block-execution.cjs

@@ -0,0 +1,78 @@
+// producer half of the paired test-block execution contract. jest's own JSON
+// reporter cannot say whether a failed block failed in its body or never got
+// there: a `beforeAll`/`beforeEach` throw and a failed `expect` inside the body
+// produce assertion results identical in status, duration, invocations,
+// numPassingAsserts and retryReasons. only the failure message text differs, and
+// attributing behavior on message text is the fuzzy join this whole bridge
+// exists to remove.
+//
+// so the suite records it directly. this module wraps the globals the
+// conformance catalogs register their blocks with, and appends one line per
+// block whose body actually started, naming how that body finished. a block
+// whose hooks failed produces no line at all, which is what makes a setup loss
+// distinguishable from a behavior failure downstream.
+//
+// the rnx suites get it through `jest-setup-after-env.cjs`, which this preset
+// already loads; the native detox suites name it in `setupFilesAfterEnv`
+// directly. either way it does nothing until CONFORMANCE_BLOCK_EXECUTION_FILE
+// is set, so an unwired run behaves exactly as before.
+//
+// `scripts/lib/paired-conformance-test-outcomes.ts` reads what this writes.
+
+const { appendFileSync } = require('node:fs')
+// the global `expect` is not jest's here: detox's core listener overwrites it
+// with its own element matcher on the circus `setup` event, which fires before
+// setup files are required. `@jest/globals` is served by the jest runtime
+// itself and always hands back the same jest expect the runner set `testPath`
+// on, whatever a runner did to the globals.
+const { expect: jestExpect } = require('@jest/globals')
+
+const outputFile = process.env.CONFORMANCE_BLOCK_EXECUTION_FILE
+
+if (outputFile) {
+  const testFile = jestExpect.getState().testPath
+
+  // a retried block runs its body more than once. numbering the invocations
+  // makes the retry explicit, so a reader can take the last attempt instead of
+  // guessing which of two identical lines was terminal.
+  const attempts = new Map()
+
+  const record = (title, bodyOutcome) => {
+    const attempt = (attempts.get(title) ?? 0) + 1
+    attempts.set(title, attempt)
+    appendFileSync(
+      outputFile,
+      `${JSON.stringify({ attempt, bodyOutcome, testFile, title })}\n`,
+    )
+  }
+
+  // jest workers each append to the same file. these lines are far below the
+  // atomic-append size, so interleaving splits between lines, never inside one.
+  const wrap = (raw) => {
+    const wrapped = function wrapped(title, body, timeout) {
+      if (typeof body !== 'function') return raw(title, body, timeout)
+      return raw(
+        title,
+        async function recordedBody(...args) {
+          let bodyOutcome = 'failed'
+          try {
+            const value = await body.apply(this, args)
+            bodyOutcome = 'passed'
+            return value
+          } finally {
+            record(title, bodyOutcome)
+          }
+        },
+        timeout,
+      )
+    }
+    // carries over each/skip/todo/failing/concurrent; `only` is wrapped too so a
+    // focused run still records its bodies.
+    Object.assign(wrapped, raw)
+    if (typeof raw.only === 'function') wrapped.only = wrap(raw.only)
+    return wrapped
+  }
+
+  globalThis.it = wrap(globalThis.it)
+  globalThis.test = wrap(globalThis.test)
+}

package/dist-lib/agent-daemon-client.cjs

@@ -0,0 +1,502 @@
+/*! rnx v0.1.527 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+let __sootsim_import_meta_url = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; } catch {}
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/agent-daemon-client.ts
+var agent_daemon_client_exports = {};
+__export(agent_daemon_client_exports, {
+  AgentDaemonClient: () => AgentDaemonClient,
+  AgentDaemonError: () => AgentDaemonError,
+  connectToDaemon: () => connectToDaemon,
+  ensureDaemonRunning: () => ensureDaemonRunning,
+  isBridgeUp: () => isBridgeUp
+});
+module.exports = __toCommonJS(agent_daemon_client_exports);
+var import_node_child_process = require("node:child_process");
+var import_node_net = __toESM(require("node:net"), 1);
+var import_ws = require("ws");
+
+// src/agent-sessions.ts
+var import_node_fs3 = __toESM(require("node:fs"), 1);
+var import_node_path3 = __toESM(require("node:path"), 1);
+
+// cli/self-invocation.ts
+var import_node_fs = require("node:fs");
+var import_node_path = require("node:path");
+var import_node_url = require("node:url");
+
+// src/public-brand.ts
+var name = "rnx";
+var rnxPublicBrand = Object.freeze({
+  name,
+  packageName: "rnxsim",
+  commandName: "rnx",
+  domain: "rnxsim.com",
+  origin: "https://rnxsim.com"
+});
+
+// cli/standalone.ts
+var IS_STANDALONE = typeof __SOOTSIM_STANDALONE__ !== "undefined" && __SOOTSIM_STANDALONE__;
+
+// cli/self-invocation.ts
+function sourceEntryPath() {
+  try {
+    const candidate = (0, import_node_path.join)((0, import_node_path.dirname)((0, import_node_url.fileURLToPath)(__sootsim_import_meta_url)), "bin.ts");
+    return (0, import_node_fs.existsSync)(candidate) ? candidate : null;
+  } catch {
+    return null;
+  }
+}
+function isCliEntry(path3) {
+  const name2 = (0, import_node_path.basename)(path3);
+  return name2 === "bin.ts" || name2 === "bin.js";
+}
+function rnxSelfInvocation() {
+  if (IS_STANDALONE) return { executable: process.execPath, prefixArgs: [] };
+  const entry = process.argv[1];
+  if (entry && isCliEntry(entry)) {
+    return { executable: process.execPath, prefixArgs: [entry] };
+  }
+  const sourceEntry = sourceEntryPath();
+  if (sourceEntry) {
+    return { executable: process.execPath, prefixArgs: [sourceEntry] };
+  }
+  if (!entry) {
+    throw new Error(`could not locate the ${rnxPublicBrand.commandName} entry script`);
+  }
+  return { executable: process.execPath, prefixArgs: [entry] };
+}
+
+// src/home-paths.ts
+var import_node_fs2 = __toESM(require("node:fs"), 1);
+var import_node_path2 = __toESM(require("node:path"), 1);
+function isSootsimDevCheckout() {
+  if (process.env.SOOTSIM_FORCE_DAEMON_INSTALL === "1") return false;
+  const env = process.env.SOOTSIM_DEV;
+  if (env === "1" || env === "true") return true;
+  if (env === "0" || env === "false") return false;
+  const argv1 = process.argv[1];
+  if (!argv1) return false;
+  try {
+    const real = import_node_fs2.default.realpathSync(argv1);
+    return real.includes(`${import_node_path2.default.sep}packages${import_node_path2.default.sep}sootsim${import_node_path2.default.sep}`);
+  } catch {
+    return false;
+  }
+}
+function isDevWorkstation() {
+  if (process.env.SOOTSIM_FORCE_DAEMON_INSTALL === "1") return false;
+  return process.env.IS_TAMAGUI_DEV === "1";
+}
+function shouldSkipPersistentDaemon() {
+  return isSootsimDevCheckout() || isDevWorkstation();
+}
+var DAEMON_LOCKFILE_MAX_BYTES = 16 * 1024;
+
+// src/attached-projects.ts
+var COST_HISTORY_MAX_AGE_MS = 14 * 24 * 60 * 60 * 1e3;
+
+// src/agent-sessions.ts
+function resolveSootsimInvocation() {
+  if (process.env.RNX_BIN) {
+    return { executable: process.env.RNX_BIN, prefixArgs: [] };
+  }
+  if (IS_STANDALONE) return rnxSelfInvocation();
+  if (process.versions.electron) {
+    const resourcesPath = process.resourcesPath;
+    if (resourcesPath) {
+      const candidates = [
+        import_node_path3.default.join(resourcesPath, "bin", "sootsim"),
+        import_node_path3.default.join(resourcesPath, "bin", `sootsim-${process.platform}-${process.arch}`)
+      ];
+      for (const c of candidates) {
+        if (import_node_fs3.default.existsSync(c)) return { executable: c, prefixArgs: [] };
+      }
+    }
+  }
+  const workspace = tryWorkspaceSootsim();
+  if (workspace) return workspace;
+  const argv1 = process.argv[1];
+  if (argv1 && /\.(ts|tsx|mjs|cjs|js)$/.test(argv1)) {
+    return { executable: process.argv[0], prefixArgs: [argv1] };
+  }
+  throw new Error(
+    "rnx CLI not found. set RNX_BIN to the path of the rnx binary, or build the workspace CLI via `bun run --cwd packages/sootsim build:cli`."
+  );
+}
+function tryWorkspaceSootsim() {
+  try {
+    const sootsimDir = resolveSootsimPackageDir();
+    if (!sootsimDir) return null;
+    const binaryName = `rnx-${process.platform === "win32" ? "windows" : process.platform}-${process.arch}${process.platform === "win32" ? ".exe" : ""}`;
+    const distBinary = import_node_path3.default.join(sootsimDir, "dist-bin", binaryName);
+    if (import_node_fs3.default.existsSync(distBinary)) return { executable: distBinary, prefixArgs: [] };
+    const distBin = import_node_path3.default.join(sootsimDir, "dist-cli", "bin.js");
+    if (import_node_fs3.default.existsSync(distBin)) {
+      try {
+        const src = import_node_path3.default.join(sootsimDir, "cli", "commands", "agent-wrapper.ts");
+        if (import_node_fs3.default.existsSync(src)) {
+          const srcMtime = import_node_fs3.default.statSync(src).mtimeMs;
+          const buildMtime = import_node_fs3.default.statSync(distBin).mtimeMs;
+          if (buildMtime < srcMtime) {
+            console.warn(
+              `[rnx] dist-cli/bin.js is older than agent-wrapper.ts \u2014 rebuild with \`bun run --cwd packages/sootsim build:cli\`.`
+            );
+          }
+        }
+      } catch {
+      }
+      return { executable: process.execPath, prefixArgs: [distBin] };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function resolveSootsimPackageDir() {
+  try {
+    const resolved = require.resolve(`${rnxPublicBrand.packageName}/package.json`);
+    return import_node_path3.default.dirname(resolved);
+  } catch {
+  }
+  const here = fileFromImportMeta();
+  if (!here) return null;
+  let cur = import_node_path3.default.dirname(here);
+  for (let i = 0; i < 8; i++) {
+    const pkg = import_node_path3.default.join(cur, "package.json");
+    try {
+      if (import_node_fs3.default.existsSync(pkg)) {
+        const parsed = JSON.parse(import_node_fs3.default.readFileSync(pkg, "utf8"));
+        if (parsed.name === rnxPublicBrand.packageName) return cur;
+      }
+    } catch {
+    }
+    const parent = import_node_path3.default.dirname(cur);
+    if (parent === cur) break;
+    cur = parent;
+  }
+  return null;
+}
+function fileFromImportMeta() {
+  try {
+    const url = __sootsim_import_meta_url;
+    if (!url || !url.startsWith("file://")) return null;
+    return decodeURIComponent(url.slice("file://".length));
+  } catch {
+    return null;
+  }
+}
+
+// src/bridge-constants.ts
+var DEFAULT_SOOTSIM_BRIDGE_PORT = 7668;
+var DEFAULT_SOOTSIM_BRIDGE_URL = `http://localhost:${DEFAULT_SOOTSIM_BRIDGE_PORT}/`;
+
+// src/agent-daemon-client.ts
+var AgentDaemonError = class extends Error {
+  code;
+  constructor(message, code) {
+    super(message);
+    this.name = "AgentDaemonError";
+    this.code = code;
+  }
+};
+var AgentDaemonClient = class {
+  ws;
+  port;
+  commandTimeoutMs;
+  ready;
+  closed = false;
+  nextId = 1;
+  pending = /* @__PURE__ */ new Map();
+  eventListeners = /* @__PURE__ */ new Set();
+  statusListeners = /* @__PURE__ */ new Set();
+  disconnectListeners = /* @__PURE__ */ new Set();
+  constructor(opts = {}) {
+    this.port = opts.port ?? DEFAULT_SOOTSIM_BRIDGE_PORT;
+    this.commandTimeoutMs = opts.commandTimeoutMs ?? 15e3;
+    this.ws = new import_ws.WebSocket(`ws://127.0.0.1:${this.port}`);
+    this.ready = new Promise((resolve, reject) => {
+      const onOpen = () => {
+        this.ws.off("error", onError);
+        resolve();
+      };
+      const onError = (err) => {
+        this.ws.off("open", onOpen);
+        reject(
+          new AgentDaemonError(
+            `could not connect to rnx daemon on port ${this.port}: ${err.message}`,
+            "NO_DAEMON"
+          )
+        );
+      };
+      this.ws.once("open", onOpen);
+      this.ws.once("error", onError);
+    });
+    this.ws.on("message", (data) => this.handleMessage(data));
+    this.ws.on("close", () => this.handleClose());
+    this.ws.on("error", () => {
+    });
+  }
+  async waitReady() {
+    return this.ready;
+  }
+  // --- public api ---
+  async listProjects() {
+    return this.send("agent:list-projects");
+  }
+  async upsertProject(input) {
+    return this.send("agent:upsert-project", { input });
+  }
+  async deleteProject(projectId) {
+    return this.send("agent:delete-project", { projectId });
+  }
+  async autoAttachForUrl(input) {
+    return this.send("agent:auto-attach-for-url", {
+      input
+    });
+  }
+  async listSessions(projectId) {
+    return this.send("agent:list-sessions", { projectId });
+  }
+  async startSession(input) {
+    return this.send("agent:start-session", { input });
+  }
+  async sendPrompt(sessionId, prompt) {
+    return this.send("agent:send-prompt", {
+      sessionId,
+      prompt
+    });
+  }
+  async sendClaimedPrompt(simId, prompt) {
+    return this.send(
+      "agent:send-claimed-prompt",
+      {
+        simId,
+        prompt
+      }
+    );
+  }
+  async endSession(sessionId) {
+    return this.send("agent:end-session", { sessionId });
+  }
+  async getTranscript(sessionId) {
+    return this.send("agent:get-transcript", {
+      sessionId
+    });
+  }
+  async getPaths() {
+    return this.send("agent:get-paths");
+  }
+  async subscribeEvents(sessionId) {
+    return this.send("agent:subscribe-events", {
+      sessionId
+    });
+  }
+  async unsubscribeEvents(sessionId) {
+    return this.send("agent:unsubscribe-events", {
+      sessionId
+    });
+  }
+  onAgentEvent(cb) {
+    this.eventListeners.add(cb);
+    return () => this.eventListeners.delete(cb);
+  }
+  onSessionStatusChange(cb) {
+    this.statusListeners.add(cb);
+    return () => this.statusListeners.delete(cb);
+  }
+  onDisconnect(cb) {
+    this.disconnectListeners.add(cb);
+    return () => this.disconnectListeners.delete(cb);
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    try {
+      this.ws.close();
+    } catch {
+    }
+  }
+  // --- internals ---
+  async send(type, payload = {}) {
+    await this.ready;
+    if (this.closed || this.ws.readyState !== import_ws.WebSocket.OPEN) {
+      throw new AgentDaemonError("daemon connection is closed", "NO_DAEMON");
+    }
+    const id = this.nextId++;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(
+          new AgentDaemonError(
+            `${type} timed out after ${Math.round(this.commandTimeoutMs / 1e3)}s`,
+            "TIMEOUT"
+          )
+        );
+      }, this.commandTimeoutMs);
+      this.pending.set(id, {
+        resolve,
+        reject,
+        timer
+      });
+      try {
+        this.ws.send(JSON.stringify({ id, type, ...payload }));
+      } catch (err) {
+        clearTimeout(timer);
+        this.pending.delete(id);
+        reject(err instanceof Error ? err : new Error(String(err)));
+      }
+    });
+  }
+  handleMessage(data) {
+    let msg;
+    try {
+      msg = JSON.parse(String(data));
+    } catch {
+      return;
+    }
+    if (!msg || typeof msg !== "object") return;
+    if (msg.type === "agent:event") {
+      for (const cb of this.eventListeners) {
+        try {
+          cb({ sessionId: msg.sessionId, event: msg.event });
+        } catch {
+        }
+      }
+      return;
+    }
+    if (msg.type === "agent:session-status") {
+      for (const cb of this.statusListeners) {
+        try {
+          cb(msg.session);
+        } catch {
+        }
+      }
+      return;
+    }
+    if (typeof msg.id !== "number") return;
+    const entry = this.pending.get(msg.id);
+    if (!entry) return;
+    this.pending.delete(msg.id);
+    clearTimeout(entry.timer);
+    if (msg.error) {
+      entry.reject(new AgentDaemonError(msg.error, msg.code));
+    } else {
+      entry.resolve(msg.result);
+    }
+  }
+  handleClose() {
+    if (this.closed) return;
+    this.closed = true;
+    for (const [, entry] of this.pending) {
+      clearTimeout(entry.timer);
+      entry.reject(new AgentDaemonError("daemon disconnected", "DISCONNECT"));
+    }
+    this.pending.clear();
+    for (const cb of this.disconnectListeners) {
+      try {
+        cb();
+      } catch {
+      }
+    }
+  }
+};
+function isBridgeUp(port = DEFAULT_SOOTSIM_BRIDGE_PORT, timeoutMs = 400) {
+  return new Promise((resolve) => {
+    const socket = new import_node_net.default.Socket();
+    let settled = false;
+    const done = (ok) => {
+      if (settled) return;
+      settled = true;
+      socket.destroy();
+      resolve(ok);
+    };
+    socket.setTimeout(timeoutMs);
+    socket.once("connect", () => done(true));
+    socket.once("timeout", () => done(false));
+    socket.once("error", () => done(false));
+    socket.connect(port, "127.0.0.1");
+  });
+}
+async function ensureDaemonRunning(opts = {}) {
+  const port = opts.port ?? DEFAULT_SOOTSIM_BRIDGE_PORT;
+  if (await isBridgeUp(port)) {
+    return { alreadyRunning: true };
+  }
+  if (shouldSkipPersistentDaemon()) {
+    throw new AgentDaemonError(
+      `no rnx bridge on port ${port}. run \`rnx daemon install\` to enable the faster background service, or \`rnx serve\` in another shell.`,
+      "DEV_HOST_REFUSED"
+    );
+  }
+  const { executable, prefixArgs } = resolveSootsimInvocation();
+  const args = [...prefixArgs, "serve", "--quiet"];
+  if (port !== DEFAULT_SOOTSIM_BRIDGE_PORT) {
+    args.push("--port", String(port));
+  }
+  const child = (0, import_node_child_process.spawn)(executable, args, {
+    detached: true,
+    stdio: "ignore",
+    env: process.env,
+    cwd: process.cwd()
+  });
+  child.unref();
+  const deadline = Date.now() + (opts.startupTimeoutMs ?? 5e3);
+  while (Date.now() < deadline) {
+    if (await isBridgeUp(port)) return { alreadyRunning: false, pid: child.pid };
+    await new Promise((r) => setTimeout(r, 100));
+  }
+  throw new AgentDaemonError(
+    `spawned rnx daemon on port ${port} but it did not come up in time. run \`rnx serve\` manually to diagnose.`,
+    "SPAWN_TIMEOUT"
+  );
+}
+async function connectToDaemon(opts = {}) {
+  await ensureDaemonRunning({
+    port: opts.port,
+    startupTimeoutMs: opts.startupTimeoutMs
+  });
+  const client = new AgentDaemonClient(opts);
+  try {
+    await client.waitReady();
+  } catch (err) {
+    client.close();
+    throw err;
+  }
+  return client;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AgentDaemonClient,
+  AgentDaemonError,
+  connectToDaemon,
+  ensureDaemonRunning,
+  isBridgeUp
+});

package/dist-lib/agent-events.cjs

@@ -0,0 +1,48 @@
+/*! rnx v0.1.527 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+let __sootsim_import_meta_url = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; } catch {}
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/agent-events.ts
+var agent_events_exports = {};
+__export(agent_events_exports, {
+  isAgentEvent: () => isAgentEvent,
+  parseAgentEventLine: () => parseAgentEventLine
+});
+module.exports = __toCommonJS(agent_events_exports);
+function isAgentEvent(value) {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  return typeof v.type === "string" && typeof v.ts === "number";
+}
+function parseAgentEventLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed) return null;
+  try {
+    const parsed = JSON.parse(trimmed);
+    return isAgentEvent(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isAgentEvent,
+  parseAgentEventLine
+});

package/dist-lib/agent-identity.cjs

@@ -0,0 +1,53 @@
+/*! rnx v0.1.527 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+let __sootsim_import_meta_url = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; } catch {}
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/agent-identity.ts
+var agent_identity_exports = {};
+__export(agent_identity_exports, {
+  agentSessionIdFromCliIdentity: () => agentSessionIdFromCliIdentity,
+  isValidTeamMachineSessionId: () => isValidTeamMachineSessionId,
+  teamMachineSessionIdFromCliIdentity: () => teamMachineSessionIdFromCliIdentity
+});
+module.exports = __toCommonJS(agent_identity_exports);
+var TEAM_MACHINE_SESSION_RE = /^[A-Za-z0-9._:-]{1,160}$/;
+function agentSessionIdFromCliIdentity(identity) {
+  if (!identity) return null;
+  const colon = identity.indexOf(":");
+  if (colon < 0) return identity.trim() || null;
+  const source = identity.slice(0, colon);
+  const value = identity.slice(colon + 1).trim();
+  return source === "RNX_CLI_IDENTITY" && value ? value : null;
+}
+function teamMachineSessionIdFromCliIdentity(identity) {
+  if (!identity?.startsWith("TM_SESSION:")) return null;
+  const sessionId = identity.slice("TM_SESSION:".length).trim();
+  if (!TEAM_MACHINE_SESSION_RE.test(sessionId)) return null;
+  return sessionId;
+}
+function isValidTeamMachineSessionId(sessionId) {
+  return TEAM_MACHINE_SESSION_RE.test(sessionId);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  agentSessionIdFromCliIdentity,
+  isValidTeamMachineSessionId,
+  teamMachineSessionIdFromCliIdentity
+});