@agenticmail/claudecode 0.1.0

package/dist/chunk-UPA2YLSM.js

@@ -0,0 +1,91 @@
+import {
+  install
+} from "./chunk-P2DXF7DO.js";
+import {
+  status
+} from "./chunk-RI4USTMC.js";
+import {
+  uninstall
+} from "./chunk-ULKJ773Y.js";
+import {
+  AgenticMailApiError
+} from "./chunk-XAW5NUNU.js";
+
+// src/http-routes.ts
+import { Router } from "express";
+function sanitizeInstallBody(body) {
+  if (!body || typeof body !== "object") return {};
+  const b = body;
+  const out = {};
+  if (typeof b.apiUrl === "string") out.apiUrl = b.apiUrl;
+  if (typeof b.masterKey === "string") out.masterKey = b.masterKey;
+  if (typeof b.claudeConfigPath === "string") out.claudeConfigPath = b.claudeConfigPath;
+  if (typeof b.agentsDir === "string") out.agentsDir = b.agentsDir;
+  if (typeof b.mcpServerName === "string") out.mcpServerName = b.mcpServerName;
+  if (typeof b.bridgeAgentName === "string") out.bridgeAgentName = b.bridgeAgentName;
+  if (typeof b.subagentPrefix === "string") out.subagentPrefix = b.subagentPrefix;
+  if (typeof b.mcpCommand === "string") out.mcpCommand = b.mcpCommand;
+  if (Array.isArray(b.mcpArgs) && b.mcpArgs.every((a) => typeof a === "string")) {
+    out.mcpArgs = b.mcpArgs;
+  }
+  return out;
+}
+function sanitizeUninstallBody(body) {
+  const base = sanitizeInstallBody(body);
+  if (body && typeof body === "object" && body.purgeBridgeAgent === true) {
+    base.purgeBridgeAgent = true;
+  }
+  return base;
+}
+function handleError(err, res) {
+  if (err instanceof AgenticMailApiError) {
+    const code = err.status === 0 ? 503 : err.status;
+    res.status(code).json({ error: err.message });
+    return;
+  }
+  const msg = err instanceof Error ? err.message : String(err);
+  res.status(500).json({ error: msg });
+}
+function createIntegrationRoutes() {
+  const router = Router();
+  router.get("/integrations/claudecode/status", async (_req, res) => {
+    try {
+      const result = await status();
+      res.json(result);
+    } catch (err) {
+      handleError(err, res);
+    }
+  });
+  router.post("/integrations/claudecode/install", async (req, res) => {
+    try {
+      const body = sanitizeInstallBody(req.body);
+      const result = await install(body);
+      const safeRegisteredAgents = result.registeredAgents.map((a) => ({
+        ...a,
+        apiKey: "***redacted***"
+      }));
+      const safeBridge = { ...result.bridgeAgent, apiKey: "***redacted***" };
+      res.status(200).json({
+        ...result,
+        registeredAgents: safeRegisteredAgents,
+        bridgeAgent: safeBridge
+      });
+    } catch (err) {
+      handleError(err, res);
+    }
+  });
+  router.post("/integrations/claudecode/uninstall", async (req, res) => {
+    try {
+      const body = sanitizeUninstallBody(req.body);
+      const result = await uninstall(body);
+      res.status(200).json(result);
+    } catch (err) {
+      handleError(err, res);
+    }
+  });
+  return router;
+}
+
+export {
+  createIntegrationRoutes
+};

package/dist/chunk-US5FT2UB.js

@@ -0,0 +1,151 @@
+// src/claude-config.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync } from "fs";
+import { dirname } from "path";
+function readClaudeConfig(path) {
+  if (!existsSync(path)) return {};
+  const raw = readFileSync(path, "utf-8");
+  if (!raw.trim()) return {};
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+    return {};
+  } catch (err) {
+    throw new Error(
+      `Could not parse Claude Code config at ${path}: ${err.message}. Refusing to overwrite \u2014 please fix the file by hand and retry.`
+    );
+  }
+}
+function writeClaudeConfig(path, config) {
+  const dir = dirname(path);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  const text = JSON.stringify(config, null, 2) + "\n";
+  const tmp = `${path}.agenticmail-tmp`;
+  writeFileSync(tmp, text, "utf-8");
+  renameSync(tmp, path);
+}
+function upsertMcpServer(path, serverName, entry) {
+  const config = readClaudeConfig(path);
+  const servers = config.mcpServers ?? {};
+  const existing = servers[serverName];
+  if (existing && deepEqual(existing, entry)) return false;
+  servers[serverName] = entry;
+  config.mcpServers = servers;
+  writeClaudeConfig(path, config);
+  return true;
+}
+function removeMcpServer(path, serverName) {
+  if (!existsSync(path)) return false;
+  const config = readClaudeConfig(path);
+  if (!config.mcpServers || !(serverName in config.mcpServers)) return false;
+  delete config.mcpServers[serverName];
+  writeClaudeConfig(path, config);
+  return true;
+}
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (typeof a !== typeof b) return false;
+  if (a && b && typeof a === "object") {
+    if (Array.isArray(a) !== Array.isArray(b)) return false;
+    if (Array.isArray(a) && Array.isArray(b)) {
+      if (a.length !== b.length) return false;
+      for (let i = 0; i < a.length; i++) {
+        if (!deepEqual(a[i], b[i])) return false;
+      }
+      return true;
+    }
+    const ao = a;
+    const bo = b;
+    const ak = Object.keys(ao).sort();
+    const bk = Object.keys(bo).sort();
+    if (ak.length !== bk.length) return false;
+    for (let i = 0; i < ak.length; i++) {
+      if (ak[i] !== bk[i]) return false;
+      if (!deepEqual(ao[ak[i]], bo[bk[i]])) return false;
+    }
+    return true;
+  }
+  return false;
+}
+
+// src/pm2.ts
+import { execFileSync, spawnSync } from "child_process";
+import { existsSync as existsSync2 } from "fs";
+var DISPATCHER_PM2_NAME = "agenticmail-claudecode-dispatcher";
+function pm2Available() {
+  const r = spawnSync("pm2", ["--version"], { stdio: "ignore" });
+  return r.status === 0;
+}
+function getDispatcherStatus() {
+  if (!pm2Available()) return null;
+  let raw;
+  try {
+    raw = execFileSync("pm2", ["jlist"], { encoding: "utf-8" });
+  } catch {
+    return null;
+  }
+  let list;
+  try {
+    list = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  for (const proc of list) {
+    if (proc.name !== DISPATCHER_PM2_NAME) continue;
+    const pm2_env = proc.pm2_env ?? {};
+    const monit = proc.monit ?? {};
+    return {
+      name: DISPATCHER_PM2_NAME,
+      pid: typeof proc.pid === "number" ? proc.pid : 0,
+      status: typeof pm2_env.status === "string" ? pm2_env.status : "unknown",
+      restartCount: typeof pm2_env.restart_time === "number" ? pm2_env.restart_time : 0,
+      uptime: typeof pm2_env.pm_uptime === "number" ? pm2_env.pm_uptime : 0,
+      // monit fields (cpu, memory) are available if we ever want them.
+      ...monit ? {} : {}
+    };
+  }
+  return null;
+}
+function startDispatcher(opts) {
+  if (!pm2Available()) return { started: false, reason: "pm2 is not installed (npm install -g pm2)" };
+  if (!existsSync2(opts.binPath)) return { started: false, reason: `dispatcher bin not found at ${opts.binPath}` };
+  const existing = getDispatcherStatus();
+  if (existing) {
+    spawnSync("pm2", ["delete", DISPATCHER_PM2_NAME], { stdio: "ignore" });
+  }
+  const r = spawnSync("pm2", [
+    "start",
+    opts.binPath,
+    "--name",
+    DISPATCHER_PM2_NAME,
+    // Restart with exponential backoff up to 10 retries before giving up.
+    // The dispatcher's internal SSE reconnect logic handles transient
+    // network errors; pm2 catches process-level crashes.
+    "--max-restarts",
+    "10",
+    "--restart-delay",
+    "2000",
+    "--update-env"
+  ], {
+    env: { ...process.env, ...opts.env },
+    stdio: "inherit"
+  });
+  if (r.status !== 0) return { started: false, reason: `pm2 start exited ${r.status}` };
+  spawnSync("pm2", ["save"], { stdio: "ignore" });
+  return { started: true };
+}
+function stopDispatcher() {
+  if (!pm2Available()) return { stopped: false };
+  if (!getDispatcherStatus()) return { stopped: false };
+  spawnSync("pm2", ["delete", DISPATCHER_PM2_NAME], { stdio: "ignore" });
+  spawnSync("pm2", ["save"], { stdio: "ignore" });
+  return { stopped: true };
+}
+
+export {
+  readClaudeConfig,
+  upsertMcpServer,
+  removeMcpServer,
+  getDispatcherStatus,
+  startDispatcher,
+  stopDispatcher
+};

package/dist/chunk-XAW5NUNU.js

@@ -0,0 +1,269 @@
+// src/api.ts
+var AgenticMailApiError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "AgenticMailApiError";
+  }
+};
+async function request(apiUrl, masterKey, path, opts = {}) {
+  if (!masterKey) {
+    throw new AgenticMailApiError(0, "AgenticMail master key is required \u2014 could not find one in ~/.agenticmail/config.json.");
+  }
+  const url = `${apiUrl.replace(/\/$/, "")}/api/agenticmail${path}`;
+  const headers = { "Authorization": `Bearer ${masterKey}` };
+  if (opts.body !== void 0) headers["Content-Type"] = "application/json";
+  let res;
+  try {
+    res = await fetch(url, {
+      method: opts.method ?? "GET",
+      headers,
+      body: opts.body !== void 0 ? JSON.stringify(opts.body) : void 0,
+      signal: AbortSignal.timeout(opts.timeoutMs ?? 1e4)
+    });
+  } catch (err) {
+    throw new AgenticMailApiError(0, `AgenticMail API unreachable at ${apiUrl}: ${err.message}`);
+  }
+  if (!res.ok) {
+    let text;
+    try {
+      text = await res.text();
+    } catch {
+      text = "(could not read response body)";
+    }
+    throw new AgenticMailApiError(res.status, `AgenticMail API ${res.status}: ${text.slice(0, 300)}`);
+  }
+  const contentType = res.headers.get("content-type") ?? "";
+  if (!contentType.includes("application/json")) {
+    return null;
+  }
+  return await res.json();
+}
+async function checkApiHealth(apiUrl) {
+  const url = `${apiUrl.replace(/\/$/, "")}/api/agenticmail/health`;
+  try {
+    const res = await fetch(url, { signal: AbortSignal.timeout(5e3) });
+    if (!res.ok) throw new AgenticMailApiError(res.status, `Health check returned HTTP ${res.status}`);
+    const data = await res.json();
+    return { ok: true, version: data?.version };
+  } catch (err) {
+    if (err instanceof AgenticMailApiError) throw err;
+    throw new AgenticMailApiError(0, `AgenticMail API unreachable at ${apiUrl}: ${err.message}`);
+  }
+}
+async function listAccounts(apiUrl, masterKey) {
+  const data = await request(apiUrl, masterKey, "/accounts");
+  return data?.agents ?? [];
+}
+async function getAccountByName(apiUrl, masterKey, name) {
+  const all = await listAccounts(apiUrl, masterKey);
+  return all.find((a) => a.name.toLowerCase() === name.toLowerCase()) ?? null;
+}
+async function ensureAccount(apiUrl, masterKey, name, role = "assistant") {
+  const existing = await getAccountByName(apiUrl, masterKey, name);
+  if (existing) return existing;
+  try {
+    const created = await request(apiUrl, masterKey, "/accounts", {
+      method: "POST",
+      body: { name, role }
+    });
+    if (!created || typeof created.apiKey !== "string") {
+      throw new AgenticMailApiError(0, "Account creation returned no apiKey \u2014 refusing to continue.");
+    }
+    return created;
+  } catch (err) {
+    if (err instanceof AgenticMailApiError && (err.status === 409 || /UNIQUE|exists/i.test(err.message))) {
+      const after = await getAccountByName(apiUrl, masterKey, name);
+      if (after) return after;
+    }
+    throw err;
+  }
+}
+async function deleteAccount(apiUrl, masterKey, id) {
+  await request(apiUrl, masterKey, `/accounts/${encodeURIComponent(id)}`, { method: "DELETE" });
+}
+
+// src/config.ts
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var AGENTICMAIL_CONFIG_PATH = join(homedir(), ".agenticmail", "config.json");
+function readAgenticMailConfig(path) {
+  if (!existsSync(path)) return {};
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function defaultMcpInvocation() {
+  return { command: "npx", args: ["-y", "@agenticmail/mcp"] };
+}
+function resolveConfig(opts = {}) {
+  const amConfigPath = opts.agenticmailConfigPath ?? AGENTICMAIL_CONFIG_PATH;
+  const onDisk = readAgenticMailConfig(amConfigPath);
+  const apiHost = onDisk.api?.host ?? "127.0.0.1";
+  const apiPort = onDisk.api?.port ?? 3200;
+  const defaultApiUrl = `http://${apiHost}:${apiPort}`;
+  const defaultInvocation = defaultMcpInvocation();
+  const masterKey = opts.masterKey ?? onDisk.masterKey ?? "";
+  return {
+    apiUrl: opts.apiUrl ?? defaultApiUrl,
+    masterKey,
+    claudeConfigPath: opts.claudeConfigPath ?? join(homedir(), ".claude.json"),
+    agentsDir: opts.agentsDir ?? join(homedir(), ".claude", "agents"),
+    mcpServerName: opts.mcpServerName ?? "agenticmail",
+    bridgeAgentName: opts.bridgeAgentName ?? "claudecode",
+    subagentPrefix: opts.subagentPrefix ?? "agenticmail-",
+    mcpCommand: opts.mcpCommand ?? defaultInvocation.command,
+    mcpArgs: opts.mcpArgs ?? defaultInvocation.args
+  };
+}
+
+// src/subagent-template.ts
+var ESSENTIAL_TOOL_NAMES = [
+  "whoami",
+  "list_inbox",
+  "read_email",
+  "send_email",
+  "reply_email",
+  "search_emails",
+  "list_agents",
+  "message_agent",
+  // call_agent is the synchronous RPC primitive — fire a task at another
+  // AgenticMail agent and get back a structured result. It is the reason
+  // multi-agent setups work, so it MUST be pre-loaded; making subagents
+  // call request_tools just to discover it would be a usability disaster
+  // for the most common coordination pattern.
+  "call_agent",
+  "check_tasks",
+  // Meta-tools — these unlock the other ~50 tools on demand.
+  "request_tools",
+  "invoke"
+];
+var MANAGED_BY_MARKER = "@agenticmail/claudecode";
+function yamlQuote(s) {
+  const cleaned = s.replace(/[\r\n]+/g, " ").replace(/\s+/g, " ").trim();
+  return `"${cleaned.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+function describeAgent(agent) {
+  const role = (agent.role ?? "").trim();
+  const owner = typeof agent.metadata?.ownerName === "string" ? agent.metadata.ownerName : "";
+  const parts = [];
+  parts.push(`AgenticMail agent "${agent.name}" (${agent.email})`);
+  if (role && role !== "assistant") parts.push(`role: ${role}`);
+  if (owner) parts.push(`owner: ${owner}`);
+  parts.push("use for anything that involves reading/writing this agent's email, sending mail from their address, managing their tasks, contacts, signatures, or SMS");
+  return parts.join("; ");
+}
+function renderPersonaBody(input) {
+  const { agent, mcpServerName } = input;
+  const tool = (n) => `mcp__${mcpServerName}__${n}`;
+  const roleLine = agent.role && agent.role !== "assistant" ? `Your role: ${agent.role}.` : "";
+  const ownerLine = typeof agent.metadata?.ownerName === "string" ? `Your owner is ${agent.metadata.ownerName}. You serve at their direction; treat their instructions as authoritative within the bounds of your role.` : "";
+  return [
+    `# You are ${agent.name}`,
+    "",
+    `You are **${agent.name}**, an AgenticMail agent. Your email address is \`${agent.email}\`. ${roleLine}`,
+    ownerLine,
+    "",
+    `You do not have your own connection to Anthropic. You are running inside a Claude Code session \u2014 Claude Code is your brain. Every reasoning step, every tool call, every reply you compose flows through Claude Code's authentication. That is intentional: it is how the AgenticMail \u2194 Claude Code integration works.`,
+    "",
+    "## Identity",
+    "",
+    `- **Name:** ${agent.name}`,
+    `- **Email:** \`${agent.email}\``,
+    agent.role ? `- **Role:** ${agent.role}` : "",
+    `- **Agent ID:** \`${agent.id}\``,
+    "",
+    "## Operating instructions",
+    "",
+    `You start every session with a small **pre-loaded** set of MCP tools (the ones listed in your frontmatter). Everything else AgenticMail offers \u2014 signatures, drafts, templates, SMS, bulk mail ops, folders, scheduling, spam tools, setup wizards, account admin \u2014 is reachable through the two **meta-tools** that are always pre-loaded:`,
+    "",
+    `- \`${tool("request_tools")}\` \u2014 Returns a text catalogue of unloaded tools. Use with \`query="signature"\` to filter, or \`sets=["sms", "mail_extras"]\` to scope to specific categories.`,
+    `- \`${tool("invoke")}\` \u2014 Calls any AgenticMail tool by name with structured args. Example: \`${tool("invoke")}({ tool: "manage_signatures", args: { action: "create", name: "default", body: "\u2014\\n${agent.name}" }, _account: "${agent.name}" })\`.`,
+    "",
+    `**On EVERY tool call you make \u2014 pre-loaded OR via \`invoke\` \u2014 you MUST pass \`_account: "${agent.name}"\`.** This tells the MCP server to authenticate as you, not as the integration's bridge identity. Without it, you'd be reading the bridge's empty inbox instead of your own, sending mail from the wrong address, and bypassing your owner's expectation that the agent named "${agent.name}" did the work.`,
+    "",
+    `Pre-loaded examples:`,
+    "",
+    "```",
+    `${tool("list_inbox")}({ _account: "${agent.name}", limit: 10 })`,
+    `${tool("read_email")}({ _account: "${agent.name}", uid: 42 })`,
+    `${tool("send_email")}({ _account: "${agent.name}", to: "...", subject: "...", text: "..." })`,
+    `${tool("reply_email")}({ _account: "${agent.name}", uid: 42, text: "..." })`,
+    `${tool("search_emails")}({ _account: "${agent.name}", from: "boss@..." })`,
+    `${tool("list_agents")}({ _account: "${agent.name}" })`,
+    `${tool("message_agent")}({ _account: "${agent.name}", agent: "researcher", message: "...fire-and-forget..." })`,
+    `// call_agent = SYNCHRONOUS RPC \u2014 sends a task, waits for the agent to do the work, returns the result.`,
+    `${tool("call_agent")}({ _account: "${agent.name}", target: "researcher", task: "Summarise the latest emails from accounting", timeout: 240 })`,
+    `${tool("check_tasks")}({ _account: "${agent.name}" })`,
+    `${tool("whoami")}({ _account: "${agent.name}" })`,
+    "```",
+    "",
+    `**Coordination tip:** When you need another agent to *do work and report back*, prefer \`${tool("call_agent")}\` over \`${tool("message_agent")}\`. message_agent just delivers an email and returns immediately; call_agent runs the AgenticMail RPC pipeline \u2014 the target agent gets the task, processes it, and the structured result flows back into your call. That is the entire reason this platform has multiple agents.`,
+    "",
+    `On-demand (via invoke) examples \u2014 anything NOT in the pre-loaded list:`,
+    "",
+    "```",
+    `${tool("request_tools")}({ query: "signature" })   // discover signature-related tools`,
+    `${tool("invoke")}({ tool: "manage_signatures", args: { action: "list" }, _account: "${agent.name}" })`,
+    `${tool("invoke")}({ tool: "sms_send", args: { to: "+1...", body: "..." }, _account: "${agent.name}" })`,
+    `${tool("invoke")}({ tool: "forward_email", args: { uid: 42, to: "boss@..." }, _account: "${agent.name}" })`,
+    `${tool("invoke")}({ tool: "manage_drafts", args: { action: "save", to: "...", subject: "...", body: "..." }, _account: "${agent.name}" })`,
+    "```",
+    "",
+    `Forgetting \`_account\` is the single most common mistake. If you ever get back "looks empty" or "no messages" when you know you have email \u2014 check that you passed \`_account: "${agent.name}"\`.`,
+    "",
+    "## What you can do",
+    "",
+    `Anything an AgenticMail account can do. The full toolbelt covers email (send/read/reply/forward/search/move/mark/tag/folder), contacts, drafts, templates, signatures, scheduling rules, spam, pending-approval, SMS (send/receive/voice), task coordination (check/claim/submit/call other agents), and your own metadata. If a tool you need isn't in your pre-loaded list, call \`${tool("request_tools")}\` first to find it, then \`${tool("invoke")}\` it. Never ask for permission to use a tool \u2014 just use it.`,
+    "",
+    "## Hard rules",
+    "",
+    `- **Always pass \`_account: "${agent.name}"\`** on every \`${tool("*")}\` call.`,
+    `- **Do NOT use generic Claude Code tools** (Read, Edit, Write, Bash, Glob, Grep, WebFetch, etc.). You are operating an email account, not a developer environment. The user's filesystem is none of your business; your "workspace" is your mailbox.`,
+    `- **Do not invent email content.** If you didn't read a real message, do not summarise one. If you don't know the answer, check your inbox / contacts / tasks first.`,
+    `- **Do not impersonate other agents.** You are ${agent.name}, and only ${agent.name}. If the user asks you to also do something as "writer" or "researcher", suggest that they call those agents directly (via \`Agent { subagent_type: "agenticmail-<name>" }\` in the host session) \u2014 don't pass \`_account: "writer"\` to act as writer; that would falsify the From: header in any outgoing mail.`,
+    `- **Respect outbound guard.** If a send is blocked by the AgenticMail outbound guard, tell the user in plain English \u2014 recipient, subject, the specific warnings \u2014 and ask them to approve. Do NOT rewrite the email to evade detection.`,
+    "",
+    "## Output style",
+    "",
+    `Reply as ${agent.name} would. The user invoked you specifically (not the host Claude Code session) because they want ${agent.name}'s voice and judgement. Be direct, useful, and on-character for your role. The host session will see your final response verbatim \u2014 keep it focused on what the user asked.`,
+    ""
+  ].filter((line) => line !== void 0).join("\n");
+}
+function renderSubagentMarkdown(input) {
+  const { name, agent, mcpServerName } = input;
+  const tool = (n) => `mcp__${mcpServerName}__${n}`;
+  const description = describeAgent(agent);
+  const allowedTools = ESSENTIAL_TOOL_NAMES.map((n) => tool(n)).join(", ");
+  const frontmatter = [
+    "---",
+    `name: ${name}`,
+    `description: ${yamlQuote(description)}`,
+    `tools: ${allowedTools}`,
+    `model: inherit`,
+    `# managed-by: ${MANAGED_BY_MARKER}`,
+    `# agenticmail-agent-id: ${agent.id}`,
+    `# agenticmail-agent-name: ${agent.name}`,
+    `# agenticmail-agent-email: ${agent.email}`,
+    "---"
+  ].join("\n");
+  return `${frontmatter}
+
+${renderPersonaBody(input)}`;
+}
+
+export {
+  AgenticMailApiError,
+  checkApiHealth,
+  listAccounts,
+  getAccountByName,
+  ensureAccount,
+  deleteAccount,
+  resolveConfig,
+  MANAGED_BY_MARKER,
+  renderPersonaBody,
+  renderSubagentMarkdown
+};

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.js

@@ -0,0 +1,174 @@
+#!/usr/bin/env node
+import {
+  install
+} from "./chunk-P2DXF7DO.js";
+import {
+  status
+} from "./chunk-RI4USTMC.js";
+import {
+  uninstall
+} from "./chunk-ULKJ773Y.js";
+import "./chunk-US5FT2UB.js";
+import {
+  AgenticMailApiError
+} from "./chunk-XAW5NUNU.js";
+
+// src/cli.ts
+var GREEN = (s) => `\x1B[32m${s}\x1B[0m`;
+var RED = (s) => `\x1B[31m${s}\x1B[0m`;
+var DIM = (s) => `\x1B[90m${s}\x1B[0m`;
+var BOLD = (s) => `\x1B[1m${s}\x1B[0m`;
+var PINK = (s) => `\x1B[38;5;205m${s}\x1B[0m`;
+function print(msg) {
+  console.log(msg);
+}
+function ok(msg) {
+  console.log(`  ${GREEN("\u2713")} ${msg}`);
+}
+function fail(msg) {
+  console.error(`  ${RED("\u2717")} ${msg}`);
+}
+function dim(msg) {
+  console.log(`  ${DIM(msg)}`);
+}
+function usage() {
+  print("");
+  print(`  ${PINK("\u{1F380} AgenticMail for Claude Code")}`);
+  print("");
+  print(`  ${BOLD("Usage:")} agenticmail-claudecode [command] [flags]`);
+  print("");
+  print(`  ${BOLD("Commands:")}`);
+  print(`    install            Register AgenticMail with Claude Code (default)`);
+  print(`    uninstall          Remove the registration`);
+  print(`    status             Show what's currently installed`);
+  print("");
+  print(`  ${BOLD("Flags:")}`);
+  print(`    --json             (status) Emit machine-readable JSON instead of prose`);
+  print(`    --purge-bridge     (uninstall) Also delete the AgenticMail bridge agent`);
+  print(`    -h, --help         Show this help and exit`);
+  print("");
+  print(`  ${BOLD("Environment overrides:")}`);
+  print(`    AGENTICMAIL_API_URL          Override AgenticMail master API URL`);
+  print(`    AGENTICMAIL_MASTER_KEY       Override master key (otherwise read from ~/.agenticmail/config.json)`);
+  print(`    CLAUDE_CODE_CONFIG_PATH      Override Claude Code config path (default ~/.claude.json)`);
+  print(`    CLAUDE_CODE_AGENTS_DIR       Override Claude Code agents dir (default ~/.claude/agents)`);
+  print("");
+}
+function envOptions() {
+  return {
+    apiUrl: process.env.AGENTICMAIL_API_URL,
+    masterKey: process.env.AGENTICMAIL_MASTER_KEY,
+    claudeConfigPath: process.env.CLAUDE_CODE_CONFIG_PATH,
+    agentsDir: process.env.CLAUDE_CODE_AGENTS_DIR
+  };
+}
+function clean(o) {
+  const out = {};
+  for (const [k, v] of Object.entries(o)) {
+    if (v !== void 0) out[k] = v;
+  }
+  return out;
+}
+async function runInstall() {
+  print("");
+  print(`  ${PINK("\u{1F380} Installing AgenticMail for Claude Code")}`);
+  print("");
+  try {
+    const result = await install(clean(envOptions()));
+    ok(`Bridge agent: ${result.bridgeAgent.name} (${result.bridgeAgent.email})`);
+    ok(`MCP server registered in ${result.claudeConfigPath}`);
+    ok(`${result.registeredAgents.length} Claude Code subagent${result.registeredAgents.length === 1 ? "" : "s"} written to ${result.agentsDir}`);
+    if (result.registeredAgents.length > 0) {
+      for (const a of result.registeredAgents) dim(`  \u2022 agenticmail-${a.name.toLowerCase()}  \u2192  ${a.email}`);
+    }
+    print("");
+    if (!result.changed) {
+      print(`  ${DIM("Already up to date \u2014 no files were modified.")}`);
+    } else {
+      print(`  ${BOLD("Next step:")} restart Claude Code so it picks up the new MCP server.`);
+      print(`  ${DIM('Once restarted, try:  Agent { subagent_type: "agenticmail-fola", prompt: "hi" }')}`);
+    }
+    print("");
+    return 0;
+  } catch (err) {
+    fail(err.message);
+    if (err instanceof AgenticMailApiError && err.status === 0) {
+      dim("Is the AgenticMail server running? Try: agenticmail start");
+    }
+    return 1;
+  }
+}
+async function runUninstall(purgeBridge) {
+  print("");
+  print(`  ${PINK("\u{1F380} Removing AgenticMail from Claude Code")}`);
+  print("");
+  try {
+    const result = await uninstall({ ...clean(envOptions()), purgeBridgeAgent: purgeBridge });
+    if (result.mcpBlockRemoved) ok("Removed MCP server entry from Claude Code config");
+    else dim("No MCP server entry was registered.");
+    if (result.removedSubagents.length > 0) ok(`Removed ${result.removedSubagents.length} subagent file(s)`);
+    else dim("No subagent files were registered.");
+    if (result.bridgeAgentDeleted) ok("Deleted bridge agent from AgenticMail");
+    else if (purgeBridge) dim("Bridge agent could not be deleted (already gone, or AgenticMail unreachable).");
+    print("");
+    if (!result.changed) print(`  ${DIM("Nothing to remove.")}`);
+    print("");
+    return 0;
+  } catch (err) {
+    fail(err.message);
+    return 1;
+  }
+}
+async function runStatus(asJson) {
+  try {
+    const result = await status(clean(envOptions()));
+    if (asJson) {
+      print(JSON.stringify(result, null, 2));
+      return result.state === "installed" ? 0 : 1;
+    }
+    print("");
+    print(`  ${PINK("\u{1F380} AgenticMail for Claude Code")}`);
+    print("");
+    const stateLabel = result.state === "installed" ? GREEN("installed") : result.state === "partial" ? `${BOLD("partial")}` : DIM("not installed");
+    print(`  Status: ${stateLabel}`);
+    print(`  MCP server registered: ${result.mcpInstalled ? GREEN("yes") : DIM("no")}`);
+    print(`  Bridge agent in AgenticMail: ${result.bridgeAgentExists ? GREEN("yes") : DIM("no")}`);
+    print(`  Subagent files: ${result.subagents.length > 0 ? GREEN(String(result.subagents.length)) : DIM("0")}`);
+    if (result.subagents.length > 0) for (const s of result.subagents) dim(`  \u2022 ${s}`);
+    if (result.notes.length > 0) {
+      print("");
+      print(`  ${BOLD("Notes:")}`);
+      for (const n of result.notes) dim(`  \u2022 ${n}`);
+    }
+    print("");
+    return result.state === "installed" ? 0 : 1;
+  } catch (err) {
+    fail(err.message);
+    return 2;
+  }
+}
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.includes("-h") || args.includes("--help") || args[0] === "help") {
+    usage();
+    return 0;
+  }
+  const command = args.find((a) => !a.startsWith("-")) ?? "install";
+  switch (command) {
+    case "install":
+      return runInstall();
+    case "uninstall":
+    case "remove":
+      return runUninstall(args.includes("--purge-bridge"));
+    case "status":
+      return runStatus(args.includes("--json"));
+    default:
+      fail(`Unknown command: ${command}`);
+      usage();
+      return 64;
+  }
+}
+main().then((code) => process.exit(code)).catch((err) => {
+  fail(err.message);
+  process.exit(1);
+});