autohand-cli 0.7.14 → 0.8.0

package/dist/{chunk-VHBUKGRG.js → chunk-WJDPVW7T.js}

@@ -1,15 +1,15 @@
 import {
   getAuthClient
-} from "./chunk-D2XFTCRP.js";
+} from "./chunk-HQ7YZKXE.js";
 import {
   safePrompt
-} from "./chunk-YHGTBPEC.js";
+} from "./chunk-VNQ5GL34.js";
 import {
   saveConfig
-} from "./chunk-ZBIBLOZL.js";
+} from "./chunk-WTNBX2JO.js";
 import {
   t
-} from "./chunk-NMWEDN4Z.js";
+} from "./chunk-HFMLWH7B.js";
 
 // src/commands/logout.ts
 import chalk from "chalk";

package/dist/chunk-WNUVPKBW.js

@@ -0,0 +1,42 @@
+// src/commands/message.ts
+import chalk from "chalk";
+var metadata = {
+  command: "/message",
+  description: "Send a direct message to a teammate",
+  implemented: true
+};
+async function message(ctx, args) {
+  if (!ctx.teamManager) {
+    return chalk.yellow("Team manager not available.");
+  }
+  const team = ctx.teamManager.getTeam();
+  if (!team) {
+    return chalk.yellow("No active team.");
+  }
+  if (args.length < 2) {
+    return [
+      chalk.bold("Usage:"),
+      `  ${chalk.cyan("/message <name> <text>")}`,
+      "",
+      chalk.gray("Example: /message hunter also check src/legacy/")
+    ].join("\n");
+  }
+  const [targetName, ...rest] = args;
+  const content = rest.join(" ");
+  try {
+    ctx.teamManager.sendMessageTo(targetName, "lead", content);
+    return chalk.green(`Message sent to ${targetName}.`);
+  } catch (err) {
+    return chalk.red(err.message);
+  }
+}
+
+export {
+  metadata,
+  message
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/{chunk-EV53SLSB.cjs → chunk-WPVWQSL7.cjs}

@@ -1,7 +1,7 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
 
 
-var _chunkGIZL57FEcjs = require('./chunk-GIZL57FE.cjs');
+var _chunkSEKD5FH3cjs = require('./chunk-SEKD5FH3.cjs');
 
 // src/memory/MemoryManager.ts
 var _fsextra = require('fs-extra'); var _fsextra2 = _interopRequireDefault(_fsextra);
@@ -11,13 +11,13 @@ var SIMILARITY_THRESHOLD = 0.6;
 var MemoryManager = class {
   constructor(workspaceRoot) {
     this.projectMemoryDir = null;
-    this.userMemoryDir = _chunkGIZL57FEcjs.AUTOHAND_PATHS.memory;
+    this.userMemoryDir = _chunkSEKD5FH3cjs.AUTOHAND_PATHS.memory;
     if (workspaceRoot) {
-      this.projectMemoryDir = _path2.default.join(workspaceRoot, _chunkGIZL57FEcjs.PROJECT_DIR_NAME, "memory");
+      this.projectMemoryDir = _path2.default.join(workspaceRoot, _chunkSEKD5FH3cjs.PROJECT_DIR_NAME, "memory");
     }
   }
   setWorkspace(workspaceRoot) {
-    this.projectMemoryDir = _path2.default.join(workspaceRoot, _chunkGIZL57FEcjs.PROJECT_DIR_NAME, "memory");
+    this.projectMemoryDir = _path2.default.join(workspaceRoot, _chunkSEKD5FH3cjs.PROJECT_DIR_NAME, "memory");
   }
   async initialize() {
     await _fsextra2.default.ensureDir(this.userMemoryDir);

package/dist/chunk-WQ3VJXZB.js

@@ -0,0 +1,118 @@
+// src/mcp/commandNormalization.ts
+import os from "os";
+import path from "path";
+function isNpxCommand(command) {
+  const normalized = command.trim().toLowerCase();
+  return normalized === "npx" || normalized === "npx.cmd" || normalized.endsWith("/npx") || normalized.endsWith("\\npx") || normalized.endsWith("/npx.cmd") || normalized.endsWith("\\npx.cmd");
+}
+function hasNpxYesFlag(args) {
+  if (!args) return false;
+  return args.some((arg) => arg === "-y" || arg === "--yes");
+}
+function hasFlag(args, flag) {
+  return args.some((arg) => arg === flag || arg.startsWith(`${flag}=`));
+}
+function findNpxCommandIndex(args) {
+  for (let i = 0; i < args.length; i++) {
+    const token = args[i];
+    if (token === "--") {
+      return i + 1 < args.length ? i + 1 : null;
+    }
+    if (!token.startsWith("-") || token === "-") {
+      return i;
+    }
+    const consumesNextValue = token === "-p" || token === "--package" || token === "-c" || token === "--call";
+    if (consumesNextValue) {
+      i++;
+    }
+  }
+  return null;
+}
+function isChromeDevtoolsMcpPackage(spec) {
+  const normalized = spec.toLowerCase();
+  return normalized === "chrome-devtools-mcp" || normalized.startsWith("chrome-devtools-mcp@");
+}
+var CHROME_DEVTOOLS_USAGE_STATS_FLAG = "--no-usage-statistics";
+var CHROME_DEVTOOLS_LEGACY_USAGE_STATS_FLAG = "--no-usage-stats";
+function addKnownNonInteractiveServerFlags(args) {
+  const normalizedArgs = [...args];
+  const commandIndex = findNpxCommandIndex(normalizedArgs);
+  if (commandIndex === null || commandIndex >= normalizedArgs.length) {
+    return normalizedArgs;
+  }
+  const packageSpec = normalizedArgs[commandIndex];
+  if (!isChromeDevtoolsMcpPackage(packageSpec)) {
+    return normalizedArgs;
+  }
+  const hasLegacyFlag = hasFlag(normalizedArgs, CHROME_DEVTOOLS_LEGACY_USAGE_STATS_FLAG);
+  if (hasLegacyFlag) {
+    for (let i = normalizedArgs.length - 1; i >= 0; i--) {
+      if (normalizedArgs[i] === CHROME_DEVTOOLS_LEGACY_USAGE_STATS_FLAG) {
+        normalizedArgs.splice(i, 1);
+      }
+    }
+  }
+  if (!hasFlag(normalizedArgs, CHROME_DEVTOOLS_USAGE_STATS_FLAG)) {
+    normalizedArgs.push(CHROME_DEVTOOLS_USAGE_STATS_FLAG);
+  }
+  return normalizedArgs;
+}
+function sanitizePathSegment(value) {
+  const sanitized = value.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+/, "").replace(/-+$/, "");
+  return sanitized.length > 0 ? sanitized : "server";
+}
+function isRetriableNpxInstallError(message) {
+  const normalized = message.toLowerCase();
+  if (/npm\s+error\s+code\s+enotempty/i.test(message)) {
+    return true;
+  }
+  return normalized.includes("enotempty") && normalized.includes("_npx");
+}
+function buildNpxIsolatedCacheEnv(baseEnv, serverName) {
+  const token = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  const cacheDir = path.join(
+    os.tmpdir(),
+    "autohand-mcp-npx-cache",
+    sanitizePathSegment(serverName),
+    token
+  );
+  const env = {};
+  for (const [key, value] of Object.entries(baseEnv ?? {})) {
+    if (typeof value === "string") {
+      env[key] = value;
+    }
+  }
+  return {
+    ...env,
+    npm_config_cache: cacheDir,
+    NPM_CONFIG_CACHE: cacheDir
+  };
+}
+function normalizeMcpCommandForSpawn(command, args) {
+  if (!isNpxCommand(command)) {
+    return { command, args };
+  }
+  const normalizedArgs = args ? [...args] : [];
+  if (!hasNpxYesFlag(normalizedArgs)) {
+    normalizedArgs.unshift("-y");
+  }
+  const spawnSafeArgs = addKnownNonInteractiveServerFlags(normalizedArgs);
+  return {
+    command,
+    args: spawnSafeArgs.length > 0 ? spawnSafeArgs : void 0
+  };
+}
+function normalizeMcpCommandForConfig(command, args) {
+  if (!command) {
+    return { command, args };
+  }
+  return normalizeMcpCommandForSpawn(command, args);
+}
+
+export {
+  isNpxCommand,
+  isRetriableNpxInstallError,
+  buildNpxIsolatedCacheEnv,
+  normalizeMcpCommandForSpawn,
+  normalizeMcpCommandForConfig
+};

package/dist/chunk-WTNBX2JO.js

@@ -0,0 +1,271 @@
+import {
+  autoInitTheme,
+  themeExists
+} from "./chunk-IVM5F2AE.js";
+import {
+  AUTOHAND_FILES
+} from "./chunk-EGFT4PGW.js";
+
+// src/config.ts
+import fs from "fs-extra";
+import path from "path";
+import YAML from "yaml";
+var DEFAULT_CONFIG_PATH = AUTOHAND_FILES.configJson;
+var YAML_CONFIG_PATH = AUTOHAND_FILES.configYaml;
+var YML_CONFIG_PATH = AUTOHAND_FILES.configYml;
+var DEFAULT_BASE_URL = "https://openrouter.ai/api/v1";
+var DEFAULT_OLLAMA_URL = "http://localhost:11434";
+var DEFAULT_LLAMACPP_URL = "http://localhost:8080";
+var DEFAULT_OPENAI_URL = "https://api.openai.com/v1";
+var DEFAULT_MLX_URL = "http://localhost:8080";
+var DEFAULT_LLMGATEWAY_URL = "https://api.llmgateway.io/v1";
+function getDefaultConfigPath() {
+  return DEFAULT_CONFIG_PATH;
+}
+async function detectConfigPath(customPath) {
+  if (customPath) {
+    return path.resolve(customPath);
+  }
+  const envPath = process.env.AUTOHAND_CONFIG;
+  if (envPath) {
+    return path.resolve(envPath);
+  }
+  if (await fs.pathExists(YAML_CONFIG_PATH)) {
+    return YAML_CONFIG_PATH;
+  }
+  if (await fs.pathExists(YML_CONFIG_PATH)) {
+    return YML_CONFIG_PATH;
+  }
+  return DEFAULT_CONFIG_PATH;
+}
+function isYamlFile(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  return ext === ".yaml" || ext === ".yml";
+}
+async function parseConfigFile(configPath) {
+  const content = await fs.readFile(configPath, "utf8");
+  if (isYamlFile(configPath)) {
+    return YAML.parse(content);
+  }
+  return JSON.parse(content);
+}
+async function loadConfig(customPath) {
+  const configPath = await detectConfigPath(customPath);
+  await fs.ensureDir(path.dirname(configPath));
+  let isNewConfig = false;
+  if (!await fs.pathExists(configPath)) {
+    const defaultConfig = {
+      provider: "openrouter",
+      openrouter: {
+        apiKey: "",
+        baseUrl: "https://openrouter.ai/api/v1",
+        model: "anthropic/claude-sonnet-4-20250514"
+      },
+      workspace: {
+        defaultRoot: process.cwd(),
+        allowDangerousOps: false
+      },
+      ui: {
+        theme: "dark",
+        autoConfirm: false,
+        promptSuggestions: true
+      },
+      telemetry: {
+        enabled: false
+      },
+      autoReport: {
+        enabled: true
+      }
+    };
+    await fs.writeJson(configPath, defaultConfig, { spaces: 2 });
+    isNewConfig = true;
+  }
+  let parsed;
+  try {
+    parsed = await parseConfigFile(configPath);
+  } catch (error) {
+    throw new Error(`Failed to parse config at ${configPath}: ${error.message}`);
+  }
+  const normalized = normalizeConfig(parsed);
+  const withEnv = mergeEnvVariables(normalized);
+  validateConfig(withEnv, configPath);
+  const themeName = withEnv.ui?.theme || "dark";
+  autoInitTheme(themeName);
+  return { ...withEnv, configPath, isNewConfig };
+}
+function mergeEnvVariables(config) {
+  return {
+    ...config,
+    api: {
+      baseUrl: process.env.AUTOHAND_API_URL || config.api?.baseUrl || "https://api.autohand.ai",
+      companySecret: process.env.AUTOHAND_SECRET || config.api?.companySecret || ""
+    }
+  };
+}
+function normalizeConfig(config) {
+  if (isModernConfig(config)) {
+    const provider = config.provider ?? "openrouter";
+    return { provider, ...config };
+  }
+  if (isLegacyConfig(config)) {
+    return {
+      provider: "openrouter",
+      openrouter: {
+        apiKey: config.api_key ?? "replace-me",
+        baseUrl: config.base_url ?? DEFAULT_BASE_URL,
+        model: config.model ?? "anthropic/claude-3.5-sonnet"
+      },
+      workspace: {
+        defaultRoot: process.cwd(),
+        allowDangerousOps: false
+      },
+      ui: {
+        autoConfirm: config.dry_run ?? false,
+        theme: "dark",
+        promptSuggestions: true
+      }
+    };
+  }
+  return config;
+}
+function isModernConfig(config) {
+  return typeof config.openrouter === "object" || typeof config.ollama === "object" || typeof config.llamacpp === "object" || typeof config.openai === "object" || typeof config.mlx === "object";
+}
+function isLegacyConfig(config) {
+  return typeof config.api_key === "string";
+}
+function validateConfig(config, configPath) {
+  if (config.workspace) {
+    if (config.workspace.defaultRoot && typeof config.workspace.defaultRoot !== "string") {
+      throw new Error(`workspace.defaultRoot must be a string in ${configPath}`);
+    }
+    if (config.workspace.allowDangerousOps !== void 0 && typeof config.workspace.allowDangerousOps !== "boolean") {
+      throw new Error(`workspace.allowDangerousOps must be boolean in ${configPath}`);
+    }
+  }
+  if (config.ui) {
+    if (config.ui.theme && typeof config.ui.theme !== "string") {
+      throw new Error(`ui.theme must be a string in ${configPath}`);
+    }
+    if (config.ui.theme && typeof config.ui.theme === "string" && !themeExists(config.ui.theme)) {
+      console.warn(`Theme '${config.ui.theme}' not found \u2014 falling back to default.`);
+    }
+    if (config.ui.autoConfirm !== void 0 && typeof config.ui.autoConfirm !== "boolean") {
+      throw new Error(`ui.autoConfirm must be boolean in ${configPath}`);
+    }
+    if (config.ui.promptSuggestions !== void 0 && typeof config.ui.promptSuggestions !== "boolean") {
+      throw new Error(`ui.promptSuggestions must be boolean in ${configPath}`);
+    }
+  }
+  if (config.mcp) {
+    if (config.mcp.enabled !== void 0 && typeof config.mcp.enabled !== "boolean") {
+      throw new Error(`mcp.enabled must be boolean in ${configPath}`);
+    }
+    if (config.mcp.servers !== void 0) {
+      if (!Array.isArray(config.mcp.servers)) {
+        throw new Error(`mcp.servers must be an array in ${configPath}`);
+      }
+      for (const server of config.mcp.servers) {
+        if (!server.name || typeof server.name !== "string") {
+          throw new Error(`mcp.servers[].name must be a non-empty string in ${configPath}`);
+        }
+        if (!["stdio", "sse", "http"].includes(server.transport)) {
+          throw new Error(`mcp.servers[].transport must be 'stdio', 'sse', or 'http' in ${configPath}`);
+        }
+        if (server.transport === "stdio" && (!server.command || typeof server.command !== "string")) {
+          throw new Error(`mcp.servers[].command is required for stdio transport in ${configPath}`);
+        }
+        if ((server.transport === "sse" || server.transport === "http") && (!server.url || typeof server.url !== "string")) {
+          throw new Error(`mcp.servers[].url is required for ${server.transport} transport in ${configPath}`);
+        }
+      }
+    }
+  }
+  if (config.externalAgents) {
+    if (config.externalAgents.enabled !== void 0 && typeof config.externalAgents.enabled !== "boolean") {
+      throw new Error(`externalAgents.enabled must be boolean in ${configPath}`);
+    }
+    if (config.externalAgents.paths !== void 0) {
+      if (!Array.isArray(config.externalAgents.paths)) {
+        throw new Error(`externalAgents.paths must be an array in ${configPath}`);
+      }
+      for (const p of config.externalAgents.paths) {
+        if (typeof p !== "string") {
+          throw new Error(`externalAgents.paths must contain only strings in ${configPath}`);
+        }
+      }
+    }
+  }
+}
+function resolveWorkspaceRoot(config, requestedPath) {
+  const candidate = requestedPath ?? process.cwd() ?? config.workspace?.defaultRoot;
+  return path.resolve(candidate);
+}
+function getProviderConfig(config, provider) {
+  const chosen = provider ?? config.provider ?? "openrouter";
+  const configByProvider = {
+    openrouter: config.openrouter,
+    ollama: config.ollama,
+    llamacpp: config.llamacpp,
+    openai: config.openai,
+    mlx: config.mlx,
+    llmgateway: config.llmgateway
+  };
+  const entry = configByProvider[chosen];
+  if (!entry) {
+    return null;
+  }
+  if (chosen === "openrouter" || chosen === "llmgateway") {
+    const { apiKey, model } = entry;
+    if (!apiKey || apiKey === "replace-me" || !model) {
+      return null;
+    }
+  } else {
+    if (!entry.model) {
+      return null;
+    }
+  }
+  return {
+    ...entry,
+    baseUrl: entry.baseUrl ?? defaultBaseUrlFor(chosen, entry.port)
+  };
+}
+function defaultBaseUrlFor(provider, port) {
+  if (provider === "openrouter") return DEFAULT_BASE_URL;
+  if (provider === "llmgateway") return DEFAULT_LLMGATEWAY_URL;
+  const p = port ? port.toString() : void 0;
+  switch (provider) {
+    case "ollama":
+      return p ? `http://localhost:${p}` : DEFAULT_OLLAMA_URL;
+    case "llamacpp":
+      return p ? `http://localhost:${p}` : DEFAULT_LLAMACPP_URL;
+    case "openai":
+      return DEFAULT_OPENAI_URL;
+    case "mlx":
+      return p ? `http://localhost:${p}` : DEFAULT_MLX_URL;
+    default:
+      return void 0;
+  }
+}
+async function saveConfig(config) {
+  const { configPath, ...data } = config;
+  if (isYamlFile(configPath)) {
+    const yamlContent = YAML.stringify(data, { indent: 2 });
+    await fs.writeFile(configPath, yamlContent, "utf8");
+  } else {
+    await fs.writeJson(configPath, data, { spaces: 2 });
+  }
+}
+
+export {
+  getDefaultConfigPath,
+  loadConfig,
+  resolveWorkspaceRoot,
+  getProviderConfig,
+  saveConfig
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/chunk-XAV24VYN.js

@@ -0,0 +1,48 @@
+// src/core/teams/MessageRouter.ts
+import { createInterface } from "readline";
+var MessageRouter = class _MessageRouter {
+  /**
+   * Encode a message payload into a JSON-RPC 2.0 JSON string.
+   * Always stamps `jsonrpc: "2.0"` onto the output.
+   */
+  static encode(msg) {
+    return JSON.stringify({ jsonrpc: "2.0", ...msg });
+  }
+  /**
+   * Subscribe to incoming JSON-RPC messages from a readable stream.
+   * Each newline-delimited line is parsed; non-JSON lines and messages
+   * without a `method` field are silently ignored (stderr leakage,
+   * debug output, etc.).
+   */
+  onMessage(stream, callback) {
+    const rl = createInterface({ input: stream, crlfDelay: Infinity });
+    rl.on("line", (line) => {
+      const trimmed = line.trim();
+      if (!trimmed) return;
+      try {
+        const parsed = JSON.parse(trimmed);
+        if (parsed.method) {
+          callback(parsed);
+        }
+      } catch {
+      }
+    });
+  }
+  /**
+   * Send a JSON-RPC 2.0 message to a writable stream as a single
+   * newline-terminated line.
+   */
+  send(stream, msg) {
+    const line = _MessageRouter.encode(msg) + "\n";
+    stream.write(line);
+  }
+};
+
+export {
+  MessageRouter
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/chunk-XDLH4EDL.cjs

@@ -0,0 +1,118 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }// src/mcp/commandNormalization.ts
+var _os = require('os'); var _os2 = _interopRequireDefault(_os);
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+function isNpxCommand(command) {
+  const normalized = command.trim().toLowerCase();
+  return normalized === "npx" || normalized === "npx.cmd" || normalized.endsWith("/npx") || normalized.endsWith("\\npx") || normalized.endsWith("/npx.cmd") || normalized.endsWith("\\npx.cmd");
+}
+function hasNpxYesFlag(args) {
+  if (!args) return false;
+  return args.some((arg) => arg === "-y" || arg === "--yes");
+}
+function hasFlag(args, flag) {
+  return args.some((arg) => arg === flag || arg.startsWith(`${flag}=`));
+}
+function findNpxCommandIndex(args) {
+  for (let i = 0; i < args.length; i++) {
+    const token = args[i];
+    if (token === "--") {
+      return i + 1 < args.length ? i + 1 : null;
+    }
+    if (!token.startsWith("-") || token === "-") {
+      return i;
+    }
+    const consumesNextValue = token === "-p" || token === "--package" || token === "-c" || token === "--call";
+    if (consumesNextValue) {
+      i++;
+    }
+  }
+  return null;
+}
+function isChromeDevtoolsMcpPackage(spec) {
+  const normalized = spec.toLowerCase();
+  return normalized === "chrome-devtools-mcp" || normalized.startsWith("chrome-devtools-mcp@");
+}
+var CHROME_DEVTOOLS_USAGE_STATS_FLAG = "--no-usage-statistics";
+var CHROME_DEVTOOLS_LEGACY_USAGE_STATS_FLAG = "--no-usage-stats";
+function addKnownNonInteractiveServerFlags(args) {
+  const normalizedArgs = [...args];
+  const commandIndex = findNpxCommandIndex(normalizedArgs);
+  if (commandIndex === null || commandIndex >= normalizedArgs.length) {
+    return normalizedArgs;
+  }
+  const packageSpec = normalizedArgs[commandIndex];
+  if (!isChromeDevtoolsMcpPackage(packageSpec)) {
+    return normalizedArgs;
+  }
+  const hasLegacyFlag = hasFlag(normalizedArgs, CHROME_DEVTOOLS_LEGACY_USAGE_STATS_FLAG);
+  if (hasLegacyFlag) {
+    for (let i = normalizedArgs.length - 1; i >= 0; i--) {
+      if (normalizedArgs[i] === CHROME_DEVTOOLS_LEGACY_USAGE_STATS_FLAG) {
+        normalizedArgs.splice(i, 1);
+      }
+    }
+  }
+  if (!hasFlag(normalizedArgs, CHROME_DEVTOOLS_USAGE_STATS_FLAG)) {
+    normalizedArgs.push(CHROME_DEVTOOLS_USAGE_STATS_FLAG);
+  }
+  return normalizedArgs;
+}
+function sanitizePathSegment(value) {
+  const sanitized = value.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+/, "").replace(/-+$/, "");
+  return sanitized.length > 0 ? sanitized : "server";
+}
+function isRetriableNpxInstallError(message) {
+  const normalized = message.toLowerCase();
+  if (/npm\s+error\s+code\s+enotempty/i.test(message)) {
+    return true;
+  }
+  return normalized.includes("enotempty") && normalized.includes("_npx");
+}
+function buildNpxIsolatedCacheEnv(baseEnv, serverName) {
+  const token = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  const cacheDir = _path2.default.join(
+    _os2.default.tmpdir(),
+    "autohand-mcp-npx-cache",
+    sanitizePathSegment(serverName),
+    token
+  );
+  const env = {};
+  for (const [key, value] of Object.entries(_nullishCoalesce(baseEnv, () => ( {})))) {
+    if (typeof value === "string") {
+      env[key] = value;
+    }
+  }
+  return {
+    ...env,
+    npm_config_cache: cacheDir,
+    NPM_CONFIG_CACHE: cacheDir
+  };
+}
+function normalizeMcpCommandForSpawn(command, args) {
+  if (!isNpxCommand(command)) {
+    return { command, args };
+  }
+  const normalizedArgs = args ? [...args] : [];
+  if (!hasNpxYesFlag(normalizedArgs)) {
+    normalizedArgs.unshift("-y");
+  }
+  const spawnSafeArgs = addKnownNonInteractiveServerFlags(normalizedArgs);
+  return {
+    command,
+    args: spawnSafeArgs.length > 0 ? spawnSafeArgs : void 0
+  };
+}
+function normalizeMcpCommandForConfig(command, args) {
+  if (!command) {
+    return { command, args };
+  }
+  return normalizeMcpCommandForSpawn(command, args);
+}
+
+
+
+
+
+
+
+exports.isNpxCommand = isNpxCommand; exports.isRetriableNpxInstallError = isRetriableNpxInstallError; exports.buildNpxIsolatedCacheEnv = buildNpxIsolatedCacheEnv; exports.normalizeMcpCommandForSpawn = normalizeMcpCommandForSpawn; exports.normalizeMcpCommandForConfig = normalizeMcpCommandForConfig;

package/dist/{chunk-U7CZFKPL.cjs → chunk-XMNHZRUB.cjs}

@@ -1,6 +1,6 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-var _chunk2U5HFVROcjs = require('./chunk-2U5HFVRO.cjs');
+var _chunkRVUQKMXXcjs = require('./chunk-RVUQKMXX.cjs');
 
 // src/commands/quit.ts
 async function quit() {
@@ -8,7 +8,7 @@ async function quit() {
 }
 var metadata = {
   command: "/quit",
-  description: _chunk2U5HFVROcjs.t.call(void 0, "commands.quit.description"),
+  description: _chunkRVUQKMXXcjs.t.call(void 0, "commands.quit.description"),
   implemented: true
 };