@agent-relay/utils 2.0.28 → 2.0.30

package/dist/cjs/precompiled-patterns.js

@@ -0,0 +1,271 @@
+"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);
+var precompiled_patterns_exports = {};
+__export(precompiled_patterns_exports, {
+  StaticPatterns: () => StaticPatterns,
+  benchmarkPatterns: () => benchmarkPatterns,
+  getCompiledPatterns: () => getCompiledPatterns,
+  getPatternMetrics: () => getPatternMetrics,
+  isEscapedFenceEndFast: () => isEscapedFenceEndFast,
+  isInstructionalTextFast: () => isInstructionalTextFast,
+  isPlaceholderTargetFast: () => isPlaceholderTargetFast,
+  isSpawnOrReleaseCommandFast: () => isSpawnOrReleaseCommandFast,
+  resetPatternMetrics: () => resetPatternMetrics,
+  stripAnsiFast: () => stripAnsiFast,
+  trackPatternPerformance: () => trackPatternPerformance,
+  unescapeFenceMarkersFast: () => unescapeFenceMarkersFast
+});
+module.exports = __toCommonJS(precompiled_patterns_exports);
+const patternCache = /* @__PURE__ */ new Map();
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function getCompiledPatterns(prefix = "->relay:", thinkingPrefix = "->thinking:") {
+  const cacheKey = `${prefix}|${thinkingPrefix}`;
+  const cached = patternCache.get(cacheKey);
+  if (cached) {
+    return cached;
+  }
+  const escapedPrefix = escapeRegex(prefix);
+  const escapedThinking = escapeRegex(thinkingPrefix);
+  const promptChars = String.raw`[>$%#→➜›»●•◦‣⁃\-*⏺◆◇○□■│┃┆┇┊┋╎╏✦]`;
+  const lineStartPrefix = String.raw`^(?:\s*(?:${promptChars}\s*)*)?`;
+  const threadSyntax = String.raw`(?:\s+\[thread:(?:([\w-]+):)?([\w-]+)\])?`;
+  const patterns = {
+    // Combined inline pattern for both relay and thinking prefixes
+    // Groups: 1=prefix type (relay/thinking), 2=target, 3=thread project, 4=thread id, 5=body
+    inline: new RegExp(
+      `${lineStartPrefix}(${escapedPrefix}|${escapedThinking})(\\S+)${threadSyntax}\\s+(.+)$`
+    ),
+    // Combined fenced inline pattern: ->relay:Target <<<
+    // Groups: 1=prefix type, 2=target, 3=thread project, 4=thread id
+    fencedInline: new RegExp(
+      `${lineStartPrefix}(${escapedPrefix}|${escapedThinking})(\\S+)${threadSyntax}\\s+<<<\\s*$`
+    ),
+    // Escape pattern for \->relay: or \->thinking:
+    escape: new RegExp(`^(\\s*)\\\\(${escapedPrefix}|${escapedThinking})`)
+  };
+  patternCache.set(cacheKey, patterns);
+  return patterns;
+}
+const INSTRUCTIONAL_COMBINED = new RegExp(
+  [
+    String.raw`\bSEND:\s*$`,
+    // "SEND:" at end (instruction prefix)
+    String.raw`\bPROTOCOL:\s*\(\d+\)`,
+    // "PROTOCOL: (1)" - numbered instructions
+    String.raw`\bExample:`,
+    // "Example:" marker
+    String.raw`\\->relay:`,
+    // Escaped relay prefix (documentation)
+    String.raw`\\->thinking:`,
+    // Escaped thinking prefix (documentation)
+    String.raw`^AgentName\s+`,
+    // Body starting with "AgentName"
+    String.raw`^Target\s+`,
+    // Body starting with "Target"
+    String.raw`\[Agent Relay\]`,
+    // Injected instruction header
+    String.raw`MULTI-LINE:`,
+    // Multi-line format instruction
+    String.raw`RECEIVE:`
+    // Receive instruction marker
+  ].join("|"),
+  "i"
+  // Case insensitive
+);
+function isInstructionalTextFast(body) {
+  return INSTRUCTIONAL_COMBINED.test(body);
+}
+const PLACEHOLDER_TARGETS_SET = /* @__PURE__ */ new Set([
+  "agentname",
+  "target",
+  "recipient",
+  "yourtarget",
+  "targetagent",
+  "someagent",
+  "otheragent",
+  "worker"
+]);
+function isPlaceholderTargetFast(target) {
+  return PLACEHOLDER_TARGETS_SET.has(target.toLowerCase());
+}
+const ANSI_PATTERN_COMPILED = /\x1b\[[0-9;?]*[a-zA-Z]|\x1b\].*?(?:\x07|\x1b\\)|\r/g;
+const ORPHANED_CSI_COMPILED = /^\s*(\[(?:\?|\d)\d*[A-Za-z])+\s*/g;
+function stripAnsiFast(str) {
+  ANSI_PATTERN_COMPILED.lastIndex = 0;
+  ORPHANED_CSI_COMPILED.lastIndex = 0;
+  let result = str.replace(ANSI_PATTERN_COMPILED, "");
+  result = result.replace(ORPHANED_CSI_COMPILED, "");
+  return result;
+}
+const StaticPatterns = {
+  // Block markers
+  BLOCK_END: /\[\[\/RELAY\]\]/,
+  BLOCK_METADATA_END: /\[\[\/RELAY_METADATA\]\]/,
+  CODE_FENCE: /^```/,
+  // Fence markers
+  FENCE_END_START: /^(?:\s*)?>>>/,
+  FENCE_END_LINE: />>>\s*$/,
+  FENCE_END: /^(?:\s*)?>>>|>>>\s*$/,
+  // Escape patterns
+  ESCAPED_FENCE_START: /\\<<</g,
+  ESCAPED_FENCE_END: /\\>>>/g,
+  ESCAPED_FENCE_END_CHECK: /\\>>>\s*$/,
+  ESCAPED_FENCE_START_CHECK: /^(?:\s*)?\\>>>/,
+  // Continuation helpers
+  BULLET_OR_NUMBERED_LIST: /^[ \t]*([\-*•◦‣⏺◆◇○□■]|[0-9]+[.)])\s+/,
+  PROMPTISH_LINE: /^[\s]*[>$%#➜›»][\s]*$/,
+  RELAY_INJECTION_PREFIX: /^\s*Relay message from /,
+  // Spawn/release commands
+  SPAWN_COMMAND: /->relay:spawn\s+\S+/i,
+  RELEASE_COMMAND: /->relay:release\s+\S+/i,
+  // Claude extended thinking blocks
+  THINKING_START: /<thinking>/,
+  THINKING_END: /<\/thinking>/,
+  // Agent name validation (PascalCase, 2-30 chars)
+  AGENT_NAME: /^[A-Z][a-zA-Z0-9]{1,29}$/,
+  // CLI prompt patterns by type
+  CLI_PROMPTS: {
+    claude: /^[>›»]\s*$/,
+    gemini: /^[>›»]\s*$/,
+    codex: /^[>›»]\s*$/,
+    droid: /^[>›»]\s*$/,
+    opencode: /^[>›»]\s*$/,
+    spawned: /^[>›»]\s*$/,
+    other: /^[>$%#➜›»]\s*$/
+  }
+};
+function isSpawnOrReleaseCommandFast(line) {
+  return StaticPatterns.SPAWN_COMMAND.test(line) || StaticPatterns.RELEASE_COMMAND.test(line);
+}
+function isEscapedFenceEndFast(line) {
+  return StaticPatterns.ESCAPED_FENCE_END_CHECK.test(line) || StaticPatterns.ESCAPED_FENCE_START_CHECK.test(line);
+}
+function unescapeFenceMarkersFast(content) {
+  StaticPatterns.ESCAPED_FENCE_START.lastIndex = 0;
+  StaticPatterns.ESCAPED_FENCE_END.lastIndex = 0;
+  return content.replace(StaticPatterns.ESCAPED_FENCE_START, "<<<").replace(StaticPatterns.ESCAPED_FENCE_END, ">>>");
+}
+const metrics = /* @__PURE__ */ new Map();
+function trackPatternPerformance(name, ms) {
+  const existing = metrics.get(name);
+  if (existing) {
+    existing.calls++;
+    existing.totalMs += ms;
+    existing.maxMs = Math.max(existing.maxMs, ms);
+  } else {
+    metrics.set(name, { calls: 1, totalMs: ms, maxMs: ms });
+  }
+}
+function getPatternMetrics() {
+  const result = /* @__PURE__ */ new Map();
+  for (const [name, m] of metrics) {
+    result.set(name, {
+      ...m,
+      avgMs: m.calls > 0 ? m.totalMs / m.calls : 0
+    });
+  }
+  return result;
+}
+function resetPatternMetrics() {
+  metrics.clear();
+}
+function benchmarkPatterns(iterations = 1e4) {
+  const testStrings = [
+    "->relay:Agent Hello world",
+    "->relay:Lead [thread:task-123] Starting work",
+    "  > ->relay:Worker <<<",
+    "Some random text without relay",
+    "\x1B[32m->relay:Test\x1B[0m message with ANSI",
+    '->relay:spawn Worker claude "task"',
+    "ACK: Task received",
+    "SEND: Protocol instruction",
+    "Example: how to use relay"
+  ];
+  const results = {};
+  {
+    let maxNs = 0;
+    const start = process.hrtime.bigint();
+    for (let i = 0; i < iterations; i++) {
+      for (const str of testStrings) {
+        const s = process.hrtime.bigint();
+        isInstructionalTextFast(str);
+        const elapsed = Number(process.hrtime.bigint() - s);
+        if (elapsed > maxNs) maxNs = elapsed;
+      }
+    }
+    const totalNs = Number(process.hrtime.bigint() - start);
+    results["instructionalCheck"] = {
+      avgNs: totalNs / (iterations * testStrings.length),
+      maxNs
+    };
+  }
+  {
+    let maxNs = 0;
+    const start = process.hrtime.bigint();
+    for (let i = 0; i < iterations; i++) {
+      for (const str of testStrings) {
+        const s = process.hrtime.bigint();
+        stripAnsiFast(str);
+        const elapsed = Number(process.hrtime.bigint() - s);
+        if (elapsed > maxNs) maxNs = elapsed;
+      }
+    }
+    const totalNs = Number(process.hrtime.bigint() - start);
+    results["ansiStrip"] = {
+      avgNs: totalNs / (iterations * testStrings.length),
+      maxNs
+    };
+  }
+  {
+    const targets = ["AgentName", "Lead", "Worker", "target", "Developer"];
+    let maxNs = 0;
+    const start = process.hrtime.bigint();
+    for (let i = 0; i < iterations; i++) {
+      for (const t of targets) {
+        const s = process.hrtime.bigint();
+        isPlaceholderTargetFast(t);
+        const elapsed = Number(process.hrtime.bigint() - s);
+        if (elapsed > maxNs) maxNs = elapsed;
+      }
+    }
+    const totalNs = Number(process.hrtime.bigint() - start);
+    results["placeholderCheck"] = {
+      avgNs: totalNs / (iterations * targets.length),
+      maxNs
+    };
+  }
+  return results;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  StaticPatterns,
+  benchmarkPatterns,
+  getCompiledPatterns,
+  getPatternMetrics,
+  isEscapedFenceEndFast,
+  isInstructionalTextFast,
+  isPlaceholderTargetFast,
+  isSpawnOrReleaseCommandFast,
+  resetPatternMetrics,
+  stripAnsiFast,
+  trackPatternPerformance,
+  unescapeFenceMarkersFast
+});

package/dist/cjs/relay-pty-path.js

@@ -0,0 +1,143 @@
+"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 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 __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);
+var relay_pty_path_exports = {};
+__export(relay_pty_path_exports, {
+  clearBinaryCache: () => clearBinaryCache,
+  findRelayPtyBinary: () => findRelayPtyBinary,
+  getCachedRelayPtyPath: () => getCachedRelayPtyPath,
+  getLastSearchPaths: () => getLastSearchPaths,
+  hasRelayPtyBinary: () => hasRelayPtyBinary
+});
+module.exports = __toCommonJS(relay_pty_path_exports);
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_os = __toESM(require("node:os"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+function getPlatformBinaryName() {
+  const platform = import_node_os.default.platform();
+  const arch = import_node_os.default.arch();
+  if (platform === "darwin" && arch === "arm64") return "relay-pty-darwin-arm64";
+  if (platform === "darwin" && arch === "x64") return "relay-pty-darwin-x64";
+  if (platform === "linux" && arch === "arm64") return "relay-pty-linux-arm64";
+  if (platform === "linux" && arch === "x64") return "relay-pty-linux-x64";
+  return null;
+}
+let cachedBinaryPath;
+let cacheChecked = false;
+let lastSearchPaths = [];
+function getLastSearchPaths() {
+  return [...lastSearchPaths];
+}
+function findRelayPtyBinary(callerDirname) {
+  const envOverride = process.env.RELAY_PTY_BINARY;
+  if (envOverride && import_node_fs.default.existsSync(envOverride)) {
+    lastSearchPaths = [envOverride];
+    return envOverride;
+  }
+  let packageRoot;
+  if (callerDirname.includes("node_modules/@agent-relay/")) {
+    packageRoot = import_node_path.default.join(callerDirname, "..", "..", "..", "..");
+  } else if (callerDirname.includes("node_modules/agent-relay")) {
+    packageRoot = import_node_path.default.join(callerDirname, "..", "..", "..");
+  } else {
+    packageRoot = import_node_path.default.join(callerDirname, "..", "..", "..");
+  }
+  let nodeModulesRoot = null;
+  const nodeModulesMatch = callerDirname.match(/^(.+?\/node_modules)\/@agent-relay\//);
+  if (nodeModulesMatch) {
+    nodeModulesRoot = nodeModulesMatch[1];
+  }
+  const platformBinary = getPlatformBinaryName();
+  const candidates = [
+    // Primary: installed by postinstall from platform-specific binary
+    import_node_path.default.join(packageRoot, "bin", "relay-pty"),
+    // Development: local Rust build
+    import_node_path.default.join(packageRoot, "relay-pty", "target", "release", "relay-pty"),
+    import_node_path.default.join(packageRoot, "relay-pty", "target", "debug", "relay-pty"),
+    // Local build in cwd (for development)
+    import_node_path.default.join(process.cwd(), "relay-pty", "target", "release", "relay-pty"),
+    // Docker container (CI tests)
+    "/app/bin/relay-pty",
+    // Installed globally
+    "/usr/local/bin/relay-pty",
+    // In node_modules (when installed as local dependency)
+    import_node_path.default.join(process.cwd(), "node_modules", "agent-relay", "bin", "relay-pty"),
+    // Global npm install (nvm) - root package
+    import_node_path.default.join(process.env.HOME || "", ".nvm", "versions", "node", process.version, "lib", "node_modules", "agent-relay", "bin", "relay-pty")
+  ];
+  if (nodeModulesRoot) {
+    candidates.push(import_node_path.default.join(nodeModulesRoot, "agent-relay", "bin", "relay-pty"));
+  }
+  if (process.env.HOME) {
+    candidates.push(import_node_path.default.join("/usr/local/lib/node_modules", "agent-relay", "bin", "relay-pty"));
+    candidates.push(import_node_path.default.join("/opt/homebrew/lib/node_modules", "agent-relay", "bin", "relay-pty"));
+    candidates.push(import_node_path.default.join(process.env.HOME, ".local", "share", "pnpm", "global", "node_modules", "agent-relay", "bin", "relay-pty"));
+  }
+  if (platformBinary) {
+    candidates.push(import_node_path.default.join(packageRoot, "bin", platformBinary));
+    candidates.push(import_node_path.default.join(process.cwd(), "node_modules", "agent-relay", "bin", platformBinary));
+    candidates.push(import_node_path.default.join(process.env.HOME || "", ".nvm", "versions", "node", process.version, "lib", "node_modules", "agent-relay", "bin", platformBinary));
+    if (nodeModulesRoot) {
+      candidates.push(import_node_path.default.join(nodeModulesRoot, "agent-relay", "bin", platformBinary));
+    }
+    if (process.env.HOME) {
+      candidates.push(import_node_path.default.join("/usr/local/lib/node_modules", "agent-relay", "bin", platformBinary));
+      candidates.push(import_node_path.default.join("/opt/homebrew/lib/node_modules", "agent-relay", "bin", platformBinary));
+      candidates.push(import_node_path.default.join(process.env.HOME, ".local", "share", "pnpm", "global", "node_modules", "agent-relay", "bin", platformBinary));
+    }
+  }
+  lastSearchPaths = candidates;
+  for (const candidate of candidates) {
+    if (import_node_fs.default.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function hasRelayPtyBinary(callerDirname) {
+  if (!cacheChecked) {
+    cachedBinaryPath = findRelayPtyBinary(callerDirname);
+    cacheChecked = true;
+  }
+  return cachedBinaryPath !== null;
+}
+function getCachedRelayPtyPath() {
+  return cachedBinaryPath;
+}
+function clearBinaryCache() {
+  cachedBinaryPath = void 0;
+  cacheChecked = false;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  clearBinaryCache,
+  findRelayPtyBinary,
+  getCachedRelayPtyPath,
+  getLastSearchPaths,
+  hasRelayPtyBinary
+});

package/dist/cjs/update-checker.js

@@ -0,0 +1,185 @@
+"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 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 __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);
+var update_checker_exports = {};
+__export(update_checker_exports, {
+  checkForUpdates: () => checkForUpdates,
+  checkForUpdatesInBackground: () => checkForUpdatesInBackground,
+  printUpdateNotification: () => printUpdateNotification
+});
+module.exports = __toCommonJS(update_checker_exports);
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_node_https = __toESM(require("node:https"), 1);
+var import_node_os = __toESM(require("node:os"), 1);
+var import_compare_versions = require("compare-versions");
+const PACKAGE_NAME = "agent-relay";
+const CHECK_INTERVAL_MS = 60 * 60 * 1e3;
+const NPM_REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
+function getCachePath() {
+  const cacheDir = import_node_path.default.join(import_node_os.default.homedir(), ".agent-relay");
+  return import_node_path.default.join(cacheDir, "update-cache.json");
+}
+function readCache() {
+  try {
+    const cachePath = getCachePath();
+    if (!import_node_fs.default.existsSync(cachePath)) return null;
+    const data = import_node_fs.default.readFileSync(cachePath, "utf-8");
+    return JSON.parse(data);
+  } catch {
+    return null;
+  }
+}
+function writeCache(cache) {
+  try {
+    const cachePath = getCachePath();
+    const cacheDir = import_node_path.default.dirname(cachePath);
+    if (!import_node_fs.default.existsSync(cacheDir)) {
+      import_node_fs.default.mkdirSync(cacheDir, { recursive: true });
+    }
+    import_node_fs.default.writeFileSync(cachePath, JSON.stringify(cache, null, 2));
+  } catch {
+  }
+}
+function fetchLatestVersion() {
+  return new Promise((resolve, reject) => {
+    const req = import_node_https.default.get(NPM_REGISTRY_URL, { timeout: 5e3 }, (res) => {
+      if (res.statusCode === 301 || res.statusCode === 302) {
+        const location = res.headers.location;
+        if (location) {
+          import_node_https.default.get(location, { timeout: 5e3 }, (redirectRes) => {
+            handleResponse(redirectRes, resolve, reject);
+          }).on("error", reject);
+          return;
+        }
+      }
+      handleResponse(res, resolve, reject);
+    });
+    req.on("error", reject);
+    req.on("timeout", () => {
+      req.destroy();
+      reject(new Error("Request timed out"));
+    });
+  });
+}
+function handleResponse(res, resolve, reject) {
+  if (res.statusCode !== 200) {
+    reject(new Error(`HTTP ${res.statusCode}`));
+    return;
+  }
+  let data = "";
+  res.on("data", (chunk) => {
+    data += chunk.toString();
+  });
+  res.on("end", () => {
+    try {
+      const json = JSON.parse(data);
+      if (json.version) {
+        resolve(json.version);
+      } else {
+        reject(new Error("No version in response"));
+      }
+    } catch (err) {
+      reject(err);
+    }
+  });
+  res.on("error", reject);
+}
+async function checkForUpdates(currentVersion) {
+  const cache = readCache();
+  const now = Date.now();
+  if (cache && now - cache.lastCheck < CHECK_INTERVAL_MS) {
+    const updateAvailable = cache.latestVersion ? (0, import_compare_versions.compare)(cache.latestVersion, currentVersion, ">") : false;
+    return {
+      updateAvailable,
+      currentVersion,
+      latestVersion: cache.latestVersion,
+      error: cache.error
+    };
+  }
+  try {
+    const latestVersion = await fetchLatestVersion();
+    const updateAvailable = (0, import_compare_versions.compare)(latestVersion, currentVersion, ">");
+    writeCache({
+      lastCheck: now,
+      latestVersion
+    });
+    return {
+      updateAvailable,
+      currentVersion,
+      latestVersion
+    };
+  } catch (err) {
+    const error = err.message;
+    writeCache({
+      lastCheck: now,
+      latestVersion: cache?.latestVersion || null,
+      error
+    });
+    return {
+      updateAvailable: false,
+      currentVersion,
+      latestVersion: cache?.latestVersion || null,
+      error
+    };
+  }
+}
+function printUpdateNotification(info) {
+  if (!info.updateAvailable || !info.latestVersion) return;
+  const line1 = `Update available: ${info.currentVersion} \u2192 ${info.latestVersion}`;
+  const line2 = "Run: npm install -g agent-relay";
+  const contentWidth = Math.max(line1.length, line2.length);
+  const boxWidth = contentWidth + 4;
+  const top = "\u256D" + "\u2500".repeat(boxWidth) + "\u256E";
+  const bottom = "\u2570" + "\u2500".repeat(boxWidth) + "\u256F";
+  const row1 = "\u2502  " + line1.padEnd(contentWidth) + "  \u2502";
+  const row2 = "\u2502  " + line2.padEnd(contentWidth) + "  \u2502";
+  console.error("");
+  console.error(top);
+  console.error(row1);
+  console.error(row2);
+  console.error(bottom);
+  console.error("");
+}
+function checkForUpdatesInBackground(currentVersion) {
+  if (process.env.AGENT_RELAY_SKIP_UPDATE_CHECK === "1") {
+    return;
+  }
+  checkForUpdates(currentVersion).then((info) => {
+    if (info.updateAvailable) {
+      printUpdateNotification(info);
+    }
+  }).catch(() => {
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkForUpdates,
+  checkForUpdatesInBackground,
+  printUpdateNotification
+});

package/dist/relay-pty-path.d.ts

@@ -11,15 +11,21 @@
  * 3. Global npm install via nvm
  * 4. System-wide installs (/usr/local/bin)
  */
+/**
+ * Get the paths that were checked in the last binary search.
+ * Useful for debugging when the binary is not found.
+ */
+export declare function getLastSearchPaths(): string[];
 /**
  * Find the relay-pty binary.
  *
  * Search order:
- * 1. bin/relay-pty in package root (installed by postinstall)
- * 2. relay-pty/target/release/relay-pty (local Rust build)
- * 3. /usr/local/bin/relay-pty (global install)
- * 4. In node_modules when installed as dependency
- * 5. Global npm installs (nvm) - both scoped and root packages
+ * 1. RELAY_PTY_BINARY environment variable (explicit override)
+ * 2. bin/relay-pty in package root (installed by postinstall)
+ * 3. relay-pty/target/release/relay-pty (local Rust build)
+ * 4. /usr/local/bin/relay-pty (global install)
+ * 5. In node_modules when installed as dependency
+ * 6. Global npm installs (nvm) - both scoped and root packages
  *
  * @param callerDirname - The __dirname of the calling module (needed to resolve relative paths)
  * @returns Path to relay-pty binary, or null if not found

package/dist/relay-pty-path.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"relay-pty-path.d.ts","sourceRoot":"","sources":["../src/relay-pty-path.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AASH;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAwEvE;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAMhE;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,IAAI,MAAM,GAAG,IAAI,GAAG,SAAS,CAEjE;AAED;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,IAAI,CAGvC"}
+{"version":3,"file":"relay-pty-path.d.ts","sourceRoot":"","sources":["../src/relay-pty-path.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AA8BH;;;GAGG;AACH,wBAAgB,kBAAkB,IAAI,MAAM,EAAE,CAE7C;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAqGvE;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAMhE;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,IAAI,MAAM,GAAG,IAAI,GAAG,SAAS,CAEjE;AAED;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,IAAI,CAGvC"}