autohand-cli 0.8.3 → 0.9.1

package/dist/chunk-4LMUDS2K.js

@@ -0,0 +1,124 @@
+// src/permissions/yoloMode.ts
+var DEFAULT_YOLO_FILE_TOOLS = [
+  "read_file",
+  "write_file",
+  "list_dir",
+  "file_search",
+  "grep_search",
+  "move_path",
+  "copy_path",
+  "run_command",
+  "shell"
+];
+function getDefaultYoloPattern() {
+  return "allow:*";
+}
+function normalizeYoloInput(pattern) {
+  if (pattern === void 0 || pattern === false) {
+    return void 0;
+  }
+  if (pattern === true) {
+    return getDefaultYoloPattern();
+  }
+  const trimmed = pattern.trim();
+  return trimmed.length > 0 ? trimmed : getDefaultYoloPattern();
+}
+function parseYoloPattern(pattern) {
+  const trimmed = pattern.trim();
+  if (trimmed.length === 0) {
+    throw new Error("YOLO pattern cannot be empty");
+  }
+  if (trimmed === "true") {
+    return { mode: "allow", tools: ["*"] };
+  }
+  const colonIndex = trimmed.indexOf(":");
+  if (colonIndex === -1) {
+    throw new Error(
+      `Invalid YOLO pattern "${pattern}". Expected format: allow:<tools> or deny:<tools>`
+    );
+  }
+  const mode = trimmed.slice(0, colonIndex).trim().toLowerCase();
+  const toolsPart = trimmed.slice(colonIndex + 1);
+  if (mode !== "allow" && mode !== "deny") {
+    throw new Error(
+      `Invalid YOLO mode "${mode}". Must be "allow" or "deny".`
+    );
+  }
+  const tools = toolsPart.split(",").map((t) => t.trim()).filter((t) => t.length > 0);
+  if (tools.length === 0) {
+    throw new Error("YOLO pattern must specify at least one tool");
+  }
+  return { mode, tools };
+}
+function isToolAllowedByYolo(toolName, pattern) {
+  const isWildcard = pattern.tools.includes("*");
+  const isListed = pattern.tools.includes(toolName);
+  if (pattern.mode === "allow") {
+    return isWildcard || isListed;
+  }
+  if (isWildcard) {
+    return false;
+  }
+  return !isListed;
+}
+function buildPermissionSettingsFromYolo(pattern) {
+  if (pattern.mode === "allow" && pattern.tools.includes("*")) {
+    return { mode: "unrestricted" };
+  }
+  if (pattern.mode === "allow") {
+    const allowPatterns = pattern.tools.map((tool) => ({ kind: tool }));
+    const pathAffectingTools = /* @__PURE__ */ new Set(["read_file", "write_file", "multi_file_edit", "move_path", "copy_path"]);
+    const defaultTools = new Set(DEFAULT_YOLO_FILE_TOOLS);
+    const patternPathTools = pattern.tools.filter((tool) => pathAffectingTools.has(tool));
+    const allPathToolsAreDefault = patternPathTools.every((tool) => defaultTools.has(tool));
+    return {
+      allowPatterns,
+      allPathsAllowed: allPathToolsAreDefault
+    };
+  }
+  return {
+    denyPatterns: pattern.tools.map((tool) => ({ kind: tool }))
+  };
+}
+var YoloTimer = class {
+  startTime;
+  durationMs;
+  constructor(timeoutSeconds) {
+    this.startTime = Date.now();
+    this.durationMs = timeoutSeconds * 1e3;
+  }
+  /** Whether the timer is still active (within the timeout window). */
+  isActive() {
+    if (this.durationMs <= 0) {
+      return false;
+    }
+    return Date.now() - this.startTime < this.durationMs;
+  }
+  /** Seconds remaining before the timer expires (minimum 0). */
+  remainingSeconds() {
+    if (this.durationMs <= 0) {
+      return 0;
+    }
+    const elapsed = Date.now() - this.startTime;
+    const remaining = Math.max(0, this.durationMs - elapsed);
+    return Math.ceil(remaining / 1e3);
+  }
+};
+
+export {
+  getDefaultYoloPattern,
+  normalizeYoloInput,
+  parseYoloPattern,
+  isToolAllowedByYolo,
+  buildPermissionSettingsFromYolo,
+  YoloTimer
+};
+/**
+ * YOLO Mode - Granular Auto-Approve with Timeout
+ *
+ * Provides pattern-based tool allow/deny and time-bounded auto-approve.
+ *
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/{chunk-W7RYQJLO.cjs → chunk-4XFHP2SN.cjs}

@@ -1,30 +1,40 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 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 _chunkRKJTGGMUcjs = require('./chunk-RKJTGGMU.cjs');
+var _chunkWKRDBCP2cjs = require('./chunk-WKRDBCP2.cjs');
 
 
 
-var _chunkZYQMLKOKcjs = require('./chunk-ZYQMLKOK.cjs');
+var _chunkCK4HAHVYcjs = require('./chunk-CK4HAHVY.cjs');
 
 
-var _chunkCB4E2T5Ncjs = require('./chunk-CB4E2T5N.cjs');
+var _chunkX5P6QQOBcjs = require('./chunk-X5P6QQOB.cjs');
 
 // src/commands/search.ts
 var _chalk = require('chalk'); var _chalk2 = _interopRequireDefault(_chalk);
 async function search(ctx) {
-  const currentConfig = _chunkRKJTGGMUcjs.getSearchConfig.call(void 0, );
+  const currentConfig = _chunkWKRDBCP2cjs.getSearchConfig.call(void 0, );
   const config = ctx.config;
   console.log(_chalk2.default.bold("\nWeb Search Configuration\n"));
   console.log(_chalk2.default.gray(`Current provider: ${_chalk2.default.cyan(currentConfig.provider)}`));
   const braveKeySet = !!(currentConfig.braveApiKey || process.env.BRAVE_SEARCH_API_KEY);
   const parallelKeySet = !!(currentConfig.parallelApiKey || process.env.PARALLEL_API_KEY);
+  const exaKeySet = !!(currentConfig.exaApiKey || process.env.EXA_API_KEY);
   console.log(_chalk2.default.gray(`Brave API key: ${braveKeySet ? _chalk2.default.green("configured") : _chalk2.default.yellow("not set")}`));
   console.log(_chalk2.default.gray(`Parallel API key: ${parallelKeySet ? _chalk2.default.green("configured") : _chalk2.default.yellow("not set")}`));
+  console.log(_chalk2.default.gray(`Exa API key: ${exaKeySet ? _chalk2.default.green("configured") : _chalk2.default.yellow("not set")}`));
   console.log();
   const providerOptions = [
     {
-      label: `Google ${_chalk2.default.gray("(no API key required, recommended default)")}`,
+      label: `Browser Profile ${_chalk2.default.gray("(uses your Chrome/Brave cookies - no API key)")}`,
+      value: "browser-profile"
+    },
+    {
+      label: `Exa.ai ${_chalk2.default.gray("(requires API key)")} ${exaKeySet ? _chalk2.default.green("\u2713") : ""}`,
+      value: "exa"
+    },
+    {
+      label: `Google ${_chalk2.default.gray("(no API key required)")}`,
       value: "google"
     },
     {
@@ -41,7 +51,7 @@ async function search(ctx) {
     }
   ];
   try {
-    const result = await _chunkZYQMLKOKcjs.showModal.call(void 0, {
+    const result = await _chunkCK4HAHVYcjs.showModal.call(void 0, {
       title: "Select search provider:",
       options: providerOptions,
       initialIndex: providerOptions.findIndex((c) => c.value === currentConfig.provider)
@@ -53,12 +63,25 @@ async function search(ctx) {
     const provider = result.value;
     let braveApiKey = currentConfig.braveApiKey;
     let parallelApiKey = currentConfig.parallelApiKey;
+    let exaApiKey = currentConfig.exaApiKey;
+    if (provider === "exa" && !exaKeySet) {
+      console.log(_chalk2.default.gray("\nGet your Exa.ai API key at: https://exa.ai\n"));
+      const apiKey = await _chunkCK4HAHVYcjs.showPassword.call(void 0, {
+        title: "Enter Exa.ai API key:"
+      });
+      if (_optionalChain([apiKey, 'optionalAccess', _ => _.trim, 'call', _2 => _2()])) {
+        exaApiKey = apiKey.trim();
+      } else {
+        console.log(_chalk2.default.yellow("No API key entered. Exa.ai Search will not work without an API key."));
+        return null;
+      }
+    }
     if (provider === "brave" && !braveKeySet) {
       console.log(_chalk2.default.gray("\nGet your free Brave Search API key at: https://brave.com/search/api/\n"));
-      const apiKey = await _chunkZYQMLKOKcjs.showPassword.call(void 0, {
+      const apiKey = await _chunkCK4HAHVYcjs.showPassword.call(void 0, {
         title: "Enter Brave Search API key:"
       });
-      if (_optionalChain([apiKey, 'optionalAccess', _ => _.trim, 'call', _2 => _2()])) {
+      if (_optionalChain([apiKey, 'optionalAccess', _3 => _3.trim, 'call', _4 => _4()])) {
         braveApiKey = apiKey.trim();
       } else {
         console.log(_chalk2.default.yellow("No API key entered. Brave Search will not work without an API key."));
@@ -67,28 +90,30 @@ async function search(ctx) {
     }
     if (provider === "parallel" && !parallelKeySet) {
       console.log(_chalk2.default.gray("\nGet your Parallel.ai API key at: https://platform.parallel.ai\n"));
-      const apiKey = await _chunkZYQMLKOKcjs.showPassword.call(void 0, {
+      const apiKey = await _chunkCK4HAHVYcjs.showPassword.call(void 0, {
         title: "Enter Parallel.ai API key:"
       });
-      if (_optionalChain([apiKey, 'optionalAccess', _3 => _3.trim, 'call', _4 => _4()])) {
+      if (_optionalChain([apiKey, 'optionalAccess', _5 => _5.trim, 'call', _6 => _6()])) {
         parallelApiKey = apiKey.trim();
       } else {
         console.log(_chalk2.default.yellow("No API key entered. Parallel.ai Search will not work without an API key."));
         return null;
       }
     }
-    _chunkRKJTGGMUcjs.configureSearch.call(void 0, {
+    _chunkWKRDBCP2cjs.configureSearch.call(void 0, {
       provider,
       braveApiKey,
-      parallelApiKey
+      parallelApiKey,
+      exaApiKey
     });
     if (config) {
       config.search = {
         provider,
         braveApiKey,
-        parallelApiKey
+        parallelApiKey,
+        exaApiKey
       };
-      await _chunkCB4E2T5Ncjs.saveConfig.call(void 0, config);
+      await _chunkX5P6QQOBcjs.saveConfig.call(void 0, config);
       console.log(_chalk2.default.green(`
 \u2713 Search provider set to ${provider} and saved to config`));
     } else {
@@ -96,6 +121,12 @@ async function search(ctx) {
 \u2713 Search provider set to ${provider} (session only)`));
     }
     switch (provider) {
+      case "browser-profile":
+        console.log(_chalk2.default.gray("Browser Profile Search is now active. Uses your Chrome/Brave cookies for better results."));
+        break;
+      case "exa":
+        console.log(_chalk2.default.gray("Exa.ai Search is now active with neural search capabilities."));
+        break;
       case "google":
         console.log(_chalk2.default.gray("Google Search is now active. No API key required."));
         break;
@@ -116,7 +147,7 @@ async function search(ctx) {
 }
 var metadata = {
   command: "/search",
-  description: "configure web search provider (google, brave, duckduckgo, parallel)",
+  description: "configure web search provider (browser-profile, exa, google, brave, duckduckgo, parallel)",
   implemented: true
 };
 

package/dist/chunk-4XVLNOFA.js

@@ -0,0 +1,360 @@
+import {
+  getAssistantChatLogContent
+} from "./chunk-RS2E32YB.js";
+import {
+  package_default
+} from "./chunk-JB3JCYBJ.js";
+import {
+  AUTOHAND_FILES
+} from "./chunk-SHRLFX6F.js";
+
+// src/commands/go.ts
+import os from "os";
+import chalk from "chalk";
+import QRCode from "qrcode";
+import terminalLink from "terminal-link";
+
+// src/mobile/MobileHandoffClient.ts
+import crypto from "crypto";
+import fs from "fs-extra";
+import path from "path";
+var DEFAULT_API_BASE_URL = "https://api.autohand.ai";
+var DEFAULT_TIMEOUT_MS = 1e4;
+function getMobileApiBaseUrl(config) {
+  return (config?.api?.baseUrl || process.env.AUTOHAND_API_URL || DEFAULT_API_BASE_URL).replace(/\/+$/, "");
+}
+var MobileHandoffClient = class {
+  baseUrl;
+  timeoutMs;
+  constructor(config = {}) {
+    this.baseUrl = (config.baseUrl || DEFAULT_API_BASE_URL).replace(/\/+$/, "");
+    this.timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  }
+  async getDeviceId() {
+    try {
+      await fs.ensureDir(path.dirname(AUTOHAND_FILES.deviceId));
+      if (await fs.pathExists(AUTOHAND_FILES.deviceId)) {
+        const existing = (await fs.readFile(AUTOHAND_FILES.deviceId, "utf8")).trim();
+        if (existing) return existing;
+      }
+      const next = crypto.randomUUID();
+      await fs.writeFile(AUTOHAND_FILES.deviceId, next);
+      return next;
+    } catch {
+      return crypto.randomUUID();
+    }
+  }
+  async registerDevice(token, payload) {
+    await this.request("/v1/devices/register", token, {
+      method: "POST",
+      body: JSON.stringify({
+        deviceId: payload.deviceId,
+        clientType: payload.clientType ?? "cli",
+        agentName: payload.agentName,
+        metadata: payload.metadata
+      }),
+      headers: {
+        "X-Device-ID": payload.deviceId
+      }
+    });
+  }
+  async createPairing(token, payload) {
+    const data = await this.request(
+      "/v1/mobile/pairings",
+      token,
+      {
+        method: "POST",
+        body: JSON.stringify(payload),
+        headers: {
+          "X-CLI-Version": package_default.version,
+          "X-Device-ID": payload.deviceId
+        }
+      }
+    );
+    if (data.success !== true || !data.pairing?.pairingUrl) {
+      throw new Error(data.error || "Invalid mobile pairing response");
+    }
+    return data.pairing;
+  }
+  async sendRelayHeartbeat(token, payload) {
+    await this.request(`/v1/mobile/sessions/${encodeURIComponent(payload.sessionId)}/heartbeat`, token, {
+      method: "POST",
+      body: JSON.stringify({
+        deviceId: payload.deviceId,
+        pairingId: payload.pairingId,
+        mode: payload.mode
+      }),
+      headers: {
+        "X-Device-ID": payload.deviceId
+      }
+    });
+  }
+  async claimWork(token, deviceId) {
+    const data = await this.request(
+      "/v1/work/claim",
+      token,
+      {
+        method: "POST",
+        body: JSON.stringify({ deviceId }),
+        headers: {
+          "X-Device-ID": deviceId
+        },
+        allowNotFound: true
+      }
+    );
+    if (data.success === false && data.error === "No work available") {
+      return null;
+    }
+    if (!data.success || !data.work) {
+      throw new Error(data.error || "Invalid work claim response");
+    }
+    return data.work;
+  }
+  async request(path2, token, options) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      const response = await fetch(`${this.baseUrl}${path2}`, {
+        method: options.method,
+        headers: {
+          Authorization: `Bearer ${token}`,
+          "Content-Type": "application/json",
+          ...options.headers
+        },
+        body: options.body,
+        signal: controller.signal
+      });
+      if (options.allowNotFound && response.status === 404) {
+        const data = await response.json().catch(() => ({ success: false, error: "No work available" }));
+        return data;
+      }
+      if (!response.ok) {
+        const text = await response.text().catch(() => "Unknown error");
+        throw new Error(`API error: ${response.status} ${text}`);
+      }
+      return await response.json();
+    } catch (error) {
+      if (error.name === "AbortError") {
+        throw new Error("Request timeout");
+      }
+      throw error;
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+};
+
+// src/mobile/MobileRelay.ts
+var activeRelay = null;
+function startMobileRelay(options) {
+  stopMobileRelay();
+  activeRelay = {
+    deviceId: options.deviceId,
+    timer: setInterval(() => {
+      void pollOnce(options);
+    }, Math.max(options.pollIntervalMs, 1e3)),
+    polling: false
+  };
+  activeRelay.timer.unref?.();
+  void pollOnce(options);
+}
+function stopMobileRelay() {
+  if (!activeRelay) return;
+  clearInterval(activeRelay.timer);
+  activeRelay = null;
+}
+async function pollOnce(options) {
+  if (!activeRelay || activeRelay.deviceId !== options.deviceId || activeRelay.polling) {
+    return;
+  }
+  activeRelay.polling = true;
+  try {
+    try {
+      await options.client.sendRelayHeartbeat(options.token, {
+        sessionId: options.sessionId,
+        deviceId: options.deviceId,
+        pairingId: options.pairingId,
+        mode: options.mode
+      });
+    } catch (error) {
+      options.onError?.(error);
+    }
+    const work = await options.client.claimWork(options.token, options.deviceId);
+    if (work?.prompt) {
+      options.enqueueInstruction(work.prompt);
+    }
+  } catch (error) {
+    options.onError?.(error);
+  } finally {
+    if (activeRelay?.deviceId === options.deviceId) {
+      activeRelay.polling = false;
+    }
+  }
+}
+
+// src/commands/go.ts
+var metadata = {
+  command: "/go",
+  description: "pair this session with the Autohand Code iOS app",
+  implemented: true
+};
+var MAX_MOBILE_SNAPSHOT_MESSAGES = 24;
+function formatUrl(url) {
+  return terminalLink.isSupported ? terminalLink(url, url) : chalk.cyan.underline(url);
+}
+function formatExpiry(value) {
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) return value;
+  return date.toLocaleString();
+}
+function nativeAppUrl(pairingUrl) {
+  const url = new URL(pairingUrl);
+  const nativeUrl = new URL("autohand-code://go");
+  const pairingId = url.searchParams.get("pairing");
+  const token = url.searchParams.get("token");
+  if (pairingId) nativeUrl.searchParams.set("pairing", pairingId);
+  if (token) nativeUrl.searchParams.set("token", token);
+  return nativeUrl.toString();
+}
+function buildMobileSessionSnapshot(session) {
+  const messages = [];
+  for (const message of session.getMessages()) {
+    if (message.role === "user") {
+      const content = message.content.trim();
+      if (content) {
+        messages.push({ role: "user", content, timestamp: message.timestamp });
+      }
+      continue;
+    }
+    if (message.role === "assistant") {
+      const content = getAssistantChatLogContent(message.content);
+      if (content) {
+        messages.push({ role: "assistant", content, timestamp: message.timestamp });
+      }
+    }
+  }
+  const recentMessages = messages.slice(-MAX_MOBILE_SNAPSHOT_MESSAGES);
+  const firstUserMessage = messages.find((message) => message.role === "user");
+  const title = firstUserMessage?.content ? firstUserMessage.content.replace(/\s+/g, " ").slice(0, 80) : `Continue ${session.metadata.projectName}`;
+  return {
+    title,
+    summary: session.metadata.summary,
+    messageCount: session.metadata.messageCount,
+    lastActivity: session.metadata.lastActiveAt,
+    messages: recentMessages
+  };
+}
+function parseMode(args, canSteer) {
+  if (args.includes("--queue")) return "queue";
+  if (args.includes("--steer")) return "steer";
+  return canSteer ? "steer" : "queue";
+}
+async function go(ctx, args = []) {
+  const mode = parseMode(args, Boolean(ctx.enqueueInstruction));
+  if (mode === "steer" && !ctx.enqueueInstruction) {
+    return [
+      chalk.yellow("Steer mode requires an interactive CLI session."),
+      chalk.gray("Run /go --queue to create a durable queue-only handoff from this mode.")
+    ].join("\n");
+  }
+  const token = ctx.config?.auth?.token;
+  if (!token) {
+    return [
+      chalk.yellow("Sign in first with /login."),
+      chalk.gray("Then run /go again to pair this laptop session with your phone.")
+    ].join("\n");
+  }
+  const session = ctx.currentSession ?? ctx.sessionManager.getCurrentSession();
+  if (!session) {
+    return [
+      chalk.yellow("No active session to pair."),
+      chalk.gray("Start a conversation, then run /go from the project you want to control remotely.")
+    ].join("\n");
+  }
+  const client = ctx.client ?? new MobileHandoffClient({
+    baseUrl: getMobileApiBaseUrl(ctx.config)
+  });
+  try {
+    const deviceId = await client.getDeviceId();
+    await client.registerDevice(token, {
+      deviceId,
+      clientType: "cli",
+      agentName: `${os.hostname()} Autohand Code`,
+      metadata: {
+        workspacePath: ctx.workspaceRoot,
+        projectName: session.metadata.projectName,
+        sessionId: session.metadata.sessionId,
+        model: ctx.model,
+        provider: ctx.provider,
+        platform: process.platform,
+        hostname: os.hostname(),
+        client: session.metadata.client,
+        clientVersion: session.metadata.clientVersion
+      }
+    });
+    const pairing = await client.createPairing(token, {
+      deviceId,
+      sessionId: session.metadata.sessionId,
+      workspacePath: ctx.workspaceRoot,
+      projectName: session.metadata.projectName,
+      model: ctx.model,
+      provider: ctx.provider,
+      capabilities: ["prompt", "approval", "notifications"],
+      metadata: {
+        platform: process.platform,
+        hostname: os.hostname(),
+        client: session.metadata.client,
+        clientVersion: session.metadata.clientVersion,
+        sessionSnapshot: JSON.stringify(buildMobileSessionSnapshot(session))
+      }
+    });
+    if (mode === "steer" && ctx.enqueueInstruction) {
+      startMobileRelay({
+        client,
+        token,
+        deviceId,
+        sessionId: session.metadata.sessionId,
+        pairingId: pairing.id,
+        mode,
+        pollIntervalMs: pairing.pollIntervalMs,
+        enqueueInstruction: ctx.enqueueInstruction
+      });
+    }
+    const appUrl = nativeAppUrl(pairing.pairingUrl);
+    const qr = await QRCode.toString(pairing.pairingUrl, {
+      type: "utf8",
+      errorCorrectionLevel: "M"
+    });
+    return [
+      "",
+      chalk.bold("Autohand Code mobile handoff"),
+      chalk.gray("Scan this with the iOS app to continue this session from your phone."),
+      "",
+      qr,
+      "",
+      `${chalk.gray("Scan or open:")} ${formatUrl(pairing.pairingUrl)}`,
+      `${chalk.gray("Simulator fallback:")} ${formatUrl(appUrl)}`,
+      `${chalk.gray("Project:")} ${chalk.cyan(session.metadata.projectName)}`,
+      `${chalk.gray("Session:")} ${chalk.cyan(session.metadata.sessionId)}`,
+      `${chalk.gray("Mode:")} ${mode === "steer" ? chalk.green("steer live") : chalk.yellow("queue")}`,
+      `${chalk.gray("Relay:")} ${mode === "steer" ? chalk.green("listening for mobile prompts") : chalk.yellow("prompts will wait in the queue")}`,
+      `${chalk.gray("Expires:")} ${chalk.cyan(formatExpiry(pairing.expiresAt))}`,
+      ""
+    ].join("\n");
+  } catch (error) {
+    return [
+      chalk.red("Could not create mobile handoff."),
+      chalk.gray(error.message)
+    ].join("\n");
+  }
+}
+
+export {
+  metadata,
+  go
+};
+/**
+ * @license
+ * Copyright 2026 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/{chunk-GBHDROGL.js → chunk-575PXZX7.js}

@@ -1,6 +1,6 @@
 import {
   AUTOHAND_PATHS
-} from "./chunk-EGFT4PGW.js";
+} from "./chunk-SHRLFX6F.js";
 
 // src/core/agents/AgentRegistry.ts
 import fs from "fs/promises";
@@ -50,9 +50,11 @@ function parseMarkdownAgent(content) {
   };
 }
 var AgentRegistry = class _AgentRegistry {
+  static instance;
+  agents = /* @__PURE__ */ new Map();
+  agentsDir;
+  externalPaths = [];
   constructor() {
-    this.agents = /* @__PURE__ */ new Map();
-    this.externalPaths = [];
     this.agentsDir = AUTOHAND_PATHS.agents;
   }
   static getInstance() {
@@ -70,6 +72,16 @@ var AgentRegistry = class _AgentRegistry {
       (p) => p.startsWith("~") ? path.join(os.homedir(), p.slice(1)) : p
     );
   }
+  /**
+   * Apply external agent settings from the loaded Autohand config.
+   */
+  configureExternalAgents(config) {
+    if (config?.enabled !== true) {
+      this.setExternalPaths([]);
+      return;
+    }
+    this.setExternalPaths(config.paths ?? []);
+  }
   /**
    * Get configured external paths
    */
@@ -159,7 +171,7 @@ var AgentRegistry = class _AgentRegistry {
         source,
         description: parsed.description || `Agent ${name}`,
         systemPrompt: parsed.systemPrompt,
-        tools: parsed.tools,
+        tools: parsed.tools.length > 0 ? parsed.tools : ["*"],
         model: parsed.model
       };
       if (!this.agents.has(name)) {