autohand-cli 0.7.9 → 0.7.11

package/dist/mcp-install-KTV52DQK.js

@@ -0,0 +1,473 @@
+import {
+  safePrompt
+} from "./chunk-WD5ZF6HE.js";
+import {
+  saveConfig
+} from "./chunk-ZBIBLOZL.js";
+import "./chunk-JS7IPR7P.js";
+import "./chunk-PNSRJT46.js";
+import "./chunk-NF7RIHJK.js";
+import {
+  AUTOHAND_PATHS
+} from "./chunk-PWLLLJHU.js";
+import "./chunk-UET7BDX2.js";
+
+// src/commands/mcp-install.ts
+import chalk from "chalk";
+
+// src/mcp/McpRegistryFetcher.ts
+var DEFAULT_REPO = "autohandai/community-mcp";
+var DEFAULT_BRANCH = "main";
+var McpRegistryFetcher = class {
+  constructor(config = {}) {
+    const repo = config.repo || DEFAULT_REPO;
+    const branch = config.branch || DEFAULT_BRANCH;
+    this.baseUrl = `https://raw.githubusercontent.com/${repo}/${branch}`;
+    this.timeout = config.timeout || 15e3;
+  }
+  /**
+   * Fetch the registry.json index file
+   */
+  async fetchRegistry() {
+    const url = `${this.baseUrl}/registry.json`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url, {
+        headers: {
+          Accept: "application/json",
+          "User-Agent": "autohand-cli"
+        },
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        throw new Error(`Failed to fetch MCP registry: HTTP ${response.status}`);
+      }
+      const data = await response.json();
+      return this.validateRegistry(data);
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  /**
+   * Fetch a README file for a specific MCP server
+   */
+  async fetchServerReadme(serverDirectory) {
+    const url = `${this.baseUrl}/${serverDirectory}/README.md`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url, {
+        headers: {
+          "User-Agent": "autohand-cli"
+        },
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        throw new Error(`Failed to fetch README: HTTP ${response.status}`);
+      }
+      return response.text();
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  /**
+   * Validate and normalize the registry data
+   */
+  validateRegistry(data) {
+    if (!data || typeof data !== "object") {
+      throw new Error("Invalid MCP registry: expected object");
+    }
+    const registry = data;
+    if (!Array.isArray(registry.servers)) {
+      throw new Error("Invalid MCP registry: missing servers array");
+    }
+    if (!Array.isArray(registry.categories)) {
+      throw new Error("Invalid MCP registry: missing categories array");
+    }
+    const validatedServers = [];
+    for (const server of registry.servers) {
+      if (this.isValidServer(server)) {
+        validatedServers.push(server);
+      }
+    }
+    return {
+      version: String(registry.version || "1.0.0"),
+      updatedAt: String(registry.updatedAt || (/* @__PURE__ */ new Date()).toISOString()),
+      servers: validatedServers,
+      categories: registry.categories
+    };
+  }
+  /**
+   * Type guard for valid MCP server objects
+   */
+  isValidServer(server) {
+    if (!server || typeof server !== "object") return false;
+    const s = server;
+    return typeof s.id === "string" && typeof s.name === "string" && typeof s.description === "string" && typeof s.directory === "string" && (s.transport === "stdio" || s.transport === "sse");
+  }
+  /**
+   * Search servers by query (client-side filtering)
+   */
+  filterServers(servers, query) {
+    if (!query.trim()) return servers;
+    const lowerQuery = query.toLowerCase();
+    return servers.filter((server) => {
+      const searchText = [
+        server.name,
+        server.description,
+        server.category,
+        ...server.tags || []
+      ].join(" ").toLowerCase();
+      return searchText.includes(lowerQuery);
+    });
+  }
+  /**
+   * Get servers by category
+   */
+  getServersByCategory(servers, categoryId) {
+    return servers.filter((server) => server.category === categoryId);
+  }
+  /**
+   * Get featured servers
+   */
+  getFeaturedServers(servers) {
+    return servers.filter((server) => server.isFeatured);
+  }
+  /**
+   * Find a server by name or ID
+   */
+  findServer(servers, nameOrId) {
+    const lower = nameOrId.toLowerCase();
+    return servers.find(
+      (s) => s.id.toLowerCase() === lower || s.name.toLowerCase() === lower
+    ) || null;
+  }
+  /**
+   * Find similar servers based on simple string matching
+   */
+  findSimilarServers(servers, query, limit = 5) {
+    const lower = query.toLowerCase();
+    const scored = servers.map((server) => {
+      let score = 0;
+      if (server.name.toLowerCase().includes(lower)) score += 10;
+      if (server.description.toLowerCase().includes(lower)) score += 5;
+      if (server.tags?.some((t) => t.toLowerCase().includes(lower))) score += 3;
+      return { server, score };
+    });
+    return scored.filter((s) => s.score > 0).sort((a, b) => b.score - a.score).slice(0, limit).map((s) => s.server);
+  }
+};
+
+// src/mcp/McpRegistryCache.ts
+import fs from "fs-extra";
+import path from "path";
+var DEFAULT_TTL_MS = 24 * 60 * 60 * 1e3;
+var McpRegistryCache = class {
+  constructor(config = {}) {
+    this.cacheDir = config.cacheDir || AUTOHAND_PATHS.mcpCache;
+    this.ttlMs = config.ttlMs ?? DEFAULT_TTL_MS;
+  }
+  /**
+   * Get cached registry if it exists and is not expired
+   */
+  async getRegistry() {
+    const cached = await this.readCachedRegistry();
+    if (!cached) return null;
+    if (Date.now() - cached.fetchedAt >= this.ttlMs) {
+      return null;
+    }
+    return cached.registry;
+  }
+  /**
+   * Get cached registry ignoring TTL (for offline fallback)
+   */
+  async getRegistryIgnoreTTL() {
+    const cached = await this.readCachedRegistry();
+    return cached?.registry || null;
+  }
+  /**
+   * Save registry to cache
+   */
+  async setRegistry(registry, etag) {
+    const cached = {
+      registry,
+      fetchedAt: Date.now(),
+      etag
+    };
+    await fs.ensureDir(this.cacheDir);
+    await fs.writeJson(this.registryPath, cached, { spaces: 2 });
+  }
+  /**
+   * Clear all cached data
+   */
+  async clear() {
+    await fs.remove(this.cacheDir);
+  }
+  // ========== Private Methods ==========
+  get registryPath() {
+    return path.join(this.cacheDir, "registry.json");
+  }
+  async readCachedRegistry() {
+    if (!await fs.pathExists(this.registryPath)) {
+      return null;
+    }
+    try {
+      const data = await fs.readJson(this.registryPath);
+      if (typeof data === "object" && data !== null && typeof data.fetchedAt === "number" && data.registry && Array.isArray(data.registry.servers)) {
+        return data;
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+};
+
+// src/commands/mcp-install.ts
+async function mcpInstall(ctx, serverName) {
+  const { mcpManager, config } = ctx;
+  if (!mcpManager || !config) {
+    console.log(chalk.red("MCP manager or config not available."));
+    return null;
+  }
+  const cache = new McpRegistryCache();
+  const fetcher = new McpRegistryFetcher();
+  let registry;
+  try {
+    const cached = await cache.getRegistry();
+    if (cached) {
+      registry = cached;
+    } else {
+      console.log(chalk.cyan("Fetching community MCP registry..."));
+      registry = await fetcher.fetchRegistry();
+      await cache.setRegistry(registry);
+    }
+  } catch (error) {
+    const stale = await cache.getRegistryIgnoreTTL();
+    if (stale) {
+      console.log(chalk.yellow("Using cached registry (offline mode)"));
+      registry = stale;
+    } else {
+      console.log(chalk.red("Failed to fetch MCP registry. Please check your internet connection."));
+      console.log(chalk.gray(error instanceof Error ? error.message : "Unknown error"));
+      return null;
+    }
+  }
+  if (serverName) {
+    return directInstall(ctx, registry, fetcher, serverName);
+  }
+  return interactiveBrowser(ctx, registry, fetcher);
+}
+async function directInstall(ctx, registry, fetcher, serverName) {
+  const server = fetcher.findServer(registry.servers, serverName);
+  if (!server) {
+    console.log(chalk.red(`MCP server not found: ${serverName}`));
+    const similar = fetcher.findSimilarServers(registry.servers, serverName, 3);
+    if (similar.length > 0) {
+      console.log(chalk.gray("Did you mean:"));
+      for (const s of similar) {
+        console.log(chalk.gray(`  - ${s.name}: ${s.description}`));
+      }
+    }
+    return null;
+  }
+  return installServer(ctx, server);
+}
+async function interactiveBrowser(ctx, registry, fetcher) {
+  console.log();
+  console.log(chalk.bold.cyan("Community MCP Servers"));
+  console.log(chalk.gray("\u2500".repeat(50)));
+  console.log(chalk.gray(`${registry.servers.length} servers available`));
+  console.log();
+  console.log(chalk.bold("Categories:"));
+  for (const cat of registry.categories) {
+    const count = registry.servers.filter((s) => s.category === cat.id).length;
+    console.log(chalk.gray(`  ${cat.name} (${count})`));
+  }
+  console.log();
+  const featured = fetcher.getFeaturedServers(registry.servers);
+  if (featured.length > 0) {
+    console.log(chalk.bold.yellow("Featured Servers:"));
+    for (const server of featured) {
+      const rating = server.rating ? `\u2605 ${server.rating.toFixed(1)}` : "";
+      console.log(`  ${chalk.green("\u25CF")} ${chalk.bold(server.name)} ${chalk.gray(rating)}`);
+      console.log(chalk.gray(`      ${server.description}`));
+    }
+    console.log();
+  }
+  const choices = registry.servers.map((server) => ({
+    name: server.id,
+    message: formatServerChoice(server),
+    value: server.id
+  }));
+  const answer = await safePrompt([
+    {
+      type: "autocomplete",
+      name: "server",
+      message: "Select a server to install (type to search)",
+      choices
+    }
+  ]);
+  if (!answer?.server) {
+    console.log(chalk.gray("No server selected."));
+    return null;
+  }
+  const selectedServer = registry.servers.find((s) => s.id === answer.server);
+  if (!selectedServer) {
+    console.log(chalk.red("Server not found."));
+    return null;
+  }
+  console.log();
+  console.log(chalk.bold.cyan(`Server: ${selectedServer.name}`));
+  console.log(chalk.gray("\u2500".repeat(50)));
+  console.log(chalk.white("Description: ") + selectedServer.description);
+  console.log(chalk.white("Category: ") + selectedServer.category);
+  console.log(chalk.white("Transport: ") + selectedServer.transport);
+  if (selectedServer.npmPackage) {
+    console.log(chalk.white("Package: ") + selectedServer.npmPackage);
+  }
+  if (selectedServer.tags?.length) {
+    console.log(chalk.white("Tags: ") + selectedServer.tags.join(", "));
+  }
+  if (selectedServer.envVars?.length) {
+    console.log(chalk.white("Required Env Vars: ") + selectedServer.envVars.join(", "));
+  }
+  if (selectedServer.requiredArgs?.length) {
+    console.log(chalk.white("Required Args: ") + selectedServer.requiredArgs.join(" "));
+  }
+  console.log();
+  return installServer(ctx, selectedServer);
+}
+async function installServer(ctx, server) {
+  const { mcpManager, config } = ctx;
+  if (!mcpManager || !config) {
+    return "MCP manager or config not available.";
+  }
+  if (config.mcp?.servers?.some((s) => s.name === server.id)) {
+    const confirm = await safePrompt([
+      {
+        type: "confirm",
+        name: "overwrite",
+        message: `Server "${server.name}" already installed. Overwrite?`,
+        initial: false
+      }
+    ]);
+    if (!confirm?.overwrite) {
+      console.log(chalk.gray("Installation cancelled."));
+      return null;
+    }
+    const idx = config.mcp.servers.findIndex((s) => s.name === server.id);
+    if (idx >= 0) {
+      try {
+        await mcpManager.disconnect(server.id);
+      } catch {
+      }
+      config.mcp.servers.splice(idx, 1);
+    }
+  }
+  if (server.envVars && server.envVars.length > 0) {
+    const missingVars = server.envVars.filter((v) => !process.env[v]);
+    if (missingVars.length > 0) {
+      console.log(chalk.yellow(`Required environment variables not set: ${missingVars.join(", ")}`));
+      console.log(chalk.gray("Set them in your shell profile or pass via env config."));
+    }
+  }
+  const serverArgs = server.args ? [...server.args] : [];
+  if (server.requiredArgs && server.requiredArgs.length > 0) {
+    console.log(chalk.yellow(`This server requires additional arguments: ${server.requiredArgs.join(" ")}`));
+    for (const reqArg of server.requiredArgs) {
+      const answer = await safePrompt([
+        {
+          type: "input",
+          name: "value",
+          message: `Enter value for ${reqArg}:`
+        }
+      ]);
+      if (answer?.value) {
+        serverArgs.push(answer.value);
+      }
+    }
+  }
+  const env = {};
+  if (server.envVars) {
+    for (const v of server.envVars) {
+      if (process.env[v]) {
+        env[v] = process.env[v];
+      }
+    }
+  }
+  const newServer = {
+    name: server.id,
+    transport: server.transport,
+    command: server.command,
+    args: serverArgs.length > 0 ? serverArgs : void 0,
+    env: Object.keys(env).length > 0 ? env : void 0,
+    autoConnect: true
+  };
+  if (!config.mcp) {
+    config.mcp = {};
+  }
+  if (!config.mcp.servers) {
+    config.mcp.servers = [];
+  }
+  config.mcp.servers.push(newServer);
+  try {
+    await saveConfig(config);
+    console.log(chalk.green(`\u2713 Installed ${server.name} to config`));
+    try {
+      console.log(chalk.cyan(`Connecting to ${server.name}...`));
+      await mcpManager.connect(newServer);
+      const tools = mcpManager.getToolsForServer(server.id);
+      console.log(chalk.green(`\u2713 Connected (${tools.length} tools available)`));
+      return `MCP server "${server.name}" installed and connected successfully.`;
+    } catch (connectError) {
+      console.log(chalk.yellow(`Installed but could not connect: ${connectError instanceof Error ? connectError.message : "Unknown error"}`));
+      return `MCP server "${server.name}" installed. Connect manually with /mcp connect ${server.id}`;
+    }
+  } catch (error) {
+    console.log(chalk.red("Failed to save config."));
+    console.log(chalk.gray(error instanceof Error ? error.message : "Unknown error"));
+    return null;
+  }
+}
+function formatServerChoice(server) {
+  const parts = [];
+  if (server.isFeatured) {
+    parts.push(chalk.yellow("\u2605"));
+  } else if (server.isCurated) {
+    parts.push(chalk.green("\u2713"));
+  } else {
+    parts.push(" ");
+  }
+  parts.push(chalk.bold(server.name.padEnd(25)));
+  if (server.rating) {
+    parts.push(chalk.gray(`${server.rating.toFixed(1)}`));
+  }
+  parts.push(chalk.gray(server.description.slice(0, 40)));
+  return parts.join(" ");
+}
+export {
+  mcpInstall
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * McpRegistryFetcher - Fetches community MCP server registry from GitHub
+ */
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * McpRegistryCache - TTL-based caching for community MCP registry
+ */
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * MCP install command - Browse and install community MCP servers from GitHub
+ */

package/dist/memory-LG4K6XV6.cjs

@@ -0,0 +1,9 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _chunk3DQSBW4Bcjs = require('./chunk-3DQSBW4B.cjs');
+require('./chunk-LOXOD4IS.cjs');
+
+
+
+exports.memory = _chunk3DQSBW4Bcjs.memory; exports.metadata = _chunk3DQSBW4Bcjs.metadata;

package/dist/{memory-4GSP7NKV.js → memory-LRDK2SYC.js}

@@ -1,7 +1,8 @@
 import {
   memory,
   metadata
-} from "./chunk-TAZJSKFD.js";
+} from "./chunk-BBIKQW66.js";
+import "./chunk-UET7BDX2.js";
 export {
   memory,
   metadata

package/dist/model-P5D7ATE7.cjs

@@ -0,0 +1,9 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _chunkAEYOIPHDcjs = require('./chunk-AEYOIPHD.cjs');
+require('./chunk-LOXOD4IS.cjs');
+
+
+
+exports.metadata = _chunkAEYOIPHDcjs.metadata; exports.model = _chunkAEYOIPHDcjs.model;

package/dist/{model-HKEFSH5E.js → model-WBFJIGUN.js}

@@ -1,7 +1,8 @@
 import {
   metadata,
   model
-} from "./chunk-KZ7VMQTC.js";
+} from "./chunk-OMEH2EVE.js";
+import "./chunk-UET7BDX2.js";
 export {
   metadata,
   model

package/dist/{new-EEZC4XXV.js → new-5A7RQEKI.js}

@@ -1,7 +1,8 @@
 import {
   metadata,
   newConversation
-} from "./chunk-ZWS3KSMK.js";
+} from "./chunk-HQQ4NKER.js";
+import "./chunk-UET7BDX2.js";
 export {
   metadata,
   newConversation

package/dist/new-EAATWI2G.cjs

@@ -0,0 +1,9 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _chunkHDSEJMWIcjs = require('./chunk-HDSEJMWI.cjs');
+require('./chunk-LOXOD4IS.cjs');
+
+
+
+exports.metadata = _chunkHDSEJMWIcjs.metadata; exports.newConversation = _chunkHDSEJMWIcjs.newConversation;

package/dist/permissions-5URK6C44.js

@@ -0,0 +1,12 @@
+import {
+  metadata,
+  permissions
+} from "./chunk-QU64XI5X.js";
+import "./chunk-WD5ZF6HE.js";
+import "./chunk-PNSRJT46.js";
+import "./chunk-NF7RIHJK.js";
+import "./chunk-UET7BDX2.js";
+export {
+  metadata,
+  permissions
+};

package/dist/permissions-CJUDVG63.cjs

@@ -0,0 +1,12 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _chunk5FZM7KLBcjs = require('./chunk-5FZM7KLB.cjs');
+require('./chunk-MNCWB5F7.cjs');
+require('./chunk-QRQ5EX7I.cjs');
+require('./chunk-Y27LG4BQ.cjs');
+require('./chunk-LOXOD4IS.cjs');
+
+
+
+exports.metadata = _chunk5FZM7KLBcjs.metadata; exports.permissions = _chunk5FZM7KLBcjs.permissions;

package/dist/quit-A33JHDG7.cjs

@@ -0,0 +1,9 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _chunkHVOBMOZ2cjs = require('./chunk-HVOBMOZ2.cjs');
+require('./chunk-LOXOD4IS.cjs');
+
+
+
+exports.metadata = _chunkHVOBMOZ2cjs.metadata; exports.quit = _chunkHVOBMOZ2cjs.quit;

package/dist/quit-IYBLN3DB.js

@@ -0,0 +1,9 @@
+import {
+  metadata,
+  quit
+} from "./chunk-WJ276BIP.js";
+import "./chunk-UET7BDX2.js";
+export {
+  metadata,
+  quit
+};

package/dist/resume-OPSJTCH7.cjs

@@ -0,0 +1,12 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _chunkBZ73ZQTEcjs = require('./chunk-BZ73ZQTE.cjs');
+require('./chunk-QRQ5EX7I.cjs');
+require('./chunk-Y27LG4BQ.cjs');
+require('./chunk-GIZL57FE.cjs');
+require('./chunk-LOXOD4IS.cjs');
+
+
+
+exports.metadata = _chunkBZ73ZQTEcjs.metadata; exports.resume = _chunkBZ73ZQTEcjs.resume;

package/dist/resume-TOWEEN5D.js

@@ -0,0 +1,12 @@
+import {
+  metadata,
+  resume
+} from "./chunk-E7YL3AHT.js";
+import "./chunk-PNSRJT46.js";
+import "./chunk-NF7RIHJK.js";
+import "./chunk-PWLLLJHU.js";
+import "./chunk-UET7BDX2.js";
+export {
+  metadata,
+  resume
+};

package/dist/search-GOLIE5BA.js

@@ -0,0 +1,14 @@
+import {
+  metadata,
+  search
+} from "./chunk-3652ROFD.js";
+import "./chunk-ZBIBLOZL.js";
+import "./chunk-JS7IPR7P.js";
+import "./chunk-PNSRJT46.js";
+import "./chunk-NF7RIHJK.js";
+import "./chunk-PWLLLJHU.js";
+import "./chunk-UET7BDX2.js";
+export {
+  metadata,
+  search
+};

package/dist/search-H42HGUK5.cjs

@@ -0,0 +1,14 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _chunkANUQFV43cjs = require('./chunk-ANUQFV43.cjs');
+require('./chunk-RJP3SZ7Q.cjs');
+require('./chunk-PGRH5Q77.cjs');
+require('./chunk-QRQ5EX7I.cjs');
+require('./chunk-Y27LG4BQ.cjs');
+require('./chunk-GIZL57FE.cjs');
+require('./chunk-LOXOD4IS.cjs');
+
+
+
+exports.metadata = _chunkANUQFV43cjs.metadata; exports.search = _chunkANUQFV43cjs.search;

package/dist/{sessions-4KXIT76T.js → sessions-B5NENDKY.js}

@@ -1,7 +1,8 @@
 import {
   metadata,
   sessions
-} from "./chunk-QJ53OSGF.js";
+} from "./chunk-WRJLBHWB.js";
+import "./chunk-UET7BDX2.js";
 export {
   metadata,
   sessions

package/dist/sessions-YHAVEMWY.cjs

@@ -0,0 +1,9 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _chunk65GTO4QMcjs = require('./chunk-65GTO4QM.cjs');
+require('./chunk-LOXOD4IS.cjs');
+
+
+
+exports.metadata = _chunk65GTO4QMcjs.metadata; exports.sessions = _chunk65GTO4QMcjs.sessions;

package/dist/share-3YWFZGNM.cjs

@@ -0,0 +1,13 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _chunkDMXN5LJBcjs = require('./chunk-DMXN5LJB.cjs');
+require('./chunk-4XHHW7QX.cjs');
+require('./chunk-QRQ5EX7I.cjs');
+require('./chunk-Y27LG4BQ.cjs');
+require('./chunk-GIZL57FE.cjs');
+require('./chunk-LOXOD4IS.cjs');
+
+
+
+exports.execute = _chunkDMXN5LJBcjs.execute; exports.metadata = _chunkDMXN5LJBcjs.metadata;

package/dist/share-T6I2LRGS.js

@@ -0,0 +1,13 @@
+import {
+  execute,
+  metadata
+} from "./chunk-DTXY7JDL.js";
+import "./chunk-BXV5O6VU.js";
+import "./chunk-PNSRJT46.js";
+import "./chunk-NF7RIHJK.js";
+import "./chunk-PWLLLJHU.js";
+import "./chunk-UET7BDX2.js";
+export {
+  execute,
+  metadata
+};