@agent-relay/utils 2.0.29 → 2.0.30

package/dist/cjs/command-resolver.js

@@ -0,0 +1,89 @@
+"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 command_resolver_exports = {};
+__export(command_resolver_exports, {
+  commandExists: () => commandExists,
+  resolveCommand: () => resolveCommand
+});
+module.exports = __toCommonJS(command_resolver_exports);
+var import_node_child_process = require("node:child_process");
+var import_node_fs = __toESM(require("node:fs"), 1);
+function resolveCommand(command) {
+  if (command.startsWith("/")) {
+    return resolveSymlinks(command);
+  }
+  try {
+    const output = (0, import_node_child_process.execSync)(`which ${command}`, {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      // Ensure we have a reasonable PATH
+      env: {
+        ...process.env,
+        PATH: process.env.PATH || "/usr/local/bin:/usr/bin:/bin:/opt/homebrew/bin"
+      }
+    });
+    const resolvedPath = output.trim();
+    if (resolvedPath) {
+      return resolveSymlinks(resolvedPath);
+    }
+  } catch (err) {
+    console.warn(`[command-resolver] 'which ${command}' failed:`, err.message?.split("\n")[0] || "unknown error");
+  }
+  return command;
+}
+function resolveSymlinks(filePath) {
+  try {
+    const resolved = import_node_fs.default.realpathSync(filePath);
+    if (resolved !== filePath && process.env.DEBUG_SPAWN === "1") {
+      console.log(`[command-resolver] Resolved symlink: ${filePath} -> ${resolved}`);
+    }
+    return resolved;
+  } catch (err) {
+    if (process.env.DEBUG_SPAWN === "1") {
+      console.warn(`[command-resolver] realpath failed for ${filePath}:`, err.message);
+    }
+    return filePath;
+  }
+}
+function commandExists(command) {
+  try {
+    (0, import_node_child_process.execSync)(`which ${command}`, {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  commandExists,
+  resolveCommand
+});

package/dist/cjs/error-tracking.js

@@ -0,0 +1,106 @@
+"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 error_tracking_exports = {};
+__export(error_tracking_exports, {
+  ERROR_SEARCH_HINT: () => ERROR_SEARCH_HINT,
+  TracedError: () => TracedError,
+  createTraceableError: () => createTraceableError,
+  generateErrorId: () => generateErrorId,
+  logAndTraceError: () => logAndTraceError,
+  withErrorTracing: () => withErrorTracing
+});
+module.exports = __toCommonJS(error_tracking_exports);
+var import_node_crypto = require("node:crypto");
+function generateErrorId() {
+  const timestamp = Math.floor(Date.now() / 1e3);
+  const random = (0, import_node_crypto.randomBytes)(2).toString("hex");
+  return `ERR-${timestamp}-${random}`;
+}
+function createTraceableError(message, context = {}, originalError) {
+  const errorId = generateErrorId();
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const contextPairs = Object.entries(context).filter(([, v]) => v !== void 0 && v !== null).map(([k, v]) => `${k}=${typeof v === "object" ? JSON.stringify(v) : v}`).join(" ");
+  const stackInfo = originalError?.stack ? `
+  Original error: ${originalError.message}
+  Stack: ${originalError.stack}` : "";
+  const logMessage = `[${errorId}] ${message}${contextPairs ? ` | ${contextPairs}` : ""}${stackInfo}`;
+  const userMessage = `${message} (Error ID: ${errorId} - share this with support)`;
+  return {
+    errorId,
+    userMessage,
+    logMessage,
+    timestamp,
+    message,
+    context: {
+      ...context,
+      originalError: originalError?.message
+    }
+  };
+}
+function logAndTraceError(message, context = {}, originalError) {
+  const error = createTraceableError(message, context, originalError);
+  console.error(error.logMessage);
+  return error;
+}
+function withErrorTracing(fn, baseContext = {}) {
+  return (async (...args) => {
+    try {
+      return await fn(...args);
+    } catch (err) {
+      const error = logAndTraceError(
+        err instanceof Error ? err.message : "Unknown error",
+        baseContext,
+        err instanceof Error ? err : void 0
+      );
+      throw new TracedError(error);
+    }
+  });
+}
+class TracedError extends Error {
+  errorId;
+  userMessage;
+  context;
+  constructor(traced) {
+    super(traced.message);
+    this.name = "TracedError";
+    this.errorId = traced.errorId;
+    this.userMessage = traced.userMessage;
+    this.context = traced.context;
+  }
+}
+const ERROR_SEARCH_HINT = `
+To find error details in logs, search for the error ID:
+
+  grep "ERR-1706012345-a7f3" /var/log/agent-relay/*.log
+
+Or in cloud logging:
+
+  fly logs -a agent-relay-cloud | grep "ERR-1706012345-a7f3"
+
+The log entry will include full context: user ID, workspace ID, agent name, etc.
+`;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ERROR_SEARCH_HINT,
+  TracedError,
+  createTraceableError,
+  generateErrorId,
+  logAndTraceError,
+  withErrorTracing
+});

package/dist/cjs/git-remote.js

@@ -0,0 +1,120 @@
+"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 git_remote_exports = {};
+__export(git_remote_exports, {
+  findGitRoot: () => findGitRoot,
+  getGitRemoteUrl: () => getGitRemoteUrl,
+  getRepoFullName: () => getRepoFullName,
+  getRepoFullNameFromPath: () => getRepoFullNameFromPath,
+  parseGitRemoteUrl: () => parseGitRemoteUrl
+});
+module.exports = __toCommonJS(git_remote_exports);
+var fs = __toESM(require("node:fs"), 1);
+var path = __toESM(require("node:path"), 1);
+var import_node_child_process = require("node:child_process");
+function parseGitRemoteUrl(url) {
+  if (!url) return null;
+  const sshMatch = url.match(/git@[^:]+:([^/]+\/[^/]+?)(?:\.git)?$/);
+  if (sshMatch) {
+    return sshMatch[1];
+  }
+  const httpsMatch = url.match(/(?:https?|git):\/\/[^/]+\/([^/]+\/[^/]+?)(?:\.git)?$/);
+  if (httpsMatch) {
+    return httpsMatch[1];
+  }
+  return null;
+}
+function getGitRemoteUrl(workingDirectory, remoteName = "origin") {
+  try {
+    const gitDir = path.join(workingDirectory, ".git");
+    if (!fs.existsSync(gitDir)) {
+      return null;
+    }
+    const result = (0, import_node_child_process.execSync)(`git remote get-url ${remoteName}`, {
+      cwd: workingDirectory,
+      encoding: "utf-8",
+      timeout: 5e3,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return result.trim() || null;
+  } catch {
+    try {
+      const configPath = path.join(workingDirectory, ".git", "config");
+      if (!fs.existsSync(configPath)) {
+        return null;
+      }
+      const config = fs.readFileSync(configPath, "utf-8");
+      const remoteSection = new RegExp(
+        `\\[remote\\s+"${remoteName}"\\][^\\[]*url\\s*=\\s*([^\\n]+)`,
+        "i"
+      );
+      const match = config.match(remoteSection);
+      return match?.[1]?.trim() || null;
+    } catch {
+      return null;
+    }
+  }
+}
+function getRepoFullName(workingDirectory) {
+  const remoteUrl = getGitRemoteUrl(workingDirectory);
+  if (!remoteUrl) {
+    return null;
+  }
+  return parseGitRemoteUrl(remoteUrl);
+}
+function findGitRoot(startPath) {
+  let currentPath = path.resolve(startPath);
+  const root = path.parse(currentPath).root;
+  while (currentPath !== root) {
+    if (fs.existsSync(path.join(currentPath, ".git"))) {
+      return currentPath;
+    }
+    currentPath = path.dirname(currentPath);
+  }
+  return null;
+}
+function getRepoFullNameFromPath(workingDirectory) {
+  let repoName = getRepoFullName(workingDirectory);
+  if (repoName) {
+    return repoName;
+  }
+  const gitRoot = findGitRoot(workingDirectory);
+  if (gitRoot && gitRoot !== workingDirectory) {
+    repoName = getRepoFullName(gitRoot);
+  }
+  return repoName;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  findGitRoot,
+  getGitRemoteUrl,
+  getRepoFullName,
+  getRepoFullNameFromPath,
+  parseGitRemoteUrl
+});

package/dist/cjs/index.js

@@ -0,0 +1,38 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var index_exports = {};
+module.exports = __toCommonJS(index_exports);
+__reExport(index_exports, require("./name-generator.js"), module.exports);
+__reExport(index_exports, require("./logger.js"), module.exports);
+__reExport(index_exports, require("./precompiled-patterns.js"), module.exports);
+__reExport(index_exports, require("./command-resolver.js"), module.exports);
+__reExport(index_exports, require("./git-remote.js"), module.exports);
+__reExport(index_exports, require("./update-checker.js"), module.exports);
+__reExport(index_exports, require("./error-tracking.js"), module.exports);
+__reExport(index_exports, require("./model-mapping.js"), module.exports);
+__reExport(index_exports, require("./relay-pty-path.js"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./name-generator.js"),
+  ...require("./logger.js"),
+  ...require("./precompiled-patterns.js"),
+  ...require("./command-resolver.js"),
+  ...require("./git-remote.js"),
+  ...require("./update-checker.js"),
+  ...require("./error-tracking.js"),
+  ...require("./model-mapping.js"),
+  ...require("./relay-pty-path.js")
+});

package/dist/cjs/logger.js

@@ -0,0 +1,105 @@
+"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 logger_exports = {};
+__export(logger_exports, {
+  connectionLog: () => connectionLog,
+  createLogger: () => createLogger,
+  daemonLog: () => daemonLog,
+  default: () => logger_default,
+  routerLog: () => routerLog
+});
+module.exports = __toCommonJS(logger_exports);
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+const LOG_FILE = process.env.AGENT_RELAY_LOG_FILE;
+const LOG_LEVEL = (process.env.AGENT_RELAY_LOG_LEVEL ?? "INFO").toUpperCase();
+const LOG_JSON = process.env.AGENT_RELAY_LOG_JSON === "1";
+const _DEBUG = process.env.DEBUG === "1" || LOG_LEVEL === "DEBUG";
+const LEVEL_PRIORITY = {
+  DEBUG: 0,
+  INFO: 1,
+  WARN: 2,
+  ERROR: 3
+};
+if (LOG_FILE) {
+  const logDir = import_node_path.default.dirname(LOG_FILE);
+  if (!import_node_fs.default.existsSync(logDir)) {
+    import_node_fs.default.mkdirSync(logDir, { recursive: true });
+  }
+}
+function shouldLog(level) {
+  return LEVEL_PRIORITY[level] >= LEVEL_PRIORITY[LOG_LEVEL];
+}
+function formatMessage(entry) {
+  if (LOG_JSON) {
+    return JSON.stringify(entry);
+  }
+  const { ts, level, component, msg, ...extra } = entry;
+  const extraStr = Object.keys(extra).length > 0 ? " " + Object.entries(extra).map(([k, v]) => `${k}=${v}`).join(" ") : "";
+  return `${ts} [${level}] [${component}] ${msg}${extraStr}`;
+}
+function log(level, component, msg, extra) {
+  if (!shouldLog(level)) return;
+  const entry = {
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    level,
+    component,
+    msg,
+    ...extra
+  };
+  const formatted = formatMessage(entry);
+  if (LOG_FILE) {
+    import_node_fs.default.appendFileSync(LOG_FILE, formatted + "\n");
+    return;
+  }
+  if (level === "ERROR" || level === "WARN") {
+    console.error(formatted);
+  } else {
+    console.log(formatted);
+  }
+}
+function createLogger(component) {
+  return {
+    debug: (msg, extra) => log("DEBUG", component, msg, extra),
+    info: (msg, extra) => log("INFO", component, msg, extra),
+    warn: (msg, extra) => log("WARN", component, msg, extra),
+    error: (msg, extra) => log("ERROR", component, msg, extra)
+  };
+}
+const daemonLog = createLogger("daemon");
+const routerLog = createLogger("router");
+const connectionLog = createLogger("connection");
+var logger_default = createLogger;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  connectionLog,
+  createLogger,
+  daemonLog,
+  routerLog
+});

package/dist/cjs/model-mapping.js

@@ -0,0 +1,54 @@
+"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 model_mapping_exports = {};
+__export(model_mapping_exports, {
+  getBaseCli: () => getBaseCli,
+  mapModelToCli: () => mapModelToCli
+});
+module.exports = __toCommonJS(model_mapping_exports);
+const MODEL_TO_CLI = {
+  // Claude models
+  "claude-sonnet-4": "claude:sonnet",
+  "claude-opus-4": "claude:opus",
+  "claude-opus-4.5": "claude:opus",
+  "sonnet": "claude:sonnet",
+  "opus": "claude:opus",
+  "haiku": "claude:haiku",
+  // Codex (OpenAI)
+  "codex": "codex",
+  "gpt-4o": "codex",
+  // Gemini (Google)
+  "gemini": "gemini",
+  "gemini-2.0-flash": "gemini"
+};
+function mapModelToCli(model) {
+  if (!model) {
+    return "claude:sonnet";
+  }
+  const normalized = model.trim().toLowerCase();
+  return MODEL_TO_CLI[normalized] ?? "claude:sonnet";
+}
+function getBaseCli(cliVariant) {
+  return cliVariant.split(":")[0];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getBaseCli,
+  mapModelToCli
+});

package/dist/cjs/name-generator.js

@@ -0,0 +1,179 @@
+"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 name_generator_exports = {};
+__export(name_generator_exports, {
+  generateAgentName: () => generateAgentName,
+  generateUniqueAgentName: () => generateUniqueAgentName,
+  isValidAgentName: () => isValidAgentName
+});
+module.exports = __toCommonJS(name_generator_exports);
+const ADJECTIVES = [
+  "Blue",
+  "Green",
+  "Red",
+  "Purple",
+  "Golden",
+  "Silver",
+  "Crystal",
+  "Amber",
+  "Coral",
+  "Jade",
+  "Ruby",
+  "Sapphire",
+  "Emerald",
+  "Onyx",
+  "Pearl",
+  "Copper",
+  "Bronze",
+  "Iron",
+  "Steel",
+  "Velvet",
+  "Silk",
+  "Cotton",
+  "Linen",
+  "Marble",
+  "Granite",
+  "Cobalt",
+  "Crimson",
+  "Azure",
+  "Indigo",
+  "Scarlet",
+  "Violet",
+  "Olive",
+  "Teal",
+  "Cyan",
+  "Magenta",
+  "Ochre",
+  "Rustic",
+  "Misty",
+  "Stormy",
+  "Sunny",
+  "Frosty",
+  "Dusty",
+  "Mossy",
+  "Rocky",
+  "Sandy",
+  "Snowy",
+  "Windy",
+  "Swift",
+  "Calm",
+  "Bold",
+  "Brave",
+  "Clever",
+  "Eager",
+  "Gentle",
+  "Happy",
+  "Jolly",
+  "Kind",
+  "Lively",
+  "Merry",
+  "Noble",
+  "Proud",
+  "Quick",
+  "Quiet"
+];
+const NOUNS = [
+  "Mountain",
+  "River",
+  "Forest",
+  "Ocean",
+  "Valley",
+  "Canyon",
+  "Desert",
+  "Island",
+  "Lake",
+  "Meadow",
+  "Prairie",
+  "Glacier",
+  "Volcano",
+  "Waterfall",
+  "Creek",
+  "Pond",
+  "Hill",
+  "Peak",
+  "Ridge",
+  "Cliff",
+  "Cave",
+  "Reef",
+  "Marsh",
+  "Grove",
+  "Fox",
+  "Wolf",
+  "Bear",
+  "Eagle",
+  "Hawk",
+  "Owl",
+  "Deer",
+  "Elk",
+  "Falcon",
+  "Raven",
+  "Swan",
+  "Crane",
+  "Heron",
+  "Otter",
+  "Beaver",
+  "Badger",
+  "Castle",
+  "Tower",
+  "Bridge",
+  "Harbor",
+  "Haven",
+  "Shelter",
+  "Beacon",
+  "Anchor",
+  "Stone",
+  "Pebble",
+  "Boulder",
+  "Crystal",
+  "Gem",
+  "Prism",
+  "Spark",
+  "Ember",
+  "Star",
+  "Moon",
+  "Sun",
+  "Comet",
+  "Cloud",
+  "Storm",
+  "Thunder",
+  "Lightning"
+];
+function generateAgentName() {
+  const adjective = ADJECTIVES[Math.floor(Math.random() * ADJECTIVES.length)];
+  const noun = NOUNS[Math.floor(Math.random() * NOUNS.length)];
+  return `${adjective}${noun}`;
+}
+function generateUniqueAgentName(existingNames, maxAttempts = 100) {
+  for (let i = 0; i < maxAttempts; i++) {
+    const name = generateAgentName();
+    if (!existingNames.has(name)) {
+      return name;
+    }
+  }
+  return `${generateAgentName()}${Math.floor(Math.random() * 1e3)}`;
+}
+function isValidAgentName(name) {
+  return /^[a-zA-Z][a-zA-Z0-9_-]{1,31}$/.test(name);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  generateAgentName,
+  generateUniqueAgentName,
+  isValidAgentName
+});

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}