agents-anywhere 0.5.0

package/dist/cli.js

@@ -0,0 +1,2550 @@
+#!/usr/bin/env node
+"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 __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
+));
+
+// src/cli.ts
+var import_commander = require("commander");
+
+// src/version.ts
+var version = "0.5.0";
+
+// src/commands/init.ts
+var fs4 = __toESM(require("fs"));
+var import_node_path5 = __toESM(require("path"));
+var import_node_os2 = __toESM(require("os"));
+var import_node_child_process2 = require("child_process");
+var import_select = __toESM(require("@inquirer/select"));
+var import_confirm = __toESM(require("@inquirer/confirm"));
+var import_simple_git = require("simple-git");
+
+// src/core/detector.ts
+var import_node_fs2 = require("fs");
+var import_node_child_process = require("child_process");
+
+// src/core/schema-loader.ts
+var import_node_fs = require("fs");
+var import_node_path = __toESM(require("path"));
+
+// src/schemas/agent-definition-schema-data.ts
+var agentDefinitionSchema = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  title: "AgentDefinition",
+  description: "Declarative agent definition for agents-anywhere. Each agent is defined by a JSON file matching this schema.",
+  type: "object",
+  required: [
+    "id",
+    "name",
+    "configDir",
+    "detect",
+    "portable",
+    "ignore",
+    "credentials",
+    "instructions",
+    "mcp"
+  ],
+  additionalProperties: false,
+  properties: {
+    id: {
+      type: "string",
+      description: "Unique identifier, used as directory name in the config repo"
+    },
+    name: {
+      type: "string",
+      description: "Human-readable display name"
+    },
+    configDir: {
+      $ref: "#/definitions/PlatformPaths",
+      description: "Per-platform config directory paths"
+    },
+    detect: {
+      $ref: "#/definitions/DetectRule",
+      description: "How to detect if the agent is installed"
+    },
+    portable: {
+      type: "array",
+      items: { type: "string" },
+      description: "Glob patterns for files to symlink"
+    },
+    ignore: {
+      type: "array",
+      items: { type: "string" },
+      description: "Glob patterns for files to never sync"
+    },
+    credentials: {
+      type: "array",
+      items: { type: "string" },
+      description: "Paths to credential files to warn about if found in repo"
+    },
+    instructions: {
+      $ref: "#/definitions/InstructionsConfig",
+      description: "Agent instructions file configuration"
+    },
+    mcp: {
+      $ref: "#/definitions/MCPConfig",
+      description: "MCP configuration for the agent"
+    }
+  },
+  definitions: {
+    PlatformPaths: {
+      type: "object",
+      required: ["darwin", "linux", "win32"],
+      additionalProperties: false,
+      properties: {
+        darwin: { type: "string" },
+        linux: { type: "string" },
+        win32: { type: "string" }
+      }
+    },
+    DetectRule: {
+      type: "object",
+      required: ["type"],
+      additionalProperties: false,
+      properties: {
+        type: {
+          type: "string",
+          enum: ["directory-exists", "command-exists"]
+        },
+        path: { type: "string" },
+        command: { type: "string" }
+      }
+    },
+    InstructionsConfig: {
+      type: "object",
+      required: ["filename", "globalPath", "globalSupport"],
+      additionalProperties: false,
+      properties: {
+        filename: { type: "string" },
+        globalPath: { type: "string" },
+        globalSupport: {
+          type: "boolean",
+          description: "Whether this agent supports global (user-level) instructions"
+        }
+      }
+    },
+    TransportConfig: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        typeField: { type: "string" },
+        typeValue: { type: "string" },
+        urlKey: { type: "string" }
+      }
+    },
+    MCPConfig: {
+      type: "object",
+      required: [
+        "configPath",
+        "scope",
+        "rootKey",
+        "writeMode",
+        "envSyntax",
+        "transports",
+        "commandType",
+        "envKey"
+      ],
+      additionalProperties: false,
+      properties: {
+        configPath: {
+          type: "string",
+          description: "Path relative to configDir"
+        },
+        scope: {
+          type: "string",
+          enum: ["project-and-user", "user", "project"]
+        },
+        rootKey: {
+          type: "string",
+          description: "Top-level key wrapping server entries"
+        },
+        format: {
+          type: "string",
+          enum: ["json", "toml"]
+        },
+        writeMode: {
+          type: "string",
+          enum: ["standalone", "merge"]
+        },
+        envSyntax: {
+          type: "string",
+          description: "Template for env var substitution \u2014 VAR is replaced with env var name"
+        },
+        defaultSyntax: {
+          type: "string",
+          description: "Fallback env syntax with default value support"
+        },
+        transports: {
+          type: "object",
+          properties: {
+            stdio: { $ref: "#/definitions/TransportConfig" },
+            http: { $ref: "#/definitions/TransportConfig" }
+          },
+          additionalProperties: false
+        },
+        commandType: {
+          type: "string",
+          enum: ["string", "array"]
+        },
+        envKey: {
+          type: "string",
+          description: "Key name for environment variables object"
+        },
+        serverSection: {
+          type: "string",
+          description: "TOML section key for reading existing servers"
+        },
+        envVarStyle: {
+          type: "string",
+          enum: ["inline", "named"]
+        }
+      }
+    }
+  }
+};
+
+// src/utils/output.ts
+var RESET = "\x1B[0m";
+var BOLD = "\x1B[1m";
+var DIM = "\x1B[2m";
+var RED = "\x1B[31m";
+var GREEN = "\x1B[32m";
+var YELLOW = "\x1B[33m";
+var BLUE = "\x1B[34m";
+var CYAN = "\x1B[36m";
+var _verbose = false;
+function setVerbose(v) {
+  _verbose = v;
+}
+function isVerbose() {
+  return _verbose || process.env.AGENTS_ANYWHERE_VERBOSE !== void 0;
+}
+function useColor() {
+  if (process.env.NO_COLOR !== void 0) return false;
+  if (process.env.FORCE_COLOR !== void 0) return true;
+  return process.stdout.isTTY === true;
+}
+function wrap(code, msg) {
+  return useColor() ? `${code}${msg}${RESET}` : msg;
+}
+function info(msg) {
+  const prefix = useColor() ? `${BLUE}\u2139${RESET}` : "\u2139";
+  console.log(`${prefix} ${msg}`);
+}
+function success(msg) {
+  const prefix = useColor() ? `${GREEN}\u2713${RESET}` : "\u2713";
+  console.log(`${prefix} ${msg}`);
+}
+function warn(msg) {
+  const prefix = useColor() ? `${YELLOW}\u26A0${RESET}` : "\u26A0";
+  console.log(`${prefix} ${msg}`);
+}
+function error(msg) {
+  const prefix = useColor() ? `${RED}\u2717${RESET}` : "\u2717";
+  console.error(`${prefix} ${msg}`);
+}
+function debug(msg) {
+  if (!isVerbose()) return;
+  const prefix = useColor() ? `${DIM}[debug]${RESET}` : "[debug]";
+  console.error(`${prefix} ${msg}`);
+}
+function heading(msg) {
+  console.log(`
+${wrap(BOLD, msg)}`);
+}
+function dim(msg) {
+  return wrap(DIM, msg);
+}
+function bold(msg) {
+  return wrap(BOLD, msg);
+}
+function green(msg) {
+  return wrap(GREEN, msg);
+}
+function yellow(msg) {
+  return wrap(YELLOW, msg);
+}
+function red(msg) {
+  return wrap(RED, msg);
+}
+function cyan(msg) {
+  return wrap(CYAN, msg);
+}
+function table(rows, indent = 2) {
+  if (rows.length === 0) return;
+  const maxKey = Math.max(...rows.map(([k]) => k.length));
+  const pad = " ".repeat(indent);
+  for (const [key, value] of rows) {
+    console.log(`${pad}${key.padEnd(maxKey)}  ${value}`);
+  }
+}
+function statusBadge(status) {
+  switch (status) {
+    case "linked":
+      return green("linked");
+    case "unlinked":
+      return dim("unlinked");
+    case "diverged":
+      return yellow("diverged");
+    case "missing":
+      return dim("missing");
+    case "installed":
+      return green("installed");
+    case "not installed":
+      return dim("not installed");
+    default:
+      return status;
+  }
+}
+
+// src/core/schema-loader.ts
+function getAgentsDir() {
+  const candidates = [
+    import_node_path.default.resolve(__dirname, "../../agents"),
+    import_node_path.default.resolve(__dirname, "../agents"),
+    import_node_path.default.resolve(__dirname, "agents")
+  ];
+  for (const candidate of candidates) {
+    try {
+      (0, import_node_fs.readdirSync)(candidate);
+      return candidate;
+    } catch (err) {
+      debug(`Agents dir candidate ${candidate} not accessible: ${err.message}`);
+    }
+  }
+  throw new Error(
+    "Could not find agents/ directory. Ensure agent definition JSON files are bundled."
+  );
+}
+function resolveRef(ref, root) {
+  const parts = ref.replace(/^#\//, "").split("/");
+  let current = root;
+  for (const part of parts) {
+    if (current && typeof current === "object" && part in current) {
+      current = current[part];
+    } else {
+      throw new Error(`Cannot resolve $ref: ${ref}`);
+    }
+  }
+  return current;
+}
+function validateNode(value, schema, root, currentPath) {
+  const errors = [];
+  let resolved = schema;
+  if (schema.$ref) {
+    resolved = { ...resolveRef(schema.$ref, root) };
+  }
+  if (resolved.type) {
+    const actualType = getJsonType(value);
+    if (actualType !== resolved.type) {
+      errors.push({
+        path: currentPath,
+        message: `Expected type "${resolved.type}", got "${actualType}"`
+      });
+      return errors;
+    }
+  }
+  if (resolved.enum && typeof value === "string") {
+    if (!resolved.enum.includes(value)) {
+      errors.push({
+        path: currentPath,
+        message: `Invalid value "${value}". Must be one of: ${resolved.enum.join(", ")}`
+      });
+    }
+  }
+  if (resolved.type === "object" && typeof value === "object" && value !== null) {
+    const obj = value;
+    if (resolved.required) {
+      for (const field of resolved.required) {
+        if (obj[field] === void 0 || obj[field] === null) {
+          errors.push({
+            path: currentPath ? `${currentPath}.${field}` : field,
+            message: `Missing required field "${field}"`
+          });
+        }
+      }
+    }
+    if (resolved.properties) {
+      for (const [key, propSchema] of Object.entries(resolved.properties)) {
+        if (obj[key] !== void 0 && obj[key] !== null) {
+          const propPath = currentPath ? `${currentPath}.${key}` : key;
+          errors.push(...validateNode(obj[key], propSchema, root, propPath));
+        }
+      }
+    }
+    if (resolved.additionalProperties === false && resolved.properties) {
+      const allowedKeys = new Set(Object.keys(resolved.properties));
+      for (const key of Object.keys(obj)) {
+        if (!allowedKeys.has(key)) {
+          errors.push({
+            path: currentPath ? `${currentPath}.${key}` : key,
+            message: `Unknown property "${key}" is not allowed`
+          });
+        }
+      }
+    }
+  }
+  if (resolved.type === "array" && Array.isArray(value)) {
+    if (resolved.items) {
+      for (let i = 0; i < value.length; i++) {
+        errors.push(
+          ...validateNode(value[i], resolved.items, root, `${currentPath}[${i}]`)
+        );
+      }
+    }
+  }
+  return errors;
+}
+function getJsonType(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "array";
+  return typeof value;
+}
+function validateAgainstSchema(data) {
+  const schema = agentDefinitionSchema;
+  const errors = validateNode(data, schema, schema, "");
+  return { valid: errors.length === 0, errors };
+}
+function loadAgentDefinition(filePath) {
+  const raw = (0, import_node_fs.readFileSync)(filePath, "utf-8");
+  const parsed = JSON.parse(raw);
+  const result = validateAgainstSchema(parsed);
+  if (!result.valid) {
+    const messages = result.errors.map((e) => `  ${e.path}: ${e.message}`).join("\n");
+    throw new Error(
+      `Agent definition ${filePath} failed validation:
+${messages}`
+    );
+  }
+  return parsed;
+}
+var _cache = null;
+function loadAllAgentDefinitions() {
+  if (_cache) return _cache;
+  const agentsDir = getAgentsDir();
+  const files = (0, import_node_fs.readdirSync)(agentsDir).filter((f) => f.endsWith(".json"));
+  _cache = files.map((file) => loadAgentDefinition(import_node_path.default.join(agentsDir, file)));
+  return _cache;
+}
+function loadAgentById(id) {
+  const all = loadAllAgentDefinitions();
+  return all.find((agent) => agent.id === id);
+}
+
+// src/utils/paths.ts
+var import_node_path2 = __toESM(require("path"));
+var import_node_os = __toESM(require("os"));
+function expandPath(p) {
+  if (p.startsWith("~")) {
+    return import_node_path2.default.join(import_node_os.default.homedir(), p.slice(1));
+  }
+  if (p.startsWith("%APPDATA%")) {
+    if (process.env.APPDATA) {
+      return import_node_path2.default.join(process.env.APPDATA, p.slice("%APPDATA%".length));
+    }
+    if (process.platform === "win32") {
+      throw new Error("APPDATA environment variable is not set");
+    }
+  }
+  return p;
+}
+function getPlatformPath(paths) {
+  const platform = process.platform;
+  if (platform === "darwin" || platform === "linux" || platform === "win32") {
+    return paths[platform];
+  }
+  warn(`Unsupported platform "${platform}", falling back to Linux paths`);
+  return paths.linux;
+}
+
+// src/core/detector.ts
+function detectAgents() {
+  const definitions = loadAllAgentDefinitions();
+  return definitions.map((def) => detectSingleAgent(def));
+}
+function detectSingleAgent(definition) {
+  const configDir = expandPath(getPlatformPath(definition.configDir));
+  const installed = checkDetectRule(definition);
+  return { definition, configDir, installed };
+}
+function checkDetectRule(definition) {
+  const { detect } = definition;
+  switch (detect.type) {
+    case "directory-exists":
+      return (0, import_node_fs2.existsSync)(expandPath(detect.path));
+    case "command-exists":
+      return commandExists(detect.command);
+    default:
+      return false;
+  }
+}
+function commandExists(command) {
+  try {
+    const cmd = process.platform === "win32" ? "where" : "which";
+    (0, import_node_child_process.execFileSync)(cmd, [command], { stdio: "ignore" });
+    return true;
+  } catch {
+    debug(`command-exists: "${command}" not found in PATH`);
+    return false;
+  }
+}
+
+// src/core/linker.ts
+var import_node_fs3 = require("fs");
+var import_node_path3 = __toESM(require("path"));
+function resolvePaths(agentDef, repoDir) {
+  const configDir = expandPath(getPlatformPath(agentDef.configDir));
+  const agentRepoDir = import_node_path3.default.join(repoDir, agentDef.id);
+  return { configDir, agentRepoDir };
+}
+function getPortableItems(agentDef) {
+  const items = /* @__PURE__ */ new Set();
+  for (const pattern of agentDef.portable) {
+    const topLevel = pattern.split("/")[0];
+    items.add(topLevel);
+  }
+  return [...items];
+}
+function backupTimestamp() {
+  return Date.now().toString();
+}
+function linkAgent(agentDef, repoDir, dryRun = false) {
+  const { configDir, agentRepoDir } = resolvePaths(agentDef, repoDir);
+  const items = getPortableItems(agentDef);
+  const results = [];
+  if (!dryRun) {
+    (0, import_node_fs3.mkdirSync)(configDir, { recursive: true });
+  }
+  for (const item of items) {
+    const agentPath = import_node_path3.default.join(configDir, item);
+    const repoPath = import_node_path3.default.join(agentRepoDir, item);
+    if (!(0, import_node_fs3.existsSync)(repoPath)) {
+      continue;
+    }
+    if ((0, import_node_fs3.existsSync)(agentPath) || lstatExists(agentPath)) {
+      if (isSymlinkTo(agentPath, repoPath)) {
+        results.push({ item, action: "skipped", agentPath });
+        continue;
+      }
+      if (!dryRun) {
+        const backupPath = `${agentPath}.backup.${backupTimestamp()}`;
+        (0, import_node_fs3.renameSync)(agentPath, backupPath);
+        (0, import_node_fs3.symlinkSync)(repoPath, agentPath);
+      }
+      results.push({ item, action: "backed-up-and-linked", agentPath });
+      continue;
+    }
+    if (!dryRun) {
+      (0, import_node_fs3.symlinkSync)(repoPath, agentPath);
+    }
+    results.push({ item, action: "linked", agentPath });
+  }
+  return results;
+}
+function unlinkAgent(agentDef, repoDir, dryRun = false) {
+  const { configDir, agentRepoDir } = resolvePaths(agentDef, repoDir);
+  const items = getPortableItems(agentDef);
+  const results = [];
+  for (const item of items) {
+    const agentPath = import_node_path3.default.join(configDir, item);
+    const repoPath = import_node_path3.default.join(agentRepoDir, item);
+    if (!lstatExists(agentPath) || !isSymlinkTo(agentPath, repoPath)) {
+      results.push({ item, action: "skipped", agentPath });
+      continue;
+    }
+    if (!dryRun) {
+      (0, import_node_fs3.unlinkSync)(agentPath);
+    }
+    const backup = findMostRecentBackup(configDir, item);
+    if (backup) {
+      if (!dryRun) {
+        (0, import_node_fs3.renameSync)(import_node_path3.default.join(configDir, backup), agentPath);
+      }
+      results.push({ item, action: "restored", agentPath });
+    } else {
+      results.push({ item, action: "unlinked", agentPath });
+    }
+  }
+  return results;
+}
+function getStatus(agentDef, repoDir) {
+  const { configDir, agentRepoDir } = resolvePaths(agentDef, repoDir);
+  const items = getPortableItems(agentDef);
+  const statuses = [];
+  for (const item of items) {
+    const agentPath = import_node_path3.default.join(configDir, item);
+    const repoPath = import_node_path3.default.join(agentRepoDir, item);
+    let status;
+    if (!(0, import_node_fs3.existsSync)(repoPath) && !lstatExists(agentPath)) {
+      status = "missing";
+    } else if (isSymlinkTo(agentPath, repoPath)) {
+      status = "linked";
+    } else if (lstatExists(agentPath)) {
+      status = "diverged";
+    } else {
+      status = "unlinked";
+    }
+    statuses.push({ item, status, agentPath, repoPath });
+  }
+  return statuses;
+}
+function lstatExists(p) {
+  try {
+    (0, import_node_fs3.lstatSync)(p);
+    return true;
+  } catch (err) {
+    debug(`lstat failed for ${p}: ${err.message}`);
+    return false;
+  }
+}
+function isSymlinkTo(linkPath, expectedTarget) {
+  try {
+    const stat = (0, import_node_fs3.lstatSync)(linkPath);
+    if (!stat.isSymbolicLink()) return false;
+    const target = (0, import_node_fs3.readlinkSync)(linkPath);
+    return import_node_path3.default.resolve(import_node_path3.default.dirname(linkPath), target) === import_node_path3.default.resolve(expectedTarget);
+  } catch (err) {
+    debug(`isSymlinkTo check failed for ${linkPath}: ${err.message}`);
+    return false;
+  }
+}
+function findMostRecentBackup(dir, item) {
+  try {
+    const entries = (0, import_node_fs3.readdirSync)(dir);
+    const prefix = `${item}.backup.`;
+    const backups = entries.filter((e) => e.startsWith(prefix)).sort().reverse();
+    return backups[0];
+  } catch (err) {
+    debug(`findMostRecentBackup readdir failed for ${dir}/${item}: ${err.message}`);
+    return void 0;
+  }
+}
+
+// src/mcp/importer.ts
+var fs = __toESM(require("fs"));
+var import_node_path4 = __toESM(require("path"));
+var TOML = __toESM(require("smol-toml"));
+function importFromAgent(agentDef) {
+  const configDir = expandPath(getPlatformPath(agentDef.configDir));
+  const configPath = import_node_path4.default.join(configDir, agentDef.mcp.configPath);
+  if (!fs.existsSync(configPath)) return null;
+  const nativeServers = readNativeConfig(configPath, agentDef.mcp);
+  if (!nativeServers) return null;
+  const servers = {};
+  for (const [name, serverData] of Object.entries(nativeServers)) {
+    const normalized = reverseTransformServer(
+      serverData,
+      agentDef.mcp
+    );
+    if (normalized) {
+      servers[name] = normalized;
+    }
+  }
+  if (Object.keys(servers).length === 0) return null;
+  return {
+    agentId: agentDef.id,
+    agentName: agentDef.name,
+    servers,
+    sourcePath: configPath
+  };
+}
+function importAndMergeAll(agents) {
+  const allImports = [];
+  for (const agent of agents) {
+    const result = importFromAgent(agent);
+    if (result) {
+      allImports.push(result);
+    }
+  }
+  const merged = {};
+  const sources = {};
+  const conflictAgents = {};
+  for (const imp of allImports) {
+    for (const [name, server] of Object.entries(imp.servers)) {
+      if (merged[name]) {
+        if (!conflictAgents[name]) {
+          conflictAgents[name] = [sources[name]];
+        }
+        conflictAgents[name].push(imp.agentId);
+        const existingScore = serverScore(merged[name]);
+        const newScore = serverScore(server);
+        if (newScore > existingScore) {
+          merged[name] = server;
+          sources[name] = imp.agentId;
+        }
+      } else {
+        merged[name] = server;
+        sources[name] = imp.agentId;
+      }
+    }
+  }
+  const conflicts = [];
+  for (const [serverName, agents2] of Object.entries(conflictAgents)) {
+    conflicts.push({ serverName, agents: agents2, kept: sources[serverName] });
+  }
+  return { config: { servers: merged }, sources, conflicts };
+}
+function readNativeConfig(filePath, mcp2) {
+  try {
+    const raw = fs.readFileSync(filePath, "utf-8");
+    let parsed;
+    if (mcp2.format === "toml") {
+      parsed = TOML.parse(raw);
+    } else {
+      parsed = JSON.parse(raw);
+    }
+    const servers = parsed[mcp2.rootKey];
+    if (!servers || typeof servers !== "object") return null;
+    return servers;
+  } catch (err) {
+    debug(`Failed to parse native config ${filePath}: ${err.message}`);
+    return null;
+  }
+}
+function reverseTransformServer(serverData, mcp2) {
+  const transport = detectTransport(serverData, mcp2);
+  if (!transport) return null;
+  const server = { transport };
+  if (transport === "stdio") {
+    reverseStdioFields(server, serverData, mcp2);
+  } else {
+    reverseHttpFields(server, serverData, mcp2);
+  }
+  if (mcp2.envVarStyle === "named") {
+    const envVars = serverData[mcp2.envKey];
+    if (Array.isArray(envVars)) {
+      server.env = reverseNamedEnvVars(envVars);
+    }
+    const bearerVar = serverData.bearer_token_env_var;
+    if (typeof bearerVar === "string") {
+      server.headers = {
+        Authorization: { $env: bearerVar, prefix: "Bearer " }
+      };
+    }
+  } else {
+    const envObj = serverData[mcp2.envKey];
+    if (envObj && typeof envObj === "object" && !Array.isArray(envObj)) {
+      const reversed = reverseInlineEnvVars(
+        envObj,
+        mcp2.envSyntax
+      );
+      if (Object.keys(reversed).length > 0) {
+        server.env = reversed;
+      }
+    }
+    const headers = serverData.headers;
+    if (headers && typeof headers === "object" && !Array.isArray(headers)) {
+      const reversedHeaders = reverseInlineHeaders(
+        headers,
+        mcp2.envSyntax
+      );
+      if (Object.keys(reversedHeaders).length > 0) {
+        server.headers = reversedHeaders;
+      }
+    }
+  }
+  return server;
+}
+function detectTransport(serverData, mcp2) {
+  for (const [transportType, config] of Object.entries(mcp2.transports)) {
+    if (!config?.typeField) continue;
+    const value = serverData[config.typeField];
+    if (value === config.typeValue) {
+      return transportType;
+    }
+  }
+  if (serverData.command) return "stdio";
+  const httpConfig = mcp2.transports.http;
+  const urlKey = httpConfig?.urlKey ?? "url";
+  if (serverData[urlKey] || serverData.url) return "http";
+  return null;
+}
+function reverseStdioFields(server, serverData, mcp2) {
+  if (mcp2.commandType === "array" && Array.isArray(serverData.command)) {
+    const arr = serverData.command;
+    server.command = arr[0];
+    if (arr.length > 1) {
+      server.args = arr.slice(1);
+    }
+  } else {
+    if (typeof serverData.command === "string") {
+      server.command = serverData.command;
+    }
+    if (Array.isArray(serverData.args) && serverData.args.length > 0) {
+      server.args = serverData.args;
+    }
+  }
+}
+function reverseHttpFields(server, serverData, mcp2) {
+  const httpConfig = mcp2.transports.http;
+  const urlKey = httpConfig?.urlKey ?? "url";
+  const url = serverData[urlKey] ?? serverData.url;
+  if (typeof url === "string") {
+    server.url = url;
+  }
+}
+function extractEnvVarName(value, envSyntax) {
+  const parts = envSyntax.split("VAR");
+  if (parts.length !== 2) return null;
+  const [prefix, suffix] = parts;
+  if (value.startsWith(prefix) && value.endsWith(suffix)) {
+    const varName = value.slice(
+      prefix.length,
+      suffix.length > 0 ? value.length - suffix.length : void 0
+    );
+    if (varName.length > 0) return varName;
+  }
+  return null;
+}
+function reverseEnvRef(value, envSyntax) {
+  const direct = extractEnvVarName(value, envSyntax);
+  if (direct) return { $env: direct };
+  const parts = envSyntax.split("VAR");
+  if (parts.length !== 2) return null;
+  const [syntaxPrefix, syntaxSuffix] = parts;
+  const idx = value.indexOf(syntaxPrefix);
+  if (idx === -1) return null;
+  const beforeSyntax = value.slice(0, idx);
+  const afterPrefix = value.slice(idx + syntaxPrefix.length);
+  let varName;
+  if (syntaxSuffix.length > 0) {
+    const suffixIdx = afterPrefix.indexOf(syntaxSuffix);
+    if (suffixIdx === -1) return null;
+    varName = afterPrefix.slice(0, suffixIdx);
+  } else {
+    varName = afterPrefix;
+  }
+  if (varName.length === 0) return null;
+  const ref = { $env: varName };
+  if (beforeSyntax) {
+    ref.prefix = beforeSyntax;
+  }
+  return ref;
+}
+function reverseNamedEnvVars(envVars) {
+  const result = {};
+  for (const name of envVars) {
+    result[name] = { $env: name };
+  }
+  return result;
+}
+function reverseInlineEnvVars(env, envSyntax) {
+  const result = {};
+  for (const [key, value] of Object.entries(env)) {
+    if (typeof value !== "string") continue;
+    const ref = reverseEnvRef(value, envSyntax);
+    if (ref) {
+      result[key] = ref;
+    }
+  }
+  return result;
+}
+function reverseInlineHeaders(headers, envSyntax) {
+  const result = {};
+  for (const [key, value] of Object.entries(headers)) {
+    if (typeof value !== "string") continue;
+    const ref = reverseEnvRef(value, envSyntax);
+    if (ref) {
+      result[key] = ref;
+    }
+  }
+  return result;
+}
+function serverScore(server) {
+  let score = 0;
+  if (server.command) score++;
+  if (server.url) score++;
+  if (server.args) score += server.args.length;
+  if (server.env) score += Object.keys(server.env).length;
+  if (server.headers) score += Object.keys(server.headers).length;
+  return score;
+}
+
+// src/mcp/parser.ts
+var fs2 = __toESM(require("fs"));
+function parseMCPConfig(filePath) {
+  const raw = fs2.readFileSync(filePath, "utf-8");
+  return parseMCPConfigFromString(raw);
+}
+function parseMCPConfigFromString(content) {
+  const parsed = JSON.parse(content);
+  if (!parsed.servers || typeof parsed.servers !== "object") {
+    throw new Error('mcp.json must have a "servers" object at the top level');
+  }
+  for (const [name, server] of Object.entries(parsed.servers)) {
+    validateServer(name, server);
+  }
+  return parsed;
+}
+function validateServer(name, server) {
+  if (!server.transport) {
+    throw new Error(`Server "${name}" must specify a "transport" (stdio or http)`);
+  }
+  if (server.transport !== "stdio" && server.transport !== "http") {
+    throw new Error(`Server "${name}" has invalid transport "${server.transport}" (must be stdio or http)`);
+  }
+  if (server.transport === "stdio" && !server.command) {
+    throw new Error(`Server "${name}" with stdio transport must specify a "command"`);
+  }
+  if (server.transport === "http" && !server.url) {
+    throw new Error(`Server "${name}" with http transport must specify a "url"`);
+  }
+  if (server.env) {
+    for (const [key, ref] of Object.entries(server.env)) {
+      if (!ref.$env || typeof ref.$env !== "string") {
+        throw new Error(`Server "${name}" env var "${key}" must have a "$env" string`);
+      }
+    }
+  }
+  if (server.headers) {
+    for (const [key, ref] of Object.entries(server.headers)) {
+      if (!ref.$env || typeof ref.$env !== "string") {
+        throw new Error(`Server "${name}" header "${key}" must have a "$env" string`);
+      }
+    }
+  }
+}
+
+// src/mcp/transformer.ts
+function transformForAgent(config, agentDef) {
+  const mcp2 = agentDef.mcp;
+  const servers = {};
+  for (const [name, server] of Object.entries(config.servers)) {
+    servers[name] = transformServer(server, mcp2, name, agentDef.name);
+  }
+  return {
+    rootKey: mcp2.rootKey,
+    servers,
+    format: mcp2.format ?? "json"
+  };
+}
+function transformServer(server, mcp2, serverName, agentName) {
+  if (!mcp2.transports[server.transport]) {
+    warn(
+      `Agent "${agentName}" does not define transport "${server.transport}" \u2014 using defaults for server "${serverName}"`
+    );
+  }
+  if (mcp2.envVarStyle === "named") {
+    return transformServerNamed(server, mcp2);
+  }
+  return transformServerInline(server, mcp2);
+}
+function transformServerInline(server, mcp2) {
+  const result = {};
+  const transportDef = mcp2.transports[server.transport];
+  if (transportDef?.typeField && transportDef.typeValue) {
+    result[transportDef.typeField] = transportDef.typeValue;
+  }
+  if (server.transport === "stdio") {
+    if (mcp2.commandType === "array") {
+      result.command = [server.command, ...server.args ?? []];
+    } else {
+      result.command = server.command;
+      if (server.args?.length) {
+        result.args = server.args;
+      }
+    }
+  } else if (server.transport === "http") {
+    const urlKey = transportDef?.urlKey ?? "url";
+    result[urlKey] = server.url;
+  }
+  if (server.env && Object.keys(server.env).length > 0) {
+    const env = {};
+    for (const [key, ref] of Object.entries(server.env)) {
+      env[key] = resolveEnvRef(ref, mcp2.envSyntax);
+    }
+    result[mcp2.envKey] = env;
+  }
+  if (server.headers && Object.keys(server.headers).length > 0) {
+    const headers = {};
+    for (const [key, ref] of Object.entries(server.headers)) {
+      headers[key] = resolveEnvRef(ref, mcp2.envSyntax);
+    }
+    result.headers = headers;
+  }
+  return result;
+}
+function transformServerNamed(server, mcp2) {
+  const result = {};
+  const transportDef = mcp2.transports[server.transport];
+  if (transportDef?.typeField && transportDef.typeValue) {
+    result[transportDef.typeField] = transportDef.typeValue;
+  }
+  if (server.transport === "stdio") {
+    result.command = server.command;
+    if (server.args?.length) {
+      result.args = server.args;
+    }
+  } else if (server.transport === "http") {
+    const urlKey = transportDef?.urlKey ?? "url";
+    result[urlKey] = server.url;
+  }
+  if (server.env && Object.keys(server.env).length > 0) {
+    result[mcp2.envKey] = Object.values(server.env).map((ref) => ref.$env);
+  }
+  if (server.headers) {
+    for (const [, ref] of Object.entries(server.headers)) {
+      if (ref.prefix?.toLowerCase().startsWith("bearer")) {
+        result.bearer_token_env_var = ref.$env;
+      }
+    }
+  }
+  return result;
+}
+function resolveEnvRef(ref, syntax) {
+  if (!syntax.includes("VAR")) {
+    throw new Error(`envSyntax "${syntax}" does not contain placeholder "VAR"`);
+  }
+  const resolved = syntax.replace("VAR", ref.$env);
+  if (ref.prefix) {
+    return ref.prefix + resolved;
+  }
+  return resolved;
+}
+
+// src/mcp/writer.ts
+var fs3 = __toESM(require("fs"));
+var path5 = __toESM(require("path"));
+var TOML2 = __toESM(require("smol-toml"));
+function ensureDir(filePath) {
+  const dir = path5.dirname(filePath);
+  if (!fs3.existsSync(dir)) {
+    fs3.mkdirSync(dir, { recursive: true });
+  }
+}
+function writeJSON(filePath, rootKey, servers) {
+  ensureDir(filePath);
+  const content = { [rootKey]: servers };
+  fs3.writeFileSync(filePath, JSON.stringify(content, null, 2) + "\n", "utf-8");
+}
+function mergeJSON(filePath, key, servers) {
+  ensureDir(filePath);
+  let existing = {};
+  if (fs3.existsSync(filePath)) {
+    const raw = fs3.readFileSync(filePath, "utf-8");
+    try {
+      existing = JSON.parse(raw);
+    } catch {
+      throw new Error(`Invalid JSON in ${filePath} \u2014 fix or delete the file before syncing`);
+    }
+  }
+  existing[key] = servers;
+  fs3.writeFileSync(
+    filePath,
+    JSON.stringify(existing, null, 2) + "\n",
+    "utf-8"
+  );
+}
+function writeTOML(filePath, rootKey, servers) {
+  ensureDir(filePath);
+  let existing = {};
+  if (fs3.existsSync(filePath)) {
+    const raw = fs3.readFileSync(filePath, "utf-8");
+    existing = TOML2.parse(raw);
+  }
+  existing[rootKey] = servers;
+  fs3.writeFileSync(filePath, TOML2.stringify(existing) + "\n", "utf-8");
+}
+
+// src/commands/init.ts
+var DEFAULT_REPO_DIR = import_node_path5.default.join(import_node_os2.default.homedir(), "agents-anywhere-config");
+var POST_MERGE_HOOK = `#!/bin/sh
+# agents-anywhere post-merge hook \u2014 re-link configs and regenerate MCP on pull
+agents-anywhere link
+agents-anywhere mcp sync
+`;
+var GITIGNORE = `# agents-anywhere generated
+*.backup.*
+
+# OS files
+.DS_Store
+Thumbs.db
+`;
+async function initCommand(repoDir, options) {
+  const targetDir = repoDir ?? DEFAULT_REPO_DIR;
+  if (options?.from) {
+    await initFromRemote(options.from, targetDir);
+    return;
+  }
+  heading("Detecting installed AI coding agents...");
+  const agents = detectAgents();
+  const installed = agents.filter((a) => a.installed);
+  if (installed.length === 0) {
+    warn("No AI coding agents detected.");
+    info(
+      "Supported agents: " + agents.map((a) => a.definition.name).join(", ")
+    );
+    return;
+  }
+  for (const agent of agents) {
+    if (agent.installed) {
+      success(`${agent.definition.name}    ${dim(agent.configDir)}`);
+    } else {
+      info(`${agent.definition.name}    ${dim("not installed")}`);
+    }
+  }
+  if (fs4.existsSync(import_node_path5.default.join(targetDir, "agents-anywhere.json"))) {
+    warn(`Config repo already exists at ${targetDir}`);
+    info("Run `agents-anywhere link` to connect your agents.");
+    return;
+  }
+  const primary = await promptPrimaryAgent(installed);
+  heading("Creating config repo...");
+  fs4.mkdirSync(targetDir, { recursive: true });
+  const git = (0, import_simple_git.simpleGit)(targetDir);
+  if (!await git.checkIsRepo()) {
+    await git.init();
+    success("git init");
+  }
+  copyPortableFiles(installed, targetDir);
+  syncInstructions(primary, installed, targetDir);
+  importMCPServers(installed, targetDir);
+  const manifest = buildManifest(installed, targetDir, primary.definition.id);
+  fs4.writeFileSync(
+    import_node_path5.default.join(targetDir, "agents-anywhere.json"),
+    JSON.stringify(manifest, null, 2) + "\n",
+    "utf-8"
+  );
+  success("agents-anywhere.json");
+  fs4.writeFileSync(import_node_path5.default.join(targetDir, ".gitignore"), GITIGNORE, "utf-8");
+  success(".gitignore");
+  const hooksDir = import_node_path5.default.join(targetDir, ".git", "hooks");
+  fs4.mkdirSync(hooksDir, { recursive: true });
+  fs4.writeFileSync(import_node_path5.default.join(hooksDir, "post-merge"), POST_MERGE_HOOK, {
+    mode: 493
+  });
+  success("post-merge hook");
+  heading("Linking agent configs...");
+  for (const agent of installed) {
+    const results = linkAgent(agent.definition, targetDir);
+    const linked = results.filter(
+      (r) => r.action === "linked" || r.action === "backed-up-and-linked"
+    );
+    if (linked.length > 0) {
+      success(`${agent.definition.name} \u2014 ${linked.length} item(s) linked`);
+    }
+  }
+  syncMCPToAllAgents(targetDir, installed);
+  await git.add(".");
+  await git.commit("Initial agents-anywhere setup");
+  success("Initial commit created");
+  console.log(`
+${dim("Setup complete!")} Config repo at ${dim(targetDir)}`);
+  await promptGitHubRepo(targetDir);
+}
+async function promptPrimaryAgent(installed) {
+  const candidates = installed.filter(
+    (a) => a.definition.instructions.globalSupport
+  );
+  if (candidates.length === 0) {
+    warn(
+      "No installed agents support global instructions \u2014 instruction syncing will be skipped."
+    );
+    return installed[0];
+  }
+  if (candidates.length === 1) {
+    info(
+      `Using ${candidates[0].definition.name} as primary agent.`
+    );
+    return candidates[0];
+  }
+  if (!process.stdin.isTTY) {
+    info(
+      `Using ${candidates[0].definition.name} as primary agent (non-interactive).`
+    );
+    return candidates[0];
+  }
+  const chosen = await (0, import_select.default)({
+    message: "Which agent is your primary? (its instructions become the source of truth)",
+    choices: candidates.map((c) => ({
+      name: c.definition.name,
+      value: c.definition.id
+    }))
+  });
+  return candidates.find((c) => c.definition.id === chosen);
+}
+function copyPortableFiles(installed, repoDir) {
+  heading("Copying portable files...");
+  for (const agent of installed) {
+    const def = agent.definition;
+    const configDir = agent.configDir;
+    const agentRepoDir = import_node_path5.default.join(repoDir, def.id);
+    fs4.mkdirSync(agentRepoDir, { recursive: true });
+    const items = getPortableItems(def);
+    const ignoreRoots = new Set(def.ignore.map((p) => p.split("/")[0]));
+    const credBasenames = new Set(
+      def.credentials.map((c) => import_node_path5.default.basename(expandPath(c)))
+    );
+    let copied = 0;
+    for (const item of items) {
+      if (ignoreRoots.has(item) || credBasenames.has(item)) continue;
+      const sourcePath = import_node_path5.default.join(configDir, item);
+      const destPath = import_node_path5.default.join(agentRepoDir, item);
+      if (!fs4.existsSync(sourcePath)) continue;
+      if (lstatExists(sourcePath) && fs4.lstatSync(sourcePath).isSymbolicLink()) {
+        const realPath = fs4.realpathSync(sourcePath);
+        if (!fs4.existsSync(realPath)) continue;
+        const stat2 = fs4.statSync(realPath);
+        if (stat2.isDirectory()) {
+          fs4.cpSync(realPath, destPath, { recursive: true });
+        } else {
+          fs4.mkdirSync(import_node_path5.default.dirname(destPath), { recursive: true });
+          fs4.copyFileSync(realPath, destPath);
+        }
+        copied++;
+        continue;
+      }
+      const stat = fs4.statSync(sourcePath);
+      if (stat.isDirectory()) {
+        fs4.cpSync(sourcePath, destPath, { recursive: true, dereference: true });
+      } else {
+        fs4.mkdirSync(import_node_path5.default.dirname(destPath), { recursive: true });
+        fs4.copyFileSync(sourcePath, destPath);
+      }
+      copied++;
+    }
+    if (copied > 0) {
+      success(`${def.name} \u2014 copied ${copied} item(s)`);
+    } else {
+      info(`${def.name} \u2014 no portable files found`);
+    }
+  }
+}
+function syncInstructions(primary, installed, repoDir) {
+  heading("Syncing instructions...");
+  const primaryDef = primary.definition;
+  const isFileBased = primaryDef.instructions.filename.includes(".");
+  let primaryInstructionsPath;
+  if (isFileBased) {
+    primaryInstructionsPath = import_node_path5.default.join(
+      repoDir,
+      primaryDef.id,
+      primaryDef.instructions.filename
+    );
+  } else {
+    primaryInstructionsPath = import_node_path5.default.join(
+      repoDir,
+      primaryDef.id,
+      primaryDef.instructions.filename,
+      "instructions.md"
+    );
+  }
+  if (!fs4.existsSync(primaryInstructionsPath)) {
+    fs4.mkdirSync(import_node_path5.default.dirname(primaryInstructionsPath), { recursive: true });
+    fs4.writeFileSync(
+      primaryInstructionsPath,
+      "# Agent Instructions\n\nAdd your instructions here.\n",
+      "utf-8"
+    );
+    info(`Created empty instructions file for ${primaryDef.name}`);
+  }
+  success(`${primaryDef.name} \u2014 instructions file (source of truth)`);
+  for (const agent of installed) {
+    if (agent.definition.id === primaryDef.id) continue;
+    const def = agent.definition;
+    const agentRepoDir = import_node_path5.default.join(repoDir, def.id);
+    if (!def.instructions.globalSupport) {
+      warn(`${def.name} \u2014 project-level rules only, instructions not synced`);
+      continue;
+    }
+    const isTargetFileBased = def.instructions.filename.includes(".");
+    let symlinkPath;
+    if (isTargetFileBased) {
+      symlinkPath = import_node_path5.default.join(agentRepoDir, def.instructions.filename);
+    } else {
+      const targetDir = import_node_path5.default.join(agentRepoDir, def.instructions.filename);
+      fs4.mkdirSync(targetDir, { recursive: true });
+      symlinkPath = import_node_path5.default.join(targetDir, "instructions.md");
+    }
+    if (lstatExists(symlinkPath)) {
+      const stat = fs4.lstatSync(symlinkPath);
+      if (!stat.isSymbolicLink()) {
+        const backupPath = `${symlinkPath}.backup.${Date.now()}`;
+        fs4.renameSync(symlinkPath, backupPath);
+      } else {
+        fs4.unlinkSync(symlinkPath);
+      }
+    }
+    fs4.mkdirSync(import_node_path5.default.dirname(symlinkPath), { recursive: true });
+    const symlinkTarget = import_node_path5.default.relative(
+      import_node_path5.default.dirname(symlinkPath),
+      primaryInstructionsPath
+    );
+    fs4.symlinkSync(symlinkTarget, symlinkPath);
+    success(`${def.name} \u2014 ${def.instructions.filename} \u2192 ${symlinkTarget}`);
+  }
+}
+function importMCPServers(installed, repoDir) {
+  heading("Importing MCP servers...");
+  const agentDefs = installed.map((a) => a.definition);
+  const result = importAndMergeAll(agentDefs);
+  const serverCount = Object.keys(result.config.servers).length;
+  if (serverCount === 0) {
+    info("No MCP servers found in any agent configs.");
+    fs4.writeFileSync(
+      import_node_path5.default.join(repoDir, "mcp.json"),
+      JSON.stringify({ servers: {} }, null, 2) + "\n",
+      "utf-8"
+    );
+    return;
+  }
+  for (const [name, agentId] of Object.entries(result.sources)) {
+    success(`${name} \u2014 imported from ${agentId}`);
+  }
+  for (const conflict of result.conflicts) {
+    warn(
+      `${conflict.serverName} \u2014 found in ${conflict.agents.join(" and ")}, kept version from ${conflict.kept}`
+    );
+  }
+  fs4.writeFileSync(
+    import_node_path5.default.join(repoDir, "mcp.json"),
+    JSON.stringify(result.config, null, 2) + "\n",
+    "utf-8"
+  );
+  success(`Imported ${serverCount} MCP server(s) to mcp.json`);
+}
+function syncMCPToAllAgents(repoDir, installed) {
+  const mcpPath = import_node_path5.default.join(repoDir, "mcp.json");
+  if (!fs4.existsSync(mcpPath)) return;
+  let config;
+  try {
+    config = parseMCPConfig(mcpPath);
+  } catch (err) {
+    debug(`Failed to parse MCP config at ${mcpPath}: ${err.message}`);
+    return;
+  }
+  if (Object.keys(config.servers).length === 0) return;
+  heading("Syncing MCP config to agents...");
+  for (const agent of installed) {
+    const agentDef = agent.definition;
+    const result = transformForAgent(config, agentDef);
+    const configDir = expandPath(getPlatformPath(agentDef.configDir));
+    const targetPath = import_node_path5.default.join(configDir, agentDef.mcp.configPath);
+    if (result.format === "toml") {
+      writeTOML(targetPath, result.rootKey, result.servers);
+    } else if (agentDef.mcp.writeMode === "merge") {
+      mergeJSON(targetPath, result.rootKey, result.servers);
+    } else {
+      writeJSON(targetPath, result.rootKey, result.servers);
+    }
+    success(`${agentDef.name} \u2014 wrote ${dim(targetPath)}`);
+  }
+}
+async function promptGitHubRepo(repoDir) {
+  if (!process.stdin.isTTY) return;
+  try {
+    (0, import_node_child_process2.execSync)("gh --version", { stdio: "ignore" });
+  } catch {
+    info(
+      "Install GitHub CLI (gh) to create a private repo: https://cli.github.com"
+    );
+    return;
+  }
+  const shouldCreate = await (0, import_confirm.default)({
+    message: "Create a private GitHub repo and push?",
+    default: false
+  });
+  if (!shouldCreate) return;
+  const repoName = import_node_path5.default.basename(repoDir);
+  try {
+    (0, import_node_child_process2.execSync)(
+      `gh repo create ${repoName} --private --source="${repoDir}" --push`,
+      { stdio: "inherit", cwd: repoDir }
+    );
+    success(`Created and pushed to private GitHub repo: ${repoName}`);
+  } catch (err) {
+    warn(`Failed to create GitHub repo: ${err.message}`);
+    info("You can create it manually later with: gh repo create");
+  }
+}
+async function initFromRemote(url, targetDir) {
+  if (fs4.existsSync(import_node_path5.default.join(targetDir, "agents-anywhere.json"))) {
+    warn(`Config repo already exists at ${targetDir}`);
+    info("Run `agents-anywhere link` to connect your agents.");
+    return;
+  }
+  heading("Cloning config repo...");
+  const git = (0, import_simple_git.simpleGit)();
+  try {
+    await git.clone(url, targetDir);
+  } catch (err) {
+    error(`Failed to clone ${url}: ${err.message}`);
+    return;
+  }
+  if (!fs4.existsSync(import_node_path5.default.join(targetDir, "agents-anywhere.json"))) {
+    fs4.rmSync(targetDir, { recursive: true, force: true });
+    error(
+      `Not an agents-anywhere config repo: ${url} (no agents-anywhere.json found)`
+    );
+    return;
+  }
+  success(`Cloned config repo to ${targetDir}`);
+  info(
+    "Run `agents-anywhere link && agents-anywhere mcp sync` to connect your agents."
+  );
+}
+function buildManifest(installedAgents, repoDir, primaryAgentId) {
+  return {
+    version: "0.1.0",
+    repoDir,
+    primaryAgent: primaryAgentId,
+    agents: Object.fromEntries(
+      installedAgents.map((a) => [
+        a.definition.id,
+        { enabled: true, name: a.definition.name }
+      ])
+    )
+  };
+}
+
+// src/utils/manifest.ts
+var fs5 = __toESM(require("fs"));
+var import_node_path6 = __toESM(require("path"));
+var import_node_os3 = __toESM(require("os"));
+var DEFAULT_REPO_DIR2 = import_node_path6.default.join(import_node_os3.default.homedir(), "agents-anywhere-config");
+function validateManifest(data, filePath) {
+  if (typeof data !== "object" || data === null) {
+    error(`Invalid manifest in ${filePath}: expected an object`);
+    return null;
+  }
+  const obj = data;
+  if (typeof obj.version !== "string") {
+    error(`Invalid manifest in ${filePath}: "version" must be a string`);
+    return null;
+  }
+  if (typeof obj.agents !== "object" || obj.agents === null || Array.isArray(obj.agents)) {
+    error(`Invalid manifest in ${filePath}: "agents" must be an object`);
+    return null;
+  }
+  for (const [key, value] of Object.entries(
+    obj.agents
+  )) {
+    if (typeof value !== "object" || value === null) {
+      error(
+        `Invalid manifest in ${filePath}: agent "${key}" must be an object`
+      );
+      return null;
+    }
+    const agent = value;
+    if (typeof agent.enabled !== "boolean") {
+      error(
+        `Invalid manifest in ${filePath}: agent "${key}.enabled" must be a boolean`
+      );
+      return null;
+    }
+    if (typeof agent.name !== "string") {
+      error(
+        `Invalid manifest in ${filePath}: agent "${key}.name" must be a string`
+      );
+      return null;
+    }
+  }
+  return data;
+}
+function loadManifest() {
+  const candidates = [
+    import_node_path6.default.join(process.cwd(), "agents-anywhere.json"),
+    import_node_path6.default.join(DEFAULT_REPO_DIR2, "agents-anywhere.json")
+  ];
+  for (const candidate of candidates) {
+    if (fs5.existsSync(candidate)) {
+      const raw = fs5.readFileSync(candidate, "utf-8");
+      let parsed;
+      try {
+        parsed = JSON.parse(raw);
+      } catch {
+        error(`Invalid JSON in ${candidate}`);
+        return null;
+      }
+      const manifest = validateManifest(parsed, candidate);
+      if (!manifest) return null;
+      manifest.repoDir = import_node_path6.default.dirname(candidate);
+      return manifest;
+    }
+  }
+  error("No agents-anywhere.json found. Run `agents-anywhere init` first.");
+  info(`Looked in: ${candidates.join(", ")}`);
+  return null;
+}
+function saveManifest(manifest) {
+  const filePath = import_node_path6.default.join(manifest.repoDir, "agents-anywhere.json");
+  fs5.writeFileSync(filePath, JSON.stringify(manifest, null, 2) + "\n", "utf-8");
+}
+
+// src/commands/link.ts
+async function linkCommand(agentId, options = {}) {
+  const manifest = loadManifest();
+  if (!manifest) return;
+  const repoDir = manifest.repoDir;
+  const dryRun = options.dryRun ?? false;
+  const prefix = dryRun ? "[dry-run] " : "";
+  if (agentId) {
+    const agentDef = loadAgentById(agentId);
+    if (!agentDef) {
+      error(`Unknown agent: ${agentId}`);
+      const all = loadAllAgentDefinitions();
+      info("Known agents: " + all.map((a) => a.id).join(", "));
+      return;
+    }
+    if (!manifest.agents[agentId]?.enabled) {
+      warn(`Agent "${agentId}" is not enabled in agents-anywhere.json`);
+      return;
+    }
+    linkSingleAgent(agentDef, repoDir, dryRun, prefix);
+  } else {
+    heading(`${prefix}Linking agent configs...`);
+    const enabledIds = Object.entries(manifest.agents).filter(([, v]) => v.enabled).map(([id]) => id);
+    if (enabledIds.length === 0) {
+      warn("No agents enabled in agents-anywhere.json");
+      return;
+    }
+    for (const id of enabledIds) {
+      const agentDef = loadAgentById(id);
+      if (!agentDef) {
+        warn(`Agent "${id}" in manifest but no definition found \u2014 skipping`);
+        continue;
+      }
+      linkSingleAgent(agentDef, repoDir, dryRun, prefix);
+    }
+  }
+}
+function linkSingleAgent(agentDef, repoDir, dryRun, prefix) {
+  const results = linkAgent(agentDef, repoDir, dryRun);
+  if (results.length === 0) {
+    info(`${prefix}${agentDef.name} \u2014 no portable files found in repo`);
+    return;
+  }
+  const linked = results.filter((r) => r.action === "linked" || r.action === "backed-up-and-linked");
+  const skipped = results.filter((r) => r.action === "skipped");
+  const items = results.map((r) => r.item).join(", ");
+  if (linked.length > 0) {
+    success(`${prefix}${agentDef.name} \u2014 ${items} linked`);
+  } else if (results.length > 0 && skipped.length === results.length) {
+    info(`${prefix}${agentDef.name} \u2014 already linked ${dim("(skipped)")}`);
+  }
+  for (const r of results) {
+    if (r.action === "backed-up-and-linked") {
+      info(`${prefix}  backed up existing ${r.item}`);
+    }
+  }
+}
+
+// src/commands/unlink.ts
+async function unlinkCommand(agentId, options = {}) {
+  const manifest = loadManifest();
+  if (!manifest) return;
+  const repoDir = manifest.repoDir;
+  const dryRun = options.dryRun ?? false;
+  const prefix = dryRun ? "[dry-run] " : "";
+  if (agentId) {
+    const agentDef = loadAgentById(agentId);
+    if (!agentDef) {
+      error(`Unknown agent: ${agentId}`);
+      const all = loadAllAgentDefinitions();
+      info("Known agents: " + all.map((a) => a.id).join(", "));
+      return;
+    }
+    unlinkSingleAgent(agentDef, repoDir, dryRun, prefix);
+  } else {
+    heading(`${prefix}Unlinking agent configs...`);
+    const agentIds = Object.keys(manifest.agents);
+    if (agentIds.length === 0) {
+      warn("No agents in agents-anywhere.json");
+      return;
+    }
+    for (const id of agentIds) {
+      const agentDef = loadAgentById(id);
+      if (!agentDef) {
+        warn(`Agent "${id}" in manifest but no definition found \u2014 skipping`);
+        continue;
+      }
+      unlinkSingleAgent(agentDef, repoDir, dryRun, prefix);
+    }
+  }
+}
+function unlinkSingleAgent(agentDef, repoDir, dryRun, prefix) {
+  const results = unlinkAgent(agentDef, repoDir, dryRun);
+  const unlinked = results.filter((r) => r.action === "unlinked" || r.action === "restored");
+  const skipped = results.filter((r) => r.action === "skipped");
+  if (unlinked.length > 0) {
+    const items = unlinked.map((r) => r.item).join(", ");
+    success(`${prefix}${agentDef.name} \u2014 ${items} unlinked`);
+  } else if (skipped.length === results.length) {
+    info(`${prefix}${agentDef.name} \u2014 nothing to unlink`);
+  }
+  for (const r of results) {
+    if (r.action === "restored") {
+      info(`${prefix}  restored backup for ${r.item}`);
+    }
+  }
+}
+
+// src/commands/status.ts
+async function statusCommand() {
+  const manifest = loadManifest();
+  if (!manifest) return;
+  const repoDir = manifest.repoDir;
+  const agentIds = Object.keys(manifest.agents);
+  if (agentIds.length === 0) {
+    warn("No agents in agents-anywhere.json");
+    return;
+  }
+  heading("Agent link status");
+  for (const id of agentIds) {
+    const agentDef = loadAgentById(id);
+    if (!agentDef) {
+      warn(`Agent "${id}" \u2014 definition not found`);
+      continue;
+    }
+    const statuses = getStatus(agentDef, repoDir);
+    console.log(`
+  ${bold(agentDef.name)}`);
+    const rows = statuses.map((s) => [
+      s.item,
+      statusBadge(s.status)
+    ]);
+    table(rows, 4);
+  }
+  console.log();
+}
+
+// src/commands/agents.ts
+async function agentsCommand() {
+  const manifest = loadManifest();
+  const repoDir = manifest?.repoDir;
+  const agents = detectAgents();
+  heading("Known AI coding agents");
+  console.log();
+  for (const agent of agents) {
+    const id = agent.definition.id;
+    const name = agent.definition.name;
+    const installStatus = agent.installed ? statusBadge("installed") : statusBadge("not installed");
+    let linkInfo = "";
+    if (agent.installed && repoDir && manifest?.agents[id]?.enabled) {
+      const statuses = getStatus(agent.definition, repoDir);
+      const linkedCount = statuses.filter((s) => s.status === "linked").length;
+      const total = statuses.length;
+      if (linkedCount === total && total > 0) {
+        linkInfo = `  ${statusBadge("linked")}`;
+      } else if (linkedCount > 0) {
+        linkInfo = `  ${dim(`${linkedCount}/${total} linked`)}`;
+      }
+    }
+    console.log(`  ${bold(name.padEnd(16))} ${installStatus}${linkInfo}`);
+    console.log(`  ${dim(agent.configDir)}`);
+    console.log();
+  }
+}
+
+// src/commands/mcp-sync.ts
+var import_node_path7 = __toESM(require("path"));
+async function mcpSyncCommand(options = {}) {
+  const manifest = loadManifest();
+  if (!manifest) return;
+  const dryRun = options.dryRun ?? false;
+  const prefix = dryRun ? "[dry-run] " : "";
+  const mcpPath = import_node_path7.default.join(manifest.repoDir, "mcp.json");
+  let config;
+  try {
+    config = parseMCPConfig(mcpPath);
+  } catch (err) {
+    error(`Failed to parse mcp.json: ${err.message}`);
+    return;
+  }
+  const serverCount = Object.keys(config.servers).length;
+  if (serverCount === 0) {
+    warn("No servers defined in mcp.json. Use `agents-anywhere mcp add` to add one.");
+    return;
+  }
+  heading(`${prefix}Syncing MCP config to agents...`);
+  const enabledIds = Object.entries(manifest.agents).filter(([, v]) => v.enabled).map(([id]) => id);
+  if (enabledIds.length === 0) {
+    warn("No agents enabled in agents-anywhere.json");
+    return;
+  }
+  let synced = 0;
+  for (const id of enabledIds) {
+    const agentDef = loadAgentById(id);
+    if (!agentDef) {
+      warn(`Agent "${id}" in manifest but no definition found \u2014 skipping`);
+      continue;
+    }
+    const result = transformForAgent(config, agentDef);
+    const configDir = expandPath(getPlatformPath(agentDef.configDir));
+    const targetPath = import_node_path7.default.join(configDir, agentDef.mcp.configPath);
+    if (!dryRun) {
+      if (result.format === "toml") {
+        writeTOML(targetPath, result.rootKey, result.servers);
+      } else if (agentDef.mcp.writeMode === "merge") {
+        mergeJSON(targetPath, result.rootKey, result.servers);
+      } else {
+        writeJSON(targetPath, result.rootKey, result.servers);
+      }
+    }
+    success(`${prefix}${agentDef.name} \u2014 ${dryRun ? "would write" : "wrote"} ${dim(targetPath)}`);
+    synced++;
+  }
+  console.log(`
+${prefix}Synced ${serverCount} server(s) to ${synced} agent(s).`);
+}
+
+// src/commands/mcp-add.ts
+var fs6 = __toESM(require("fs"));
+var readline = __toESM(require("readline/promises"));
+var import_node_path8 = __toESM(require("path"));
+function buildServerFromFlags(flags) {
+  if (!flags.transport) return null;
+  if (flags.transport !== "stdio" && flags.transport !== "http") {
+    error(`Transport must be "stdio" or "http", got "${flags.transport}"`);
+    return null;
+  }
+  if (flags.transport === "stdio") {
+    if (!flags.command) return null;
+    const server2 = {
+      transport: "stdio",
+      command: flags.command
+    };
+    if (flags.args) {
+      server2.args = flags.args.split(",").map((a) => a.trim());
+    }
+    if (flags.env && flags.env.length > 0) {
+      server2.env = parseEnvPairs(flags.env);
+    }
+    return server2;
+  }
+  if (!flags.url) return null;
+  const server = {
+    transport: "http",
+    url: flags.url
+  };
+  if (flags.env && flags.env.length > 0) {
+    server.env = parseEnvPairs(flags.env);
+  }
+  return server;
+}
+function parseEnvPairs(pairs) {
+  const env = {};
+  for (const pair of pairs) {
+    const eqIdx = pair.indexOf("=");
+    if (eqIdx === -1) {
+      warn(`Skipping invalid env pair "${pair}" \u2014 expected KEY=VAR format`);
+      continue;
+    }
+    const key = pair.slice(0, eqIdx);
+    const varName = pair.slice(eqIdx + 1);
+    if (!key || !varName) {
+      warn(`Skipping invalid env pair "${pair}" \u2014 empty key or value`);
+      continue;
+    }
+    env[key] = { $env: varName };
+  }
+  return env;
+}
+async function ask(rl, question) {
+  const answer = await rl.question(question);
+  return answer.trim();
+}
+async function mcpAddCommand(name, flags = {}) {
+  const manifest = loadManifest();
+  if (!manifest) return;
+  const mcpPath = import_node_path8.default.join(manifest.repoDir, "mcp.json");
+  let config;
+  try {
+    config = parseMCPConfig(mcpPath);
+  } catch {
+    config = { servers: {} };
+  }
+  if (config.servers[name]) {
+    warn(`Server "${name}" already exists in mcp.json. It will be overwritten.`);
+  }
+  if (flags.transport) {
+    const serverFromFlags = buildServerFromFlags(flags);
+    if (serverFromFlags) {
+      config.servers[name] = serverFromFlags;
+      fs6.writeFileSync(mcpPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+      success(`Added server "${name}" to mcp.json`);
+      info("Run `agents-anywhere mcp sync` to generate per-agent configs.");
+    }
+    return;
+  }
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  try {
+    const transport = await ask(rl, "Transport (stdio/http): ");
+    if (transport !== "stdio" && transport !== "http") {
+      error('Transport must be "stdio" or "http"');
+      return;
+    }
+    const server = { transport };
+    if (transport === "stdio") {
+      const command = await ask(rl, "Command (e.g., npx): ");
+      if (!command) {
+        error("Command is required for stdio transport");
+        return;
+      }
+      server.command = command;
+      const argsStr = await ask(rl, "Args (comma-separated, or empty): ");
+      if (argsStr) {
+        server.args = argsStr.split(",").map((a) => a.trim());
+      }
+    } else {
+      const url = await ask(rl, "URL: ");
+      if (!url) {
+        error("URL is required for http transport");
+        return;
+      }
+      server.url = url;
+    }
+    const envVars = {};
+    info("Add environment variables (empty name to finish):");
+    while (true) {
+      const envName = await ask(rl, "  Env var name (or empty to finish): ");
+      if (!envName) break;
+      const envVar = await ask(rl, `  Shell variable for ${envName}: `);
+      if (!envVar) {
+        warn(`Skipping env var "${envName}" \u2014 no value provided`);
+        continue;
+      }
+      envVars[envName] = { $env: envVar };
+    }
+    if (Object.keys(envVars).length > 0) {
+      server.env = envVars;
+    }
+    if (transport === "http") {
+      const addAuth = await ask(rl, "Add authorization header? (y/n): ");
+      if (addAuth.toLowerCase() === "y") {
+        const tokenVar = await ask(rl, "  Token env variable name: ");
+        if (tokenVar) {
+          server.headers = {
+            Authorization: { $env: tokenVar, prefix: "Bearer " }
+          };
+        }
+      }
+    }
+    config.servers[name] = server;
+    fs6.writeFileSync(mcpPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+    success(`Added server "${name}" to mcp.json`);
+    info("Run `agents-anywhere mcp sync` to generate per-agent configs.");
+  } finally {
+    rl.close();
+  }
+}
+
+// src/commands/mcp-list.ts
+var import_node_path9 = __toESM(require("path"));
+async function mcpListCommand() {
+  const manifest = loadManifest();
+  if (!manifest) return;
+  const mcpPath = import_node_path9.default.join(manifest.repoDir, "mcp.json");
+  let config;
+  try {
+    config = parseMCPConfig(mcpPath);
+  } catch (err) {
+    error(`Failed to parse mcp.json: ${err.message}`);
+    return;
+  }
+  const servers = Object.entries(config.servers);
+  if (servers.length === 0) {
+    warn("No MCP servers configured. Use `agents-anywhere mcp add` to add one.");
+    return;
+  }
+  heading(`MCP Servers (${servers.length})`);
+  const rows = [];
+  for (const [name, server] of servers) {
+    const target = server.transport === "stdio" ? `${server.command}${server.args?.length ? " " + server.args.join(" ") : ""}` : server.url ?? "";
+    const envVars = server.env ? Object.values(server.env).map((ref) => ref.$env).join(", ") : "";
+    const headerVars = server.headers ? Object.values(server.headers).map((ref) => ref.$env).join(", ") : "";
+    rows.push([bold(name), `${server.transport}  ${dim(target)}`]);
+    if (envVars) {
+      rows.push(["", `env: ${envVars}`]);
+    }
+    if (headerVars) {
+      rows.push(["", `headers: ${headerVars}`]);
+    }
+  }
+  table(rows);
+}
+
+// src/commands/mcp-diff.ts
+var fs7 = __toESM(require("fs"));
+var import_node_path10 = __toESM(require("path"));
+var TOML3 = __toESM(require("smol-toml"));
+function readExistingServers(agentDef, targetPath) {
+  if (!fs7.existsSync(targetPath)) {
+    return null;
+  }
+  const raw = fs7.readFileSync(targetPath, "utf-8");
+  const format = agentDef.mcp.format ?? "json";
+  if (format === "toml") {
+    const parsed2 = TOML3.parse(raw);
+    const section2 = parsed2[agentDef.mcp.serverSection ?? agentDef.mcp.rootKey];
+    if (!section2 || typeof section2 !== "object") return {};
+    return section2;
+  }
+  const parsed = JSON.parse(raw);
+  const rootKey = agentDef.mcp.rootKey;
+  const section = parsed[rootKey];
+  if (!section || typeof section !== "object") return {};
+  return section;
+}
+function diffServers(existing, incoming) {
+  const diff = { added: [], removed: [], changed: [], unchanged: [] };
+  if (existing === null) {
+    diff.added = Object.keys(incoming);
+    return diff;
+  }
+  const existingNames = new Set(Object.keys(existing));
+  const incomingNames = new Set(Object.keys(incoming));
+  for (const name of incomingNames) {
+    if (!existingNames.has(name)) {
+      diff.added.push(name);
+    } else {
+      const existingStr = JSON.stringify(existing[name], null, 2);
+      const incomingStr = JSON.stringify(incoming[name], null, 2);
+      if (existingStr === incomingStr) {
+        diff.unchanged.push(name);
+      } else {
+        diff.changed.push(name);
+      }
+    }
+  }
+  for (const name of existingNames) {
+    if (!incomingNames.has(name)) {
+      diff.removed.push(name);
+    }
+  }
+  return diff;
+}
+async function mcpDiffCommand() {
+  const manifest = loadManifest();
+  if (!manifest) return;
+  const mcpPath = import_node_path10.default.join(manifest.repoDir, "mcp.json");
+  let config;
+  try {
+    config = parseMCPConfig(mcpPath);
+  } catch (err) {
+    error(`Failed to parse mcp.json: ${err.message}`);
+    return;
+  }
+  const serverCount = Object.keys(config.servers).length;
+  if (serverCount === 0) {
+    warn("No servers defined in mcp.json. Use `agents-anywhere mcp add` to add one.");
+    return;
+  }
+  const enabledIds = Object.entries(manifest.agents).filter(([, v]) => v.enabled).map(([id]) => id);
+  if (enabledIds.length === 0) {
+    warn("No agents enabled in agents-anywhere.json");
+    return;
+  }
+  heading("MCP diff \u2014 previewing sync changes...");
+  let anyChanges = false;
+  for (const id of enabledIds) {
+    const agentDef = loadAgentById(id);
+    if (!agentDef) {
+      warn(`Agent "${id}" in manifest but no definition found \u2014 skipping`);
+      continue;
+    }
+    const result = transformForAgent(config, agentDef);
+    const configDir = expandPath(getPlatformPath(agentDef.configDir));
+    const targetPath = import_node_path10.default.join(configDir, agentDef.mcp.configPath);
+    const existing = readExistingServers(agentDef, targetPath);
+    const diff = diffServers(existing, result.servers);
+    const hasChanges = diff.added.length > 0 || diff.removed.length > 0 || diff.changed.length > 0;
+    if (!hasChanges && existing !== null) {
+      success(`${agentDef.name} \u2014 ${dim("up to date")}`);
+      continue;
+    }
+    anyChanges = true;
+    if (existing === null) {
+      console.log(`
+  ${bold(agentDef.name)} ${dim(`(${targetPath})`)}`);
+      console.log(`    ${dim("File does not exist \u2014 will be created")}`);
+    } else {
+      console.log(`
+  ${bold(agentDef.name)} ${dim(`(${targetPath})`)}`);
+    }
+    for (const name of diff.added) {
+      console.log(`    ${green("+ " + name)}`);
+    }
+    for (const name of diff.removed) {
+      console.log(`    ${red("- " + name)}`);
+    }
+    for (const name of diff.changed) {
+      console.log(`    ${yellow("~ " + name)}`);
+    }
+  }
+  console.log();
+  if (!anyChanges) {
+    success("All agents up to date");
+  } else {
+    console.log(`Run ${bold("agents-anywhere mcp sync")} to apply these changes.`);
+  }
+}
+
+// src/commands/doctor.ts
+var fs8 = __toESM(require("fs"));
+var import_node_path11 = __toESM(require("path"));
+function checkBrokenSymlinks(agents, repoDir) {
+  const issues = [];
+  for (const { id, def } of agents) {
+    const configDir = expandPath(getPlatformPath(def.configDir));
+    const items = getPortableItems(def);
+    for (const item of items) {
+      const agentPath = import_node_path11.default.join(configDir, item);
+      try {
+        const stat = fs8.lstatSync(agentPath);
+        if (stat.isSymbolicLink()) {
+          const target = fs8.readlinkSync(agentPath);
+          const resolved = import_node_path11.default.resolve(import_node_path11.default.dirname(agentPath), target);
+          if (!fs8.existsSync(resolved)) {
+            issues.push({
+              agent: def.name,
+              message: `${item} \u2192 ${resolved} (target missing)`,
+              fix: `Run \`agents-anywhere unlink ${id} && agents-anywhere link ${id}\``
+            });
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  return issues;
+}
+function checkCredentialsInRepo(agents, repoDir) {
+  const issues = [];
+  for (const { def } of agents) {
+    for (const credPath of def.credentials) {
+      const credFileName = import_node_path11.default.basename(expandPath(credPath));
+      const inRoot = import_node_path11.default.join(repoDir, credFileName);
+      if (fs8.existsSync(inRoot)) {
+        issues.push({
+          agent: def.name,
+          message: `${credFileName} found at repo root`,
+          fix: `Remove ${inRoot} and add to .gitignore`
+        });
+      }
+      const inAgentDir = import_node_path11.default.join(repoDir, def.id, credFileName);
+      if (fs8.existsSync(inAgentDir)) {
+        issues.push({
+          agent: def.name,
+          message: `${credFileName} found in ${def.id}/ directory`,
+          fix: `Remove ${inAgentDir} and add to .gitignore`
+        });
+      }
+    }
+  }
+  return issues;
+}
+function checkStaleConfigs(agents, repoDir) {
+  const issues = [];
+  for (const { id, def } of agents) {
+    const configDir = expandPath(getPlatformPath(def.configDir));
+    const agentRepoDir = import_node_path11.default.join(repoDir, id);
+    const items = getPortableItems(def);
+    for (const item of items) {
+      const agentPath = import_node_path11.default.join(configDir, item);
+      const repoPath = import_node_path11.default.join(agentRepoDir, item);
+      try {
+        const stat = fs8.lstatSync(agentPath);
+        if (stat.isSymbolicLink() && !fs8.existsSync(repoPath)) {
+          issues.push({
+            agent: def.name,
+            message: `${item} is linked but missing from repo`,
+            fix: `Run \`agents-anywhere unlink ${id}\` to clean up, then re-add the file`
+          });
+        }
+      } catch {
+      }
+    }
+  }
+  return issues;
+}
+function checkMCPFreshness(agents, repoDir) {
+  const issues = [];
+  const mcpJsonPath = import_node_path11.default.join(repoDir, "mcp.json");
+  if (!fs8.existsSync(mcpJsonPath)) {
+    return issues;
+  }
+  const mcpMtime = fs8.statSync(mcpJsonPath).mtimeMs;
+  for (const { def } of agents) {
+    const configDir = expandPath(getPlatformPath(def.configDir));
+    const generatedPath = import_node_path11.default.join(configDir, def.mcp.configPath);
+    if (fs8.existsSync(generatedPath)) {
+      const genMtime = fs8.statSync(generatedPath).mtimeMs;
+      if (genMtime < mcpMtime) {
+        issues.push({
+          agent: def.name,
+          message: `${def.mcp.configPath} is older than mcp.json`,
+          fix: "Run `agents-anywhere mcp sync` to regenerate"
+        });
+      }
+    }
+  }
+  return issues;
+}
+async function doctorCommand() {
+  const manifest = loadManifest();
+  if (!manifest) return;
+  const repoDir = manifest.repoDir;
+  const enabledIds = Object.entries(manifest.agents).filter(([, v]) => v.enabled).map(([id]) => id);
+  if (enabledIds.length === 0) {
+    warn("No agents enabled in agents-anywhere.json");
+    return;
+  }
+  heading("agents-anywhere doctor");
+  console.log();
+  const agents = enabledIds.map((id) => ({ id, def: loadAgentById(id) })).filter(
+    (a) => a.def !== void 0
+  );
+  const checks = [
+    { name: "Broken symlinks", issues: checkBrokenSymlinks(agents, repoDir) },
+    {
+      name: "Credentials in repo",
+      issues: checkCredentialsInRepo(agents, repoDir)
+    },
+    { name: "Stale configs", issues: checkStaleConfigs(agents, repoDir) },
+    {
+      name: "MCP config freshness",
+      issues: checkMCPFreshness(agents, repoDir)
+    }
+  ];
+  let totalIssues = 0;
+  for (const check of checks) {
+    if (check.issues.length === 0) {
+      success(check.name);
+    } else {
+      error(check.name);
+      for (const issue of check.issues) {
+        console.log(`    ${issue.agent}: ${issue.message}`);
+        console.log(`    ${dim(`Fix: ${issue.fix}`)}`);
+      }
+      totalIssues += check.issues.length;
+    }
+  }
+  console.log();
+  if (totalIssues === 0) {
+    success("All checks passed \u2014 config is healthy");
+  } else {
+    warn(`${totalIssues} issue(s) found`);
+  }
+}
+
+// src/commands/validate.ts
+var import_node_fs4 = require("fs");
+var import_node_path12 = __toESM(require("path"));
+async function validateCommand() {
+  heading("Validating agent definitions");
+  const agentsDir = getAgentsDir();
+  const files = (0, import_node_fs4.readdirSync)(agentsDir).filter((f) => f.endsWith(".json"));
+  let totalErrors = 0;
+  for (const file of files) {
+    const filePath = import_node_path12.default.join(agentsDir, file);
+    try {
+      const raw = (0, import_node_fs4.readFileSync)(filePath, "utf-8");
+      const parsed = JSON.parse(raw);
+      const result = validateAgainstSchema(parsed);
+      if (result.valid) {
+        success(`${file} \u2014 valid`);
+      } else {
+        error(`${file} \u2014 ${result.errors.length} error(s)`);
+        for (const err of result.errors) {
+          console.log(`    ${err.path}: ${err.message}`);
+        }
+        totalErrors += result.errors.length;
+      }
+    } catch (err) {
+      error(`${file} \u2014 failed to parse: ${err.message}`);
+      totalErrors++;
+    }
+  }
+  console.log();
+  if (totalErrors === 0) {
+    info(`All ${files.length} agent definitions are valid.`);
+  } else {
+    info(`${totalErrors} error(s) found across agent definitions.`);
+    process.exitCode = 1;
+  }
+}
+
+// src/commands/export.ts
+var fs9 = __toESM(require("fs"));
+var import_node_path13 = __toESM(require("path"));
+var import_node_os4 = __toESM(require("os"));
+var TOML4 = __toESM(require("smol-toml"));
+async function exportCommand() {
+  const manifest = loadManifest();
+  if (!manifest) return;
+  const mcpPath = import_node_path13.default.join(manifest.repoDir, "mcp.json");
+  let config;
+  try {
+    config = parseMCPConfig(mcpPath);
+  } catch (err) {
+    error(`Failed to parse mcp.json: ${err.message}`);
+    return;
+  }
+  const mcpRaw = fs9.readFileSync(mcpPath, "utf-8");
+  const enabledIds = Object.entries(manifest.agents).filter(([, v]) => v.enabled).map(([id]) => id);
+  if (enabledIds.length === 0) {
+    warn("No agents enabled in agents-anywhere.json");
+    return;
+  }
+  const agents = [];
+  for (const id of enabledIds) {
+    const agentDef = loadAgentById(id);
+    if (!agentDef) {
+      warn(`Agent "${id}" in manifest but no definition found \u2014 skipping`);
+      continue;
+    }
+    const result = transformForAgent(config, agentDef);
+    const configDir = expandPath(getPlatformPath(agentDef.configDir));
+    const mcpTargetPath = import_node_path13.default.join(configDir, agentDef.mcp.configPath);
+    let serialized;
+    if (result.format === "toml") {
+      serialized = TOML4.stringify({ [result.rootKey]: result.servers }) + "\n";
+    } else {
+      serialized = JSON.stringify({ [result.rootKey]: result.servers }, null, 2) + "\n";
+    }
+    agents.push({
+      agentDef,
+      configDir,
+      mcpTargetPath,
+      mcpContent: serialized,
+      portableItems: getPortableItems(agentDef)
+    });
+  }
+  const script = generateExportScript(manifest.repoDir, mcpRaw, agents);
+  process.stdout.write(script);
+}
+function makePortablePath(p) {
+  const normalized = p.replace(/\\/g, "/");
+  const home = import_node_os4.default.homedir().replace(/\\/g, "/");
+  if (normalized.startsWith(home + "/") || normalized === home) {
+    return "$HOME" + normalized.slice(home.length);
+  }
+  return normalized;
+}
+function safeDelimiter(base, content) {
+  let delimiter = base;
+  while (content.includes(`
+${delimiter}
+`) || content.startsWith(`${delimiter}
+`) || content.endsWith(`
+${delimiter}`)) {
+    delimiter = `${base}_${Math.random().toString(36).slice(2, 8).toUpperCase()}`;
+  }
+  return delimiter;
+}
+function generateExportScript(repoDir, mcpRaw, agents) {
+  const lines = [];
+  lines.push("#!/bin/bash");
+  lines.push("# Generated by agents-anywhere export");
+  lines.push(
+    "# Sets up agent configs without requiring agents-anywhere to be installed."
+  );
+  lines.push("# Usage: bash install.sh");
+  lines.push("");
+  lines.push("set -euo pipefail");
+  lines.push("");
+  const portableRepoDir = makePortablePath(repoDir);
+  lines.push(`REPO_DIR="${portableRepoDir}"`);
+  lines.push("");
+  lines.push("# Create config repo directory structure");
+  lines.push('mkdir -p "$REPO_DIR"');
+  for (const agent of agents) {
+    lines.push(`mkdir -p "$REPO_DIR/${agent.agentDef.id}"`);
+  }
+  lines.push("");
+  const mcpDelimiter = safeDelimiter("AGENTSYNC_MCP_EOF", mcpRaw);
+  lines.push("# Write normalized mcp.json");
+  lines.push(`cat > "$REPO_DIR/mcp.json" << '${mcpDelimiter}'`);
+  lines.push(mcpRaw.trimEnd());
+  lines.push(mcpDelimiter);
+  lines.push("");
+  for (const agent of agents) {
+    const eofBase = `AGENTSYNC_EOF_${agent.agentDef.id.toUpperCase().replace(/-/g, "_")}`;
+    const eof = safeDelimiter(eofBase, agent.mcpContent);
+    const portableConfigDir = makePortablePath(agent.configDir);
+    const portableMcpTarget = makePortablePath(agent.mcpTargetPath);
+    lines.push(`# --- ${agent.agentDef.name} ---`);
+    lines.push(`AGENT_CONFIG_DIR="${portableConfigDir}"`);
+    lines.push('mkdir -p "$AGENT_CONFIG_DIR"');
+    lines.push("");
+    lines.push(`cat > "${portableMcpTarget}" << '${eof}'`);
+    lines.push(agent.mcpContent.trimEnd());
+    lines.push(eof);
+    lines.push("");
+    if (agent.portableItems.length > 0) {
+      lines.push(`# Symlinks for ${agent.agentDef.name}`);
+      for (const item of agent.portableItems) {
+        lines.push(
+          `if [ -e "$REPO_DIR/${agent.agentDef.id}/${item}" ]; then`
+        );
+        lines.push(`  DEST="$AGENT_CONFIG_DIR/${item}"`);
+        lines.push(`  SRC="$REPO_DIR/${agent.agentDef.id}/${item}"`);
+        lines.push('  if [ -L "$DEST" ]; then');
+        lines.push('    rm "$DEST"');
+        lines.push('  elif [ -e "$DEST" ]; then');
+        lines.push('    mv "$DEST" "$DEST.backup.$(date +%s)"');
+        lines.push("  fi");
+        lines.push('  ln -s "$SRC" "$DEST"');
+        lines.push("fi");
+      }
+      lines.push("");
+    }
+    lines.push(`echo "Done: ${agent.agentDef.name}"`);
+    lines.push("");
+  }
+  lines.push(`echo "${agents.length} agent(s) configured from $REPO_DIR"`);
+  return lines.join("\n") + "\n";
+}
+
+// src/commands/enable.ts
+async function enableCommand(agentId) {
+  const manifest = loadManifest();
+  if (!manifest) return;
+  const agentDef = await loadAgentById(agentId);
+  if (!agentDef) {
+    error(`Unknown agent: ${agentId}`);
+    const all = await loadAllAgentDefinitions();
+    info("Known agents: " + all.map((a) => a.id).join(", "));
+    return;
+  }
+  const entry = manifest.agents[agentId];
+  if (!entry) {
+    manifest.agents[agentId] = { enabled: true, name: agentDef.name };
+    saveManifest(manifest);
+    success(`Enabled ${agentDef.name} (added to manifest)`);
+    return;
+  }
+  if (entry.enabled) {
+    info(`${agentDef.name} is already enabled`);
+    return;
+  }
+  entry.enabled = true;
+  saveManifest(manifest);
+  success(`Enabled ${agentDef.name}`);
+}
+
+// src/commands/disable.ts
+async function disableCommand(agentId) {
+  const manifest = loadManifest();
+  if (!manifest) return;
+  const agentDef = await loadAgentById(agentId);
+  if (!agentDef) {
+    error(`Unknown agent: ${agentId}`);
+    const all = await loadAllAgentDefinitions();
+    info("Known agents: " + all.map((a) => a.id).join(", "));
+    return;
+  }
+  const entry = manifest.agents[agentId];
+  if (!entry) {
+    error(`Agent "${agentId}" is not in the manifest. Run \`agents-anywhere init\` first.`);
+    return;
+  }
+  if (!entry.enabled) {
+    info(`${agentDef.name} is already disabled`);
+    return;
+  }
+  entry.enabled = false;
+  saveManifest(manifest);
+  success(`Disabled ${agentDef.name}`);
+}
+
+// src/commands/mcp-remove.ts
+var fs10 = __toESM(require("fs"));
+var import_node_path14 = __toESM(require("path"));
+async function mcpRemoveCommand(name) {
+  const manifest = loadManifest();
+  if (!manifest) return;
+  const mcpPath = import_node_path14.default.join(manifest.repoDir, "mcp.json");
+  let config;
+  try {
+    config = parseMCPConfig(mcpPath);
+  } catch (err) {
+    error(`Failed to parse mcp.json: ${err.message}`);
+    return;
+  }
+  if (!config.servers[name]) {
+    warn(`Server "${name}" not found in mcp.json`);
+    return;
+  }
+  delete config.servers[name];
+  fs10.writeFileSync(mcpPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  success(`Removed server "${name}" from mcp.json`);
+  info("Run `agents-anywhere mcp sync` to update per-agent configs.");
+}
+
+// src/commands/push.ts
+var import_simple_git2 = require("simple-git");
+async function pushCommand(opts = {}) {
+  const manifest = loadManifest();
+  if (!manifest) return;
+  const git = (0, import_simple_git2.simpleGit)(manifest.repoDir);
+  const status = await git.status();
+  if (status.isClean()) {
+    info("No changes to push.");
+    return;
+  }
+  heading("Changes to commit:");
+  const categories = [
+    [status.created, "new file", green],
+    [status.not_added, "new file", green],
+    [status.modified, "modified", yellow],
+    [status.deleted, "deleted", red],
+    [status.renamed.map((r) => `${r.from} \u2192 ${r.to}`), "renamed", cyan]
+  ];
+  for (const [files, label, colorFn] of categories) {
+    for (const file of files) {
+      console.log(`  ${colorFn(label)}:  ${file}`);
+    }
+  }
+  console.log();
+  if (opts.dryRun) {
+    info("Dry run \u2014 no changes made.");
+    return;
+  }
+  try {
+    await git.add("-A");
+    const commitMsg = opts.message ?? "Update agent configs";
+    const summary = await git.commit(commitMsg);
+    success(
+      `Committed: ${summary.summary.changes} file(s) changed`
+    );
+  } catch (err) {
+    error(`Commit failed: ${err.message}`);
+    return;
+  }
+  try {
+    const remotes = await git.getRemotes();
+    if (remotes.length === 0) {
+      warn("No remote configured. Add one with: git remote add origin <url>");
+      return;
+    }
+    await git.push();
+    success("Pushed to remote.");
+  } catch (err) {
+    error(`Push failed: ${err.message}`);
+  }
+}
+
+// src/commands/pull.ts
+var import_simple_git3 = require("simple-git");
+async function pullCommand() {
+  const manifest = loadManifest();
+  if (!manifest) return;
+  const git = (0, import_simple_git3.simpleGit)(manifest.repoDir);
+  heading("Pulling config changes...");
+  try {
+    const remotes = await git.getRemotes();
+    if (remotes.length === 0) {
+      error(
+        "No remote configured. Add one with: git remote add origin <url>"
+      );
+      return;
+    }
+    const result = await git.pull();
+    if (result.summary.changes === 0) {
+      info("Already up to date.");
+    } else {
+      success(
+        `Pulled ${result.summary.changes} change(s). Post-merge hook will re-link configs.`
+      );
+    }
+  } catch (err) {
+    error(`Pull failed: ${err.message}`);
+  }
+}
+
+// src/cli.ts
+var program = new import_commander.Command();
+program.name("agents-anywhere").description(
+  "Your AI agent configs, skills, and instructions \u2014 on every device."
+).version(version).option("--verbose", "Show debug output for troubleshooting");
+program.hook("preAction", () => {
+  if (program.opts().verbose) {
+    setVerbose(true);
+  }
+});
+program.command("init").description(
+  "Detect installed agents, create config repo, and scaffold structure"
+).argument("[dir]", "Config repo directory (default: ~/agents-anywhere-config)").option("--from <url>", "Clone an existing agents-anywhere config repo from a git URL").action(async (dir, opts) => {
+  await initCommand(dir, { from: opts?.from });
+});
+program.command("link [agent]").description("Link agent configs from central repo to agent config dirs").option("--dry-run", "Show what would be linked without making changes").action(async (agent, opts) => {
+  await linkCommand(agent, { dryRun: opts.dryRun });
+});
+program.command("unlink [agent]").description("Unlink agent configs and restore backups").option("--dry-run", "Show what would be unlinked without making changes").action(async (agent, opts) => {
+  await unlinkCommand(agent, { dryRun: opts.dryRun });
+});
+program.command("status").description("Show link status for all agents and their config files").action(async () => {
+  await statusCommand();
+});
+program.command("agents").description("List all known agents with install and link status").action(async () => {
+  await agentsCommand();
+});
+program.command("enable <agent>").description("Enable an agent in the manifest").action(async (agent) => {
+  await enableCommand(agent);
+});
+program.command("disable <agent>").description("Disable an agent in the manifest").action(async (agent) => {
+  await disableCommand(agent);
+});
+program.command("doctor").description("Diagnose config health: broken symlinks, credentials, stale configs").action(async () => {
+  await doctorCommand();
+});
+program.command("validate").description("Validate all bundled agent definition JSON files against the schema").action(async () => {
+  await validateCommand();
+});
+program.command("export").description(
+  "Generate a standalone install script (pure bash, no agents-anywhere needed)"
+).action(async () => {
+  await exportCommand();
+});
+program.command("push").description("Stage, commit, and push config changes to remote").option("--dry-run", "Show what would be committed without making changes").option("-m, --message <msg>", "Custom commit message").action(async (opts) => {
+  await pushCommand(opts);
+});
+program.command("pull").description("Pull config changes from remote (post-merge hook re-links)").action(async () => {
+  await pullCommand();
+});
+var mcp = program.command("mcp").description("MCP server configuration management");
+mcp.command("sync").description(
+  "Generate per-agent MCP configs from the normalized mcp.json"
+).option("--dry-run", "Show what would be written without making changes").action(async (opts) => {
+  await mcpSyncCommand({ dryRun: opts.dryRun });
+});
+mcp.command("add <name>").description("Add an MCP server to the normalized mcp.json").option("--transport <type>", "Transport type: stdio or http").option("--command <cmd>", "Command to run (stdio transport)").option("--url <url>", "Server URL (http transport)").option("--args <csv>", "Comma-separated arguments (stdio transport)").option("--env <pair...>", "Environment variables as KEY=VAR pairs").action(async (name, opts) => {
+  await mcpAddCommand(name, opts);
+});
+mcp.command("remove <name>").description("Remove an MCP server from mcp.json").action(async (name) => {
+  await mcpRemoveCommand(name);
+});
+mcp.command("diff").description("Preview what `mcp sync` would change for each agent").action(async () => {
+  await mcpDiffCommand();
+});
+mcp.command("list").description("List all configured MCP servers").action(async () => {
+  await mcpListCommand();
+});
+program.parseAsync().catch((err) => {
+  console.error(err.message);
+  process.exit(1);
+});