@agenticmail/claudecode 0.1.0

package/dist/chunk-563BZ447.js

@@ -0,0 +1,408 @@
+import {
+  listAccounts,
+  renderPersonaBody,
+  resolveConfig
+} from "./chunk-XAW5NUNU.js";
+
+// src/persona-loader.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+function sanitizeSubagentName(name) {
+  return name.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function stripFrontmatter(raw) {
+  const text = raw.replace(/\r\n/g, "\n");
+  if (!text.startsWith("---\n")) return text;
+  const close = text.indexOf("\n---", 4);
+  if (close < 0) return text;
+  let cursor = close + 4;
+  while (cursor < text.length && (text[cursor] === "\n" || text[cursor] === "\r")) cursor++;
+  return text.slice(cursor);
+}
+function loadPersonaForAgent(opts) {
+  const { agent, agentsDir, subagentPrefix, mcpServerName } = opts;
+  const basename = sanitizeSubagentName(`${subagentPrefix}${agent.name}`);
+  const filePath = join(agentsDir, `${basename}.md`);
+  if (existsSync(filePath)) {
+    try {
+      const raw = readFileSync(filePath, "utf-8");
+      const body2 = stripFrontmatter(raw).trim();
+      if (body2) return { body: body2, source: "file", filePath };
+    } catch {
+    }
+  }
+  const body = renderPersonaBody({ name: basename, agent, mcpServerName });
+  return { body, source: "generated" };
+}
+
+// src/dispatcher.ts
+var SEEN_CAP = 1024;
+function rememberBounded(set, item) {
+  set.add(item);
+  if (set.size > SEEN_CAP) {
+    const drop = Array.from(set).slice(0, Math.floor(SEEN_CAP / 2));
+    for (const x of drop) set.delete(x);
+  }
+}
+var DEFAULT_MAX_CONCURRENT = 10;
+var DEFAULT_SYNC_INTERVAL_MS = 6e4;
+var DEFAULT_RECONNECT_BASE_MS = 2e3;
+var DEFAULT_RECONNECT_MAX_MS = 6e4;
+async function runWorker(query, persona, userPrompt, agent, mcpServerName, mcpCommand, mcpArgs, mcpEnv, log, abortSignal) {
+  const opts = {
+    systemPrompt: persona,
+    mcpServers: {
+      [mcpServerName]: {
+        command: mcpCommand,
+        args: mcpArgs,
+        env: mcpEnv
+      }
+    },
+    // Restrict to MCP tools only — workers should never reach for
+    // Bash / Read / Edit / etc. Listing them avoids accidental leakage.
+    allowedTools: [
+      `mcp__${mcpServerName}__whoami`,
+      `mcp__${mcpServerName}__list_inbox`,
+      `mcp__${mcpServerName}__read_email`,
+      `mcp__${mcpServerName}__send_email`,
+      `mcp__${mcpServerName}__reply_email`,
+      `mcp__${mcpServerName}__search_emails`,
+      `mcp__${mcpServerName}__list_agents`,
+      `mcp__${mcpServerName}__message_agent`,
+      `mcp__${mcpServerName}__call_agent`,
+      `mcp__${mcpServerName}__check_tasks`,
+      `mcp__${mcpServerName}__claim_task`,
+      `mcp__${mcpServerName}__submit_result`,
+      `mcp__${mcpServerName}__request_tools`,
+      `mcp__${mcpServerName}__invoke`
+    ],
+    permissionMode: "bypassPermissions",
+    abortController: abortSignal ? wrapSignal(abortSignal) : void 0
+  };
+  const collectedText = [];
+  try {
+    for await (const msg of query({ prompt: userPrompt, options: opts })) {
+      const m = msg;
+      if (m.type === "assistant" && Array.isArray(m.message && m.message.content)) {
+        for (const block of m.message.content) {
+          const b = block;
+          if (b.type === "text" && typeof b.text === "string") collectedText.push(b.text);
+        }
+      }
+      if (m.type === "result" && typeof m.result === "string") {
+        collectedText.push(m.result);
+      }
+    }
+    const text = collectedText.join("\n").trim();
+    log("info", `[dispatcher] worker for "${agent.name}" finished (${text.length} chars output)`);
+    return { ok: true, text };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    log("error", `[dispatcher] worker for "${agent.name}" failed: ${msg}`);
+    return { ok: false, error: msg };
+  }
+}
+function wrapSignal(signal) {
+  const c = new AbortController();
+  if (signal.aborted) c.abort();
+  else signal.addEventListener("abort", () => c.abort(), { once: true });
+  return c;
+}
+function newMailPrompt(agent, event) {
+  const from = event.from ?? "unknown sender";
+  const subject = event.subject ?? "(no subject)";
+  const uid = event.uid;
+  return [
+    `You have new mail.`,
+    ``,
+    `- From: ${from}`,
+    `- Subject: ${subject}`,
+    uid ? `- UID: ${uid}` : "",
+    ``,
+    `Open it (with read_email if a UID was given, or list_inbox otherwise), decide what to do as ${agent.name} would, and act:`,
+    `  - if it's a question or request \u2192 reply with reply_email`,
+    `  - if it requires research \u2192 use call_agent to ask the right teammate, then reply`,
+    `  - if it's an FYI \u2192 archive (mark_read) and move on`,
+    `  - if it's spam-looking \u2192 trust the auto-spam-filter; only intervene if it slipped through`,
+    ``,
+    `When you've handled it, return a one-line summary of what you did.`
+  ].filter(Boolean).join("\n");
+}
+function taskPrompt(agent, event) {
+  const taskId = event.taskId ?? "(missing taskId)";
+  const taskText = event.task ?? "(no task description)";
+  const taskType = event.taskType ?? "generic";
+  const from = event.from ?? "unknown";
+  return [
+    `You have a pending task \u2014 handle it now.`,
+    ``,
+    `- Task ID: ${taskId}`,
+    `- Type: ${taskType}`,
+    `- From: ${from}`,
+    `- Task: ${taskText}`,
+    ``,
+    `Workflow:`,
+    `  1. Call claim_task({ id: "${taskId}", _account: "${agent.name}" }) to mark yourself as the owner.`,
+    `  2. Do the work using whatever pre-loaded or invoke-able MCP tools fit.`,
+    `  3. Call submit_result({ id: "${taskId}", result: { ... }, _account: "${agent.name}" }) with structured JSON.`,
+    `     The caller is waiting on a synchronous long-poll \u2014 submit_result is what wakes them.`,
+    ``,
+    `If you cannot complete the task, submit_result with { status: "failed", reason: "..." }. Never leave it unclaimed \u2014 that strands the caller until timeout.`
+  ].join("\n");
+}
+var Dispatcher = class {
+  cfg;
+  maxConcurrent;
+  syncIntervalMs;
+  reconnectBaseMs;
+  reconnectMaxMs;
+  query;
+  fetchImpl;
+  log;
+  channels = /* @__PURE__ */ new Map();
+  // keyed by account.id
+  accountSyncTimer = null;
+  running = 0;
+  waiters = [];
+  stopped = false;
+  constructor(opts = {}) {
+    this.cfg = resolveConfig(opts);
+    this.maxConcurrent = opts.maxConcurrentWorkers ?? DEFAULT_MAX_CONCURRENT;
+    this.syncIntervalMs = opts.accountSyncIntervalMs ?? DEFAULT_SYNC_INTERVAL_MS;
+    this.reconnectBaseMs = opts.sseReconnectBaseMs ?? DEFAULT_RECONNECT_BASE_MS;
+    this.reconnectMaxMs = opts.sseReconnectMaxMs ?? DEFAULT_RECONNECT_MAX_MS;
+    this.query = opts.querySdk ?? defaultQuery();
+    this.fetchImpl = opts.fetchImpl ?? globalThis.fetch;
+    this.log = opts.log ?? defaultLog;
+    if (!this.cfg.masterKey) {
+      throw new Error("Dispatcher requires AgenticMail master key. Run `agenticmail setup` first.");
+    }
+  }
+  async start() {
+    this.log("info", `[dispatcher] starting (maxConcurrent=${this.maxConcurrent}, syncEvery=${this.syncIntervalMs}ms)`);
+    await this.syncAccounts();
+    this.accountSyncTimer = setInterval(() => {
+      this.syncAccounts().catch((err) => this.log("warn", `[dispatcher] account sync failed: ${err}`));
+    }, this.syncIntervalMs);
+  }
+  async stop() {
+    this.stopped = true;
+    if (this.accountSyncTimer) clearInterval(this.accountSyncTimer);
+    this.accountSyncTimer = null;
+    for (const ch of this.channels.values()) {
+      ch.stopping = true;
+      ch.controller?.abort();
+    }
+    this.channels.clear();
+    this.log("info", "[dispatcher] stopped");
+  }
+  /** Public for tests — directly hand an event to the routing path. */
+  async handleEvent(account, event) {
+    if (this.stopped) return;
+    if (event.type === "new" && typeof event.uid === "number") {
+      const ch = this.channels.get(account.id);
+      if (ch?.seenUids.has(event.uid)) return;
+      if (ch) rememberBounded(ch.seenUids, event.uid);
+      await this.spawnWorker(account, newMailPrompt(account, event), { kind: "new-mail", uid: event.uid });
+      return;
+    }
+    if (event.type === "task" && typeof event.taskId === "string") {
+      if (typeof event.assignee === "string" && event.assignee.toLowerCase() !== account.name.toLowerCase()) return;
+      const ch = this.channels.get(account.id);
+      if (ch?.seenTaskIds.has(event.taskId)) return;
+      if (ch) rememberBounded(ch.seenTaskIds, event.taskId);
+      await this.spawnWorker(account, taskPrompt(account, event), { kind: "task", taskId: event.taskId });
+      return;
+    }
+  }
+  /** Re-fetch /accounts; open SSE for new ones, close for vanished ones. */
+  async syncAccounts() {
+    let accounts;
+    try {
+      accounts = await listAccounts(this.cfg.apiUrl, this.cfg.masterKey);
+    } catch (err) {
+      this.log("warn", `[dispatcher] could not list accounts: ${err.message}`);
+      return;
+    }
+    const liveIds = new Set(accounts.map((a) => a.id));
+    for (const [id, ch] of this.channels) {
+      if (!liveIds.has(id)) {
+        ch.stopping = true;
+        ch.controller?.abort();
+        this.channels.delete(id);
+        this.log("info", `[dispatcher] account "${ch.account.name}" removed \u2014 closed SSE channel`);
+      }
+    }
+    for (const account of accounts) {
+      if (this.channels.has(account.id)) {
+        this.channels.get(account.id).account = account;
+        continue;
+      }
+      const ch = {
+        account,
+        controller: null,
+        stopping: false,
+        backoffMs: this.reconnectBaseMs,
+        seenUids: /* @__PURE__ */ new Set(),
+        seenTaskIds: /* @__PURE__ */ new Set()
+      };
+      this.channels.set(account.id, ch);
+      this.log("info", `[dispatcher] opening SSE for "${account.name}" (${account.email})`);
+      void this.runChannel(ch);
+    }
+  }
+  /** Watch one account's SSE stream forever; reconnect with backoff on drop. */
+  async runChannel(ch) {
+    while (!ch.stopping && !this.stopped) {
+      try {
+        ch.controller = new AbortController();
+        await this.streamOne(ch);
+        if (!ch.stopping) {
+          this.log("warn", `[dispatcher] SSE for "${ch.account.name}" ended unexpectedly; reconnecting in ${ch.backoffMs}ms`);
+        }
+      } catch (err) {
+        if (ch.stopping) break;
+        this.log("warn", `[dispatcher] SSE error for "${ch.account.name}": ${err.message}; reconnecting in ${ch.backoffMs}ms`);
+      }
+      if (ch.stopping) break;
+      await sleep(ch.backoffMs);
+      ch.backoffMs = Math.min(ch.backoffMs * 2, this.reconnectMaxMs);
+    }
+  }
+  /** Single SSE attach. Returns when the stream closes for any reason. */
+  async streamOne(ch) {
+    const url = `${this.cfg.apiUrl.replace(/\/$/, "")}/api/agenticmail/events`;
+    const res = await this.fetchImpl(url, {
+      headers: {
+        "Authorization": `Bearer ${ch.account.apiKey}`,
+        "Accept": "text/event-stream"
+      },
+      signal: ch.controller.signal
+    });
+    if (!res.ok || !res.body) {
+      throw new Error(`SSE handshake HTTP ${res.status}`);
+    }
+    ch.backoffMs = this.reconnectBaseMs;
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    while (!ch.stopping) {
+      const { value, done } = await reader.read();
+      if (done) return;
+      buffer += decoder.decode(value, { stream: true });
+      let boundary;
+      while ((boundary = buffer.indexOf("\n\n")) !== -1) {
+        const frame = buffer.slice(0, boundary);
+        buffer = buffer.slice(boundary + 2);
+        for (const line of frame.split("\n")) {
+          if (!line.startsWith("data: ")) continue;
+          let event;
+          try {
+            event = JSON.parse(line.slice(6));
+          } catch {
+            continue;
+          }
+          this.handleEvent(ch.account, event).catch(
+            (err) => this.log("error", `[dispatcher] handleEvent threw for "${ch.account.name}": ${err}`)
+          );
+        }
+      }
+    }
+  }
+  /** Acquire a concurrency slot, run a worker, release the slot. */
+  async spawnWorker(account, prompt, ctx) {
+    await this.acquireSlot();
+    try {
+      const { body } = loadPersonaForAgent({
+        agent: account,
+        agentsDir: this.cfg.agentsDir,
+        subagentPrefix: this.cfg.subagentPrefix,
+        mcpServerName: this.cfg.mcpServerName
+      });
+      this.log("info", `[dispatcher] waking "${account.name}" \u2014 ${ctx.kind}${ctx.taskId ? " " + ctx.taskId : ctx.uid ? " uid=" + ctx.uid : ""}`);
+      const mcpEnv = await this.buildMcpEnv();
+      await runWorker(
+        this.query,
+        body,
+        prompt,
+        account,
+        this.cfg.mcpServerName,
+        this.cfg.mcpCommand,
+        this.cfg.mcpArgs,
+        mcpEnv,
+        this.log
+      );
+    } finally {
+      this.releaseSlot();
+    }
+  }
+  /** Build the env block we pass to the worker's MCP server child process. */
+  async buildMcpEnv() {
+    return {
+      AGENTICMAIL_API_URL: this.cfg.apiUrl,
+      AGENTICMAIL_MASTER_KEY: this.cfg.masterKey
+      // No AGENTICMAIL_API_KEY: workers should ALWAYS pass `_account`
+      // explicitly. Omitting the default key forces that discipline at
+      // the MCP-server level (any forgotten `_account` becomes a clear
+      // error rather than a silent identity drift).
+    };
+  }
+  acquireSlot() {
+    if (this.running < this.maxConcurrent) {
+      this.running++;
+      return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+      this.waiters.push(() => {
+        this.running++;
+        resolve();
+      });
+    });
+  }
+  releaseSlot() {
+    this.running--;
+    const next = this.waiters.shift();
+    if (next) next();
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function defaultLog(level, msg) {
+  const stream = level === "error" ? process.stderr : process.stdout;
+  stream.write(`[${(/* @__PURE__ */ new Date()).toISOString()}] [${level}] ${msg}
+`);
+}
+function defaultQuery() {
+  return (params) => {
+    let inner = null;
+    const init = async () => {
+      try {
+        const mod = await import("@anthropic-ai/claude-agent-sdk");
+        return mod.query(params);
+      } catch (err) {
+        throw new Error(
+          `Dispatcher needs @anthropic-ai/claude-agent-sdk installed in the package, but: ${err.message}`
+        );
+      }
+    };
+    return {
+      [Symbol.asyncIterator]() {
+        return {
+          async next() {
+            if (!inner) inner = await init();
+            const it = inner[Symbol.asyncIterator]();
+            const self = this;
+            self.next = it.next.bind(it);
+            return it.next();
+          }
+        };
+      }
+    };
+  };
+}
+
+export {
+  loadPersonaForAgent,
+  Dispatcher
+};

package/dist/chunk-P2DXF7DO.js

@@ -0,0 +1,139 @@
+import {
+  startDispatcher,
+  upsertMcpServer
+} from "./chunk-US5FT2UB.js";
+import {
+  MANAGED_BY_MARKER,
+  checkApiHealth,
+  ensureAccount,
+  listAccounts,
+  renderSubagentMarkdown,
+  resolveConfig
+} from "./chunk-XAW5NUNU.js";
+
+// src/install.ts
+import { existsSync, mkdirSync, readdirSync, writeFileSync, readFileSync, unlinkSync } from "fs";
+import { join } from "path";
+import { fileURLToPath } from "url";
+function sanitizeSubagentName(name) {
+  return name.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function buildMcpEntry(cfg, bridgeKey, accountKeys) {
+  const env = {
+    AGENTICMAIL_API_URL: cfg.apiUrl,
+    AGENTICMAIL_API_KEY: bridgeKey,
+    AGENTICMAIL_MASTER_KEY: cfg.masterKey
+  };
+  if (Object.keys(accountKeys).length > 0) {
+    env.AGENTICMAIL_ACCOUNT_KEYS_JSON = JSON.stringify(accountKeys);
+  }
+  return {
+    type: "stdio",
+    command: cfg.mcpCommand,
+    args: cfg.mcpArgs,
+    env
+  };
+}
+function selectExposableAgents(accounts, cfg) {
+  return accounts.filter(
+    (a) => a.name.toLowerCase() !== cfg.bridgeAgentName.toLowerCase() && a.role !== "bridge"
+  );
+}
+function isOwnedSubagent(filepath) {
+  try {
+    const head = readFileSync(filepath, "utf-8").slice(0, 1024);
+    return head.includes(MANAGED_BY_MARKER);
+  } catch {
+    return false;
+  }
+}
+function writeSubagentFiles(agentsDir, cfg, agents) {
+  if (!existsSync(agentsDir)) mkdirSync(agentsDir, { recursive: true });
+  const updated = [];
+  for (const agent of agents) {
+    const baseName = sanitizeSubagentName(`${cfg.subagentPrefix}${agent.name}`);
+    const filePath = join(agentsDir, `${baseName}.md`);
+    const content = renderSubagentMarkdown({
+      name: baseName,
+      agent,
+      mcpServerName: cfg.mcpServerName
+    });
+    if (existsSync(filePath)) {
+      if (!isOwnedSubagent(filePath)) continue;
+      const existing = readFileSync(filePath, "utf-8");
+      if (existing === content) continue;
+    }
+    writeFileSync(filePath, content, "utf-8");
+    updated.push(baseName);
+  }
+  return updated;
+}
+function pruneStaleSubagentFiles(agentsDir, cfg, liveAgentNames) {
+  if (!existsSync(agentsDir)) return [];
+  const prefix = cfg.subagentPrefix.toLowerCase();
+  const removed = [];
+  for (const file of readdirSync(agentsDir)) {
+    if (!file.endsWith(".md")) continue;
+    if (!file.toLowerCase().startsWith(prefix)) continue;
+    const full = join(agentsDir, file);
+    if (!isOwnedSubagent(full)) continue;
+    const stem = file.slice(prefix.length, -3);
+    if (liveAgentNames.has(stem.toLowerCase())) continue;
+    try {
+      unlinkSync(full);
+      removed.push(file);
+    } catch {
+    }
+  }
+  return removed;
+}
+async function install(opts = {}) {
+  const cfg = resolveConfig(opts);
+  await checkApiHealth(cfg.apiUrl);
+  if (!cfg.masterKey) {
+    throw new Error(
+      "AgenticMail master key not found. Run `agenticmail setup` first to generate one, or pass { masterKey } to install() explicitly."
+    );
+  }
+  const bridge = await ensureAccount(cfg.apiUrl, cfg.masterKey, cfg.bridgeAgentName, "assistant");
+  const everyAccount = await listAccounts(cfg.apiUrl, cfg.masterKey);
+  const exposable = selectExposableAgents(everyAccount, cfg);
+  const accountKeys = {};
+  for (const a of exposable) accountKeys[a.name] = a.apiKey;
+  accountKeys[bridge.name] = bridge.apiKey;
+  const mcpEntry = buildMcpEntry(cfg, bridge.apiKey, accountKeys);
+  const mcpChanged = upsertMcpServer(cfg.claudeConfigPath, cfg.mcpServerName, mcpEntry);
+  const updated = writeSubagentFiles(cfg.agentsDir, cfg, exposable);
+  const liveNames = new Set(exposable.map((a) => sanitizeSubagentName(a.name)));
+  const pruned = pruneStaleSubagentFiles(cfg.agentsDir, cfg, liveNames);
+  const dispatcherStatus = await startDispatcherForInstall(cfg);
+  return {
+    registeredAgents: exposable,
+    claudeConfigPath: cfg.claudeConfigPath,
+    agentsDir: cfg.agentsDir,
+    bridgeAgent: bridge,
+    changed: mcpChanged || updated.length > 0 || pruned.length > 0 || dispatcherStatus.started,
+    dispatcher: dispatcherStatus
+  };
+}
+function resolveDispatcherBinPath() {
+  const thisFile = fileURLToPath(import.meta.url);
+  const dir = thisFile.slice(0, thisFile.lastIndexOf("/"));
+  return `${dir}/dispatcher-bin.js`;
+}
+async function startDispatcherForInstall(cfg) {
+  const binPath = resolveDispatcherBinPath();
+  return startDispatcher({
+    binPath,
+    env: {
+      AGENTICMAIL_API_URL: cfg.apiUrl,
+      AGENTICMAIL_MASTER_KEY: cfg.masterKey,
+      CLAUDE_CODE_AGENTS_DIR: cfg.agentsDir
+    }
+  });
+}
+
+export {
+  selectExposableAgents,
+  install
+};

package/dist/chunk-RI4USTMC.js

@@ -0,0 +1,89 @@
+import {
+  getDispatcherStatus,
+  readClaudeConfig
+} from "./chunk-US5FT2UB.js";
+import {
+  AgenticMailApiError,
+  MANAGED_BY_MARKER,
+  getAccountByName,
+  resolveConfig
+} from "./chunk-XAW5NUNU.js";
+
+// src/status.ts
+import { existsSync, readFileSync, readdirSync } from "fs";
+import { join } from "path";
+async function status(opts = {}) {
+  const cfg = resolveConfig(opts);
+  const notes = [];
+  let mcpInstalled = false;
+  if (existsSync(cfg.claudeConfigPath)) {
+    try {
+      const claudeCfg = readClaudeConfig(cfg.claudeConfigPath);
+      mcpInstalled = Boolean(claudeCfg.mcpServers?.[cfg.mcpServerName]);
+    } catch (err) {
+      notes.push(`Could not parse ${cfg.claudeConfigPath}: ${err.message}`);
+    }
+  } else {
+    notes.push(`Claude Code config not found at ${cfg.claudeConfigPath} \u2014 Claude Code may not be installed yet.`);
+  }
+  const subagents = [];
+  if (existsSync(cfg.agentsDir)) {
+    const prefix = cfg.subagentPrefix.toLowerCase();
+    for (const file of readdirSync(cfg.agentsDir)) {
+      if (!file.endsWith(".md")) continue;
+      if (!file.toLowerCase().startsWith(prefix)) continue;
+      const full = join(cfg.agentsDir, file);
+      try {
+        const head = readFileSync(full, "utf-8").slice(0, 1024);
+        if (head.includes(MANAGED_BY_MARKER)) subagents.push(file.slice(0, -3));
+      } catch {
+      }
+    }
+  }
+  let bridgeAgentExists = false;
+  if (cfg.masterKey) {
+    try {
+      const bridge = await getAccountByName(cfg.apiUrl, cfg.masterKey, cfg.bridgeAgentName);
+      bridgeAgentExists = Boolean(bridge);
+      if (!bridge && mcpInstalled) {
+        notes.push(`MCP server is registered but bridge agent "${cfg.bridgeAgentName}" is missing in AgenticMail \u2014 re-run install to recreate it.`);
+      }
+    } catch (err) {
+      if (err instanceof AgenticMailApiError) {
+        notes.push(`Could not reach AgenticMail at ${cfg.apiUrl}: ${err.message}`);
+      } else {
+        notes.push(err.message);
+      }
+    }
+  } else {
+    notes.push("AgenticMail master key not found \u2014 run `agenticmail setup` to initialize.");
+  }
+  const dispatcherInfo = getDispatcherStatus();
+  const dispatcher = dispatcherInfo ? {
+    running: dispatcherInfo.status === "online",
+    pid: dispatcherInfo.pid,
+    restartCount: dispatcherInfo.restartCount,
+    uptimeMs: dispatcherInfo.uptime ? Date.now() - dispatcherInfo.uptime : void 0
+  } : null;
+  if (mcpInstalled && (!dispatcher || !dispatcher.running)) {
+    notes.push("Dispatcher daemon is not running \u2014 AgenticMail agents will NOT auto-wake on mail/task events. Re-run `agenticmail claudecode` to (re)start it.");
+  }
+  let state;
+  if (mcpInstalled && bridgeAgentExists && subagents.length > 0) state = "installed";
+  else if (!mcpInstalled && !bridgeAgentExists && subagents.length === 0) state = "not_installed";
+  else state = "partial";
+  return {
+    state,
+    mcpInstalled,
+    bridgeAgentExists,
+    subagents,
+    claudeConfigPath: cfg.claudeConfigPath,
+    agentsDir: cfg.agentsDir,
+    notes,
+    dispatcher
+  };
+}
+
+export {
+  status
+};

package/dist/chunk-ULKJ773Y.js

@@ -0,0 +1,65 @@
+import {
+  removeMcpServer,
+  stopDispatcher
+} from "./chunk-US5FT2UB.js";
+import {
+  MANAGED_BY_MARKER,
+  deleteAccount,
+  getAccountByName,
+  resolveConfig
+} from "./chunk-XAW5NUNU.js";
+
+// src/uninstall.ts
+import { existsSync, readdirSync, readFileSync, unlinkSync } from "fs";
+import { join } from "path";
+function removeOwnedSubagents(agentsDir, prefix) {
+  if (!existsSync(agentsDir)) return [];
+  const safePrefix = prefix.toLowerCase();
+  const removed = [];
+  for (const file of readdirSync(agentsDir)) {
+    if (!file.endsWith(".md")) continue;
+    if (!file.toLowerCase().startsWith(safePrefix)) continue;
+    const full = join(agentsDir, file);
+    let head;
+    try {
+      head = readFileSync(full, "utf-8").slice(0, 1024);
+    } catch {
+      continue;
+    }
+    if (!head.includes(MANAGED_BY_MARKER)) continue;
+    try {
+      unlinkSync(full);
+      removed.push(file);
+    } catch {
+    }
+  }
+  return removed;
+}
+async function uninstall(opts = {}) {
+  const cfg = resolveConfig(opts);
+  const mcpBlockRemoved = removeMcpServer(cfg.claudeConfigPath, cfg.mcpServerName);
+  const removedSubagents = removeOwnedSubagents(cfg.agentsDir, cfg.subagentPrefix);
+  const dispatcherStopped = stopDispatcher().stopped;
+  let bridgeAgentDeleted = false;
+  if (opts.purgeBridgeAgent && cfg.masterKey) {
+    try {
+      const bridge = await getAccountByName(cfg.apiUrl, cfg.masterKey, cfg.bridgeAgentName);
+      if (bridge) {
+        await deleteAccount(cfg.apiUrl, cfg.masterKey, bridge.id);
+        bridgeAgentDeleted = true;
+      }
+    } catch {
+    }
+  }
+  return {
+    changed: mcpBlockRemoved || removedSubagents.length > 0 || bridgeAgentDeleted || dispatcherStopped,
+    removedSubagents,
+    mcpBlockRemoved,
+    bridgeAgentDeleted,
+    dispatcherStopped
+  };
+}
+
+export {
+  uninstall
+};