adhdev 0.9.58 → 0.9.60

package/vendor/mcp-server/index.js

@@ -0,0 +1,835 @@
+#!/usr/bin/env node
+"use strict";
+
+// src/server.ts
+var import_server = require("@modelcontextprotocol/sdk/server/index.js");
+var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
+var import_types = require("@modelcontextprotocol/sdk/types.js");
+
+// src/transports/local.ts
+var DEFAULT_PORT = 3847;
+var LocalTransport = class {
+  baseUrl;
+  authHeader;
+  constructor(opts = {}) {
+    this.baseUrl = `http://localhost:${opts.port ?? DEFAULT_PORT}`;
+    this.authHeader = opts.password ? `Bearer ${opts.password}` : null;
+  }
+  headers() {
+    const h = { "Content-Type": "application/json" };
+    if (this.authHeader) h["Authorization"] = this.authHeader;
+    return h;
+  }
+  async getStatus() {
+    const res = await fetch(`${this.baseUrl}/api/v1/status`, { headers: this.headers() });
+    if (!res.ok) throw new Error(`Status fetch failed: ${res.status}`);
+    return res.json();
+  }
+  async command(type, args = {}) {
+    const res = await fetch(`${this.baseUrl}/api/v1/command`, {
+      method: "POST",
+      headers: this.headers(),
+      body: JSON.stringify({ type, ...args })
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => res.statusText);
+      throw new Error(`Command ${type} failed: ${res.status} ${text}`);
+    }
+    return res.json();
+  }
+  async ping() {
+    try {
+      await this.getStatus();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/transports/cloud.ts
+var DEFAULT_BASE_URL = "https://api.adhf.dev";
+var CloudTransport = class {
+  baseUrl;
+  apiKey;
+  constructor(opts) {
+    this.apiKey = opts.apiKey;
+    this.baseUrl = opts.baseUrl ?? DEFAULT_BASE_URL;
+  }
+  headers() {
+    return {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${this.apiKey}`
+    };
+  }
+  async listDaemons() {
+    const res = await fetch(`${this.baseUrl}/api/v1/daemons`, { headers: this.headers() });
+    if (!res.ok) throw new Error(`List daemons failed: ${res.status}`);
+    return res.json();
+  }
+  async getStatus(targetId) {
+    const res = await fetch(
+      `${this.baseUrl}/api/v1/shortcuts/${encodeURIComponent(targetId)}/status`,
+      { headers: this.headers() }
+    );
+    if (!res.ok) throw new Error(`Status failed: ${res.status}`);
+    return res.json();
+  }
+  /** Get all sessions for a daemon (returns CompactSessionEntry[]). */
+  async getDaemonStatus(daemonId) {
+    const res = await fetch(
+      `${this.baseUrl}/api/v1/daemons/${encodeURIComponent(daemonId)}/status`,
+      { headers: this.headers() }
+    );
+    if (!res.ok) throw new Error(`Daemon status failed: ${res.status}`);
+    return res.json();
+  }
+  async readChat(targetId, opts = {}) {
+    const params = new URLSearchParams();
+    if (opts.limit) params.set("limit", String(opts.limit));
+    if (opts.sessionId) params.set("sessionId", opts.sessionId);
+    const qs = params.toString() ? `?${params}` : "";
+    const res = await fetch(
+      `${this.baseUrl}/api/v1/shortcuts/${encodeURIComponent(targetId)}/chat${qs}`,
+      { headers: this.headers() }
+    );
+    if (!res.ok) throw new Error(`Read chat failed: ${res.status}`);
+    return res.json();
+  }
+  async sendChat(targetId, message, opts = {}) {
+    const res = await fetch(
+      `${this.baseUrl}/api/v1/shortcuts/${encodeURIComponent(targetId)}/chat`,
+      {
+        method: "POST",
+        headers: this.headers(),
+        body: JSON.stringify({ message, ...opts })
+      }
+    );
+    if (!res.ok) throw new Error(`Send chat failed: ${res.status}`);
+    return res.json();
+  }
+  async approve(targetId, action, agentType) {
+    const res = await fetch(
+      `${this.baseUrl}/api/v1/shortcuts/${encodeURIComponent(targetId)}/approve`,
+      {
+        method: "POST",
+        headers: this.headers(),
+        body: JSON.stringify({ action, ...agentType ? { agentType } : {} })
+      }
+    );
+    if (!res.ok) throw new Error(`Approve failed: ${res.status}`);
+    return res.json();
+  }
+  async gitStatus(daemonId, workspace, includeDiff = true) {
+    const params = new URLSearchParams({ workspace, includeDiff: String(includeDiff) });
+    const res = await fetch(
+      `${this.baseUrl}/api/v1/shortcuts/${encodeURIComponent(daemonId)}/git-status?${params}`,
+      { headers: this.headers() }
+    );
+    if (!res.ok) throw new Error(`Git status failed: ${res.status}`);
+    return res.json();
+  }
+  async launch(daemonId, opts) {
+    const res = await fetch(
+      `${this.baseUrl}/api/v1/shortcuts/${encodeURIComponent(daemonId)}/launch`,
+      {
+        method: "POST",
+        headers: this.headers(),
+        body: JSON.stringify(opts)
+      }
+    );
+    if (!res.ok) throw new Error(`Launch failed: ${res.status}`);
+    return res.json();
+  }
+  async ping() {
+    try {
+      await this.listDaemons();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/tools/list-sessions.ts
+var FORMAT_PROP = {
+  format: {
+    type: "string",
+    enum: ["text", "json"],
+    description: "Output format: 'text' (default, human-readable) or 'json' (structured, for programmatic use)."
+  }
+};
+var LIST_SESSIONS_TOOL = {
+  name: "list_sessions",
+  description: "List all currently connected IDE and CLI agent sessions on the local machine.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      ...FORMAT_PROP
+    },
+    required: []
+  }
+};
+async function listSessions(transport, args = {}) {
+  const asJson = args.format === "json";
+  if ("getStatus" in transport) {
+    const status = await transport.getStatus();
+    const sessions = status?.sessions ?? [];
+    if (asJson) {
+      return JSON.stringify({
+        sessions: sessions.map((s) => ({
+          id: s.id,
+          type: s.providerType ?? s.type ?? "unknown",
+          label: s.label ?? null,
+          status: s.status ?? s.agentStatus ?? null,
+          workspace: s.workspace ?? null
+        }))
+      }, null, 2);
+    }
+    if (sessions.length === 0) return "No active sessions.";
+    const lines2 = sessions.map((s) => {
+      const parts = [`id: ${s.id}`, `type: ${s.providerType ?? s.type ?? "unknown"}`];
+      if (s.label) parts.push(`label: ${s.label}`);
+      if (s.agentStatus) parts.push(`status: ${s.agentStatus}`);
+      if (s.workspace) parts.push(`workspace: ${s.workspace}`);
+      return parts.join(", ");
+    });
+    return `Sessions (${sessions.length}):
+${lines2.join("\n")}`;
+  }
+  const data = await transport.listDaemons();
+  const daemons = data?.daemons ?? data ?? [];
+  if (asJson) {
+    const sessions = [];
+    for (const d of daemons) {
+      for (const s of d.sessions ?? []) {
+        sessions.push({
+          daemon_id: d.id,
+          id: s.id,
+          type: s.providerType ?? "unknown",
+          status: s.status ?? s.agentStatus ?? null,
+          workspace: s.workspace ?? null
+        });
+      }
+    }
+    return JSON.stringify({ sessions }, null, 2);
+  }
+  if (daemons.length === 0) return "No connected daemons.";
+  const lines = [];
+  for (const d of daemons) {
+    const sessions = d.sessions ?? [];
+    for (const s of sessions) {
+      lines.push(
+        `daemon: ${d.id}, session: ${s.id}, type: ${s.providerType ?? "unknown"}${s.agentStatus ? `, status: ${s.agentStatus}` : ""}`
+      );
+    }
+    if (sessions.length === 0) lines.push(`daemon: ${d.id} (no sessions)`);
+  }
+  return lines.length > 0 ? `Sessions:
+${lines.join("\n")}` : "No active sessions.";
+}
+
+// src/tools/read-chat.ts
+var READ_CHAT_TOOL = {
+  name: "read_chat",
+  description: "Read the current chat conversation from an IDE agent session. Returns recent messages.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      session_id: {
+        type: "string",
+        description: "Target session ID (from list_sessions). Omit to use the active session."
+      },
+      limit: {
+        type: "number",
+        description: "Max messages to return (default: 50)."
+      },
+      daemon_id: {
+        type: "string",
+        description: "Daemon ID (cloud mode only). Omit for local mode."
+      },
+      ...FORMAT_PROP
+    },
+    required: []
+  }
+};
+async function readChat(transport, args) {
+  const limit = args.limit ?? 50;
+  if ("command" in transport) {
+    const result2 = await transport.command("read_chat", {
+      ...args.session_id ? { targetSessionId: args.session_id } : {},
+      limit
+    });
+    return formatChatResult(result2, args.session_id, args.format);
+  }
+  if (!args.daemon_id) throw new Error("daemon_id is required in cloud mode");
+  const targetId = args.session_id ? `${args.daemon_id}:session:${args.session_id}` : args.daemon_id;
+  const result = await transport.readChat(targetId, { limit, sessionId: args.session_id });
+  return formatChatResult(result, args.session_id, args.format);
+}
+function formatChatResult(result, sessionId, format) {
+  if (!result?.success && result?.error) {
+    if (format === "json") return JSON.stringify({ error: result.error, messages: [] }, null, 2);
+    return `Error: ${result.error}`;
+  }
+  const messages = result?.messages ?? result?.data?.messages ?? [];
+  if (format === "json") {
+    return JSON.stringify({
+      session_id: sessionId ?? null,
+      messages: messages.slice(-50).map((m) => ({
+        role: m.role,
+        kind: m.kind ?? null,
+        content: typeof m.content === "string" ? m.content : Array.isArray(m.content) ? m.content.map((p) => typeof p === "string" ? p : p?.text ?? "").join("") : "",
+        timestamp: m.timestamp ?? null
+      }))
+    }, null, 2);
+  }
+  if (messages.length === 0) return "No messages in chat.";
+  const lines = messages.slice(-50).map((m) => {
+    const role = m.role === "user" ? "User" : m.role === "assistant" ? "Agent" : m.role;
+    const content = typeof m.content === "string" ? m.content : Array.isArray(m.content) ? m.content.map((p) => typeof p === "string" ? p : p?.text ?? "").join("") : "";
+    const truncated = content.length > 500 ? `${content.slice(0, 500)}\u2026` : content;
+    return `[${role}] ${truncated}`;
+  });
+  return lines.join("\n\n");
+}
+
+// src/tools/send-chat.ts
+var SEND_CHAT_TOOL = {
+  name: "send_chat",
+  description: "Send a message to an IDE agent session.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      message: {
+        type: "string",
+        description: "The message to send to the agent."
+      },
+      session_id: {
+        type: "string",
+        description: "Target session ID (from list_sessions). Omit to use the active session."
+      },
+      daemon_id: {
+        type: "string",
+        description: "Daemon ID (cloud mode only). Omit for local mode."
+      }
+    },
+    required: ["message"]
+  }
+};
+async function sendChat(transport, args) {
+  if (!args.message?.trim()) throw new Error("message is required");
+  if ("command" in transport) {
+    const result2 = await transport.command("send_chat", {
+      message: args.message,
+      ...args.session_id ? { targetSessionId: args.session_id } : {}
+    });
+    if (result2?.success === false) return `Error: ${result2.error ?? "send_chat failed"}`;
+    return "Message sent.";
+  }
+  if (!args.daemon_id) throw new Error("daemon_id is required in cloud mode");
+  const targetId = args.session_id ? `${args.daemon_id}:session:${args.session_id}` : args.daemon_id;
+  const result = await transport.sendChat(targetId, args.message, {
+    ...args.session_id ? { sessionId: args.session_id } : {}
+  });
+  if (result?.success === false) return `Error: ${result.error ?? "send_chat failed"}`;
+  return "Message sent.";
+}
+
+// src/tools/approve.ts
+var APPROVE_TOOL = {
+  name: "approve",
+  description: "Approve or reject a pending agent action (e.g. file write, command execution).",
+  inputSchema: {
+    type: "object",
+    properties: {
+      action: {
+        type: "string",
+        enum: ["approve", "reject"],
+        description: "Whether to approve or reject the pending action."
+      },
+      session_id: {
+        type: "string",
+        description: "Target session ID. Omit to use the active session."
+      },
+      daemon_id: {
+        type: "string",
+        description: "Daemon ID (cloud mode only)."
+      }
+    },
+    required: ["action"]
+  }
+};
+async function approve(transport, args) {
+  const action = args.action === "reject" ? "reject" : "approve";
+  if ("command" in transport) {
+    const result2 = await transport.command("resolve_action", {
+      action,
+      ...args.session_id ? { targetSessionId: args.session_id } : {}
+    });
+    if (result2?.success === false) return `Error: ${result2.error ?? "resolve_action failed"}`;
+    return `Action ${action}d.`;
+  }
+  if (!args.daemon_id) throw new Error("daemon_id is required in cloud mode");
+  const targetId = args.session_id ? `${args.daemon_id}:session:${args.session_id}` : args.daemon_id;
+  const result = await transport.approve(targetId, action);
+  if (result?.success === false) return `Error: ${result.error ?? "approve failed"}`;
+  return `Action ${action}d.`;
+}
+
+// src/tools/screenshot.ts
+var SCREENSHOT_TOOL = {
+  name: "screenshot",
+  description: "Capture a screenshot of the current IDE window. Returns the image.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      session_id: {
+        type: "string",
+        description: "Target session ID. Omit to use the active session."
+      },
+      daemon_id: {
+        type: "string",
+        description: "Daemon ID (cloud mode only)."
+      }
+    },
+    required: []
+  }
+};
+async function screenshot(transport, args) {
+  let result;
+  if ("command" in transport) {
+    result = await transport.command("screenshot", {
+      ...args.session_id ? { targetSessionId: args.session_id } : {}
+    });
+  } else {
+    return { type: "text", text: "Screenshots are not available in cloud mode. Run adhdev mcp in local mode (requires standalone daemon)." };
+  }
+  if (result?.success === false) {
+    return { type: "text", text: `Error: ${result.error ?? "screenshot failed"}` };
+  }
+  const b64 = result?.base64 ?? result?.screenshot ?? result?.result;
+  if (!b64) {
+    return { type: "text", text: "Screenshot captured but no image data returned." };
+  }
+  const mimeType = result?.format === "png" ? "image/png" : "image/webp";
+  return { type: "image", data: b64, mimeType };
+}
+
+// src/tools/git-status.ts
+var GIT_STATUS_TOOL = {
+  name: "git_status",
+  description: "Get git repository status for a workspace on the daemon machine.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      workspace: {
+        type: "string",
+        description: "Absolute path to the workspace/repository directory."
+      },
+      include_diff: {
+        type: "boolean",
+        description: "Include changed file list (default: true)."
+      },
+      daemon_id: {
+        type: "string",
+        description: "Daemon ID (cloud mode only)."
+      },
+      ...FORMAT_PROP
+    },
+    required: ["workspace"]
+  }
+};
+async function gitStatus(transport, args) {
+  let status;
+  let diffSummary;
+  if ("command" in transport) {
+    const statusResult = await transport.command("git_status", {
+      workspace: args.workspace
+    });
+    status = statusResult?.status ?? statusResult;
+    if (args.include_diff !== false) {
+      const diffResult = await transport.command("git_diff_summary", {
+        workspace: args.workspace
+      });
+      diffSummary = diffResult?.diffSummary ?? diffResult;
+    }
+  } else {
+    if (!args.daemon_id) throw new Error("daemon_id is required in cloud mode");
+    const result = await transport.gitStatus(
+      args.daemon_id,
+      args.workspace,
+      args.include_diff !== false
+    );
+    if (result?.error) {
+      if (args.format === "json") return JSON.stringify({ error: result.error }, null, 2);
+      return `Error: ${result.error}`;
+    }
+    status = result?.status;
+    diffSummary = result?.diff;
+  }
+  if (status?.success === false || status?.reason) {
+    const msg = status?.error ?? status?.reason ?? "unknown";
+    if (args.format === "json") return JSON.stringify({ error: msg }, null, 2);
+    return `Git error: ${msg}`;
+  }
+  if (!status?.isGitRepo) {
+    if (args.format === "json") return JSON.stringify({ error: `Not a git repository: ${args.workspace}` }, null, 2);
+    return `Not a git repository: ${args.workspace}`;
+  }
+  if (args.format === "json") {
+    const files = diffSummary?.files?.map((f) => ({
+      path: f.path,
+      old_path: f.oldPath ?? null,
+      status: f.status ?? "M",
+      insertions: f.insertions ?? 0,
+      deletions: f.deletions ?? 0
+    })) ?? [];
+    return JSON.stringify({
+      branch: status.branch ?? null,
+      head_commit: status.headCommit ?? null,
+      head_message: status.headMessage ?? null,
+      ahead: status.ahead ?? 0,
+      behind: status.behind ?? 0,
+      staged: status.staged ?? 0,
+      modified: status.modified ?? 0,
+      untracked: status.untracked ?? 0,
+      deleted: status.deleted ?? 0,
+      stash_count: status.stashCount ?? 0,
+      has_conflicts: status.hasConflicts ?? false,
+      dirty: status.dirty ?? false,
+      changed_files: files,
+      total_insertions: diffSummary?.totalInsertions ?? 0,
+      total_deletions: diffSummary?.totalDeletions ?? 0
+    }, null, 2);
+  }
+  const lines = [];
+  if (status.branch) lines.push(`Branch: ${status.branch}`);
+  if (status.headCommit) {
+    lines.push(`HEAD: ${status.headCommit.slice(0, 7)}${status.headMessage ? ` \u2014 ${status.headMessage.slice(0, 80)}` : ""}`);
+  }
+  if (status.ahead > 0) lines.push(`Ahead: ${status.ahead}`);
+  if (status.behind > 0) lines.push(`Behind: ${status.behind}`);
+  if (status.staged > 0) lines.push(`Staged: ${status.staged}`);
+  if (status.modified > 0) lines.push(`Modified: ${status.modified}`);
+  if (status.untracked > 0) lines.push(`Untracked: ${status.untracked}`);
+  if (status.deleted > 0) lines.push(`Deleted: ${status.deleted}`);
+  if (status.stashCount > 0) lines.push(`Stashes: ${status.stashCount}`);
+  if (status.hasConflicts) lines.push("Conflicts: YES");
+  if (!status.dirty) lines.push("Working tree: clean");
+  if (diffSummary?.files?.length > 0) {
+    lines.push("");
+    lines.push(`Changed files (${diffSummary.files.length}):`);
+    for (const f of diffSummary.files.slice(0, 20)) {
+      lines.push(`  ${f.status ?? "M"} ${f.path}${f.oldPath ? ` (was ${f.oldPath})` : ""}${f.insertions || f.deletions ? ` +${f.insertions ?? 0}/-${f.deletions ?? 0}` : ""}`);
+    }
+    if (diffSummary.files.length > 20) lines.push(`  \u2026 and ${diffSummary.files.length - 20} more`);
+    if (diffSummary.totalInsertions || diffSummary.totalDeletions) {
+      lines.push(`Total: +${diffSummary.totalInsertions ?? 0}/-${diffSummary.totalDeletions ?? 0}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/tools/launch-session.ts
+var LAUNCH_SESSION_TOOL = {
+  name: "launch_session",
+  description: "Launch a new agent session on the daemon. Supports CLI agents (e.g. hermes-cli, claude-cli, gemini-cli), ACP agents (e.g. claude-acp), and IDEs (e.g. cursor, vscode).",
+  inputSchema: {
+    type: "object",
+    properties: {
+      type: {
+        type: "string",
+        description: "Provider type to launch. CLI examples: hermes-cli, claude-cli, gemini-cli. ACP examples: claude-acp. IDE examples: cursor, vscode."
+      },
+      workspace: {
+        type: "string",
+        description: "Working directory for the session. Defaults to the daemon default workspace."
+      },
+      model: {
+        type: "string",
+        description: "Model override for ACP agents (e.g. claude-opus-4-7)."
+      },
+      daemon_id: {
+        type: "string",
+        description: "Daemon ID (cloud mode only). Required in cloud mode."
+      }
+    },
+    required: ["type"]
+  }
+};
+async function launchSession(transport, args) {
+  if ("command" in transport) {
+    const isCliOrAcp = args.type.includes("-cli") || args.type.includes("-acp") || args.type === "codex";
+    const commandType = isCliOrAcp ? "launch_cli" : "launch_ide";
+    const payload = isCliOrAcp ? { cliType: args.type, dir: args.workspace ?? "~", ...args.model ? { model: args.model } : {} } : { ideType: args.type, enableCdp: true };
+    const result2 = await transport.command(commandType, payload);
+    if (result2?.success === false) return `Error: ${result2.error ?? "launch failed"}`;
+    const id2 = result2?.id ?? result2?.sessionId;
+    return id2 ? `Session launched. id: ${id2}, type: ${args.type}` : `Launched: ${JSON.stringify(result2)}`;
+  }
+  if (!args.daemon_id) throw new Error("daemon_id is required in cloud mode");
+  const result = await transport.launch(args.daemon_id, {
+    type: args.type,
+    dir: args.workspace,
+    model: args.model
+  });
+  if (result?.success === false || result?.error) return `Error: ${result.error ?? "launch failed"}`;
+  const id = result?.id ?? result?.sessionId;
+  return id ? `Session launched. id: ${id}, type: ${args.type}` : `Launched: ${JSON.stringify(result)}`;
+}
+
+// src/tools/check-pending.ts
+var CHECK_PENDING_TOOL = {
+  name: "check_pending",
+  description: "List all agent sessions currently waiting for user approval (tool-use confirmation). Returns session ID, daemon ID, workspace, and the approval prompt message when available. Use approve() with the session_id to approve or reject.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      daemon_id: {
+        type: "string",
+        description: "Daemon ID to check (cloud mode). Omit to check all daemons."
+      },
+      ...FORMAT_PROP
+    },
+    required: []
+  }
+};
+async function checkPending(transport, args) {
+  if ("getStatus" in transport) {
+    return checkPendingLocal(transport, args.format);
+  }
+  return checkPendingCloud(transport, args.daemon_id, args.format);
+}
+async function checkPendingLocal(transport, format) {
+  const status = await transport.getStatus();
+  const sessions = status?.sessions ?? [];
+  const pending = sessions.filter(
+    (s) => s.status === "waiting_approval" || s.agentStatus === "waiting_approval"
+  );
+  if (format === "json") {
+    return JSON.stringify({
+      pending: pending.map((s) => ({
+        session_id: s.id,
+        workspace: s.workspace ?? null,
+        type: s.providerType ?? null,
+        modal_message: s.activeChat?.activeModal?.message ?? null,
+        buttons: s.activeChat?.activeModal?.buttons ?? []
+      }))
+    }, null, 2);
+  }
+  if (pending.length === 0) return "No sessions waiting for approval.";
+  const lines = pending.map((s) => {
+    const modal = s.activeChat?.activeModal;
+    const parts = [`session_id: ${s.id}`];
+    if (s.workspace) parts.push(`workspace: ${s.workspace}`);
+    if (s.providerType) parts.push(`type: ${s.providerType}`);
+    if (modal?.message) parts.push(`prompt: ${modal.message}`);
+    if (modal?.buttons?.length) parts.push(`buttons: ${modal.buttons.join(", ")}`);
+    return parts.join("\n  ");
+  });
+  return `Pending approvals (${pending.length}):
+
+${lines.join("\n\n")}`;
+}
+async function checkPendingCloud(transport, daemonId, format) {
+  const pending = [];
+  if (daemonId) {
+    const daemonStatus = await transport.getDaemonStatus(daemonId);
+    const sessions = daemonStatus?.sessions ?? [];
+    for (const s of sessions) {
+      if (s.status === "waiting_approval") pending.push({ daemonId, session: s });
+    }
+  } else {
+    const data = await transport.listDaemons();
+    const daemons = data?.daemons ?? [];
+    for (let i = 0; i < daemons.length; i += 5) {
+      await Promise.allSettled(
+        daemons.slice(i, i + 5).map(async (d) => {
+          try {
+            const daemonStatus = await transport.getDaemonStatus(d.id);
+            const sessions = daemonStatus?.sessions ?? [];
+            for (const s of sessions) {
+              if (s.status === "waiting_approval") pending.push({ daemonId: d.id, session: s });
+            }
+          } catch {
+          }
+        })
+      );
+    }
+  }
+  if (format === "json") {
+    return JSON.stringify({
+      pending: pending.map(({ daemonId: dId, session: s }) => ({
+        daemon_id: dId,
+        session_id: s.id,
+        workspace: s.workspace ?? null,
+        type: s.providerType ?? null,
+        modal_message: null,
+        buttons: []
+      }))
+    }, null, 2);
+  }
+  if (pending.length === 0) return "No sessions waiting for approval.";
+  const lines = pending.map(({ daemonId: dId, session: s }) => {
+    const parts = [`daemon_id: ${dId}`, `session_id: ${s.id}`];
+    if (s.workspace) parts.push(`workspace: ${s.workspace}`);
+    if (s.providerType) parts.push(`type: ${s.providerType}`);
+    parts.push("(use read_chat to see the approval prompt)");
+    return parts.join("\n  ");
+  });
+  return `Pending approvals (${pending.length}):
+
+${lines.join("\n\n")}`;
+}
+
+// src/server.ts
+async function startMcpServer(opts) {
+  const transport = opts.mode === "cloud" ? new CloudTransport({ apiKey: opts.apiKey, baseUrl: opts.baseUrl }) : new LocalTransport({ port: opts.port, password: opts.password });
+  const alive = await transport.ping();
+  if (!alive) {
+    const hint = opts.mode === "local" ? `Make sure the standalone daemon is running (adhdev standalone or npx @adhdev/daemon-standalone).` : `Check your API key and network connectivity.`;
+    process.stderr.write(`[adhdev-mcp] Cannot reach ${opts.mode} daemon. ${hint}
+`);
+    process.exit(1);
+  }
+  const isLocal = opts.mode === "local";
+  const allTools = [
+    LIST_SESSIONS_TOOL,
+    LAUNCH_SESSION_TOOL,
+    CHECK_PENDING_TOOL,
+    READ_CHAT_TOOL,
+    SEND_CHAT_TOOL,
+    APPROVE_TOOL,
+    GIT_STATUS_TOOL,
+    ...isLocal ? [SCREENSHOT_TOOL] : []
+  ];
+  const server = new import_server.Server(
+    { name: "adhdev-mcp-server", version: "0.9.60" },
+    { capabilities: { tools: {} } }
+  );
+  server.setRequestHandler(import_types.ListToolsRequestSchema, async () => ({ tools: allTools }));
+  server.setRequestHandler(import_types.CallToolRequestSchema, async (req) => {
+    const { name, arguments: args } = req.params;
+    const a = args ?? {};
+    try {
+      switch (name) {
+        case "list_sessions": {
+          const text = await listSessions(transport, { format: a.format });
+          return { content: [{ type: "text", text }] };
+        }
+        case "read_chat": {
+          const text = await readChat(transport, a);
+          return { content: [{ type: "text", text }] };
+        }
+        case "send_chat": {
+          const text = await sendChat(transport, { message: a.message, session_id: a.session_id, daemon_id: a.daemon_id });
+          return { content: [{ type: "text", text }] };
+        }
+        case "approve": {
+          const action = a.action === "reject" ? "reject" : "approve";
+          const text = await approve(transport, { action, session_id: a.session_id, daemon_id: a.daemon_id });
+          return { content: [{ type: "text", text }] };
+        }
+        case "screenshot": {
+          const result = await screenshot(transport, { session_id: a.session_id, daemon_id: a.daemon_id });
+          if (result.type === "image") {
+            return {
+              content: [{ type: "image", data: result.data, mimeType: result.mimeType }]
+            };
+          }
+          return { content: [{ type: "text", text: result.text }] };
+        }
+        case "git_status": {
+          const text = await gitStatus(transport, { workspace: a.workspace, include_diff: a.include_diff, daemon_id: a.daemon_id, format: a.format });
+          return { content: [{ type: "text", text }] };
+        }
+        case "launch_session": {
+          const text = await launchSession(transport, {
+            type: a.type,
+            workspace: a.workspace,
+            model: a.model,
+            daemon_id: a.daemon_id
+          });
+          return { content: [{ type: "text", text }] };
+        }
+        case "check_pending": {
+          const text = await checkPending(transport, { daemon_id: a.daemon_id, format: a.format });
+          return { content: [{ type: "text", text }] };
+        }
+        default:
+          return { content: [{ type: "text", text: `Unknown tool: ${name}` }], isError: true };
+      }
+    } catch (err) {
+      return {
+        content: [{ type: "text", text: `Error: ${err?.message ?? String(err)}` }],
+        isError: true
+      };
+    }
+  });
+  const stdioTransport = new import_stdio.StdioServerTransport();
+  await server.connect(stdioTransport);
+  process.stderr.write(`[adhdev-mcp] Server running in ${opts.mode} mode.
+`);
+}
+
+// src/index.ts
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  let apiKey;
+  let baseUrl;
+  let port;
+  let password;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if ((arg === "--api-key" || arg === "-k") && args[i + 1]) {
+      apiKey = args[++i];
+    } else if (arg?.startsWith("--api-key=")) {
+      apiKey = arg.slice("--api-key=".length);
+    } else if (arg === "--base-url" && args[i + 1]) {
+      baseUrl = args[++i];
+    } else if (arg === "--port" && args[i + 1]) {
+      port = Number(args[++i]);
+    } else if (arg?.startsWith("--port=")) {
+      port = Number(arg.slice("--port=".length));
+    } else if (arg === "--password" && args[i + 1]) {
+      password = args[++i];
+    } else if (arg === "--help" || arg === "-h") {
+      printHelp();
+      process.exit(0);
+    }
+  }
+  if (!apiKey && process.env.ADHDEV_API_KEY) apiKey = process.env.ADHDEV_API_KEY;
+  if (!password && process.env.ADHDEV_PASSWORD) password = process.env.ADHDEV_PASSWORD;
+  const mode = apiKey ? "cloud" : "local";
+  return { mode, port, password, apiKey, baseUrl };
+}
+function printHelp() {
+  console.error(`
+adhdev-mcp \u2014 ADHDev MCP Server
+
+Usage:
+  adhdev-mcp                         Local mode (requires standalone daemon)
+  adhdev-mcp --api-key <key>         Cloud mode (ADHDev cloud API)
+
+Options:
+  --port <n>          Standalone daemon port (default: 3847)
+  --password <pass>   Standalone daemon password (if set)
+  --api-key <key>     ADHDev cloud API key (switches to cloud mode)
+  --base-url <url>    Override cloud API base URL
+  --help              Show this help
+
+Environment variables:
+  ADHDEV_API_KEY      API key (cloud mode)
+  ADHDEV_PASSWORD     Daemon password (local mode)
+
+Local mode tools:   list_sessions, launch_session, check_pending, read_chat, send_chat, approve, git_status, screenshot
+Cloud mode tools:   list_sessions, launch_session, check_pending, read_chat, send_chat, approve, git_status
+`.trim());
+}
+startMcpServer(parseArgs(process.argv)).catch((err) => {
+  process.stderr.write(`[adhdev-mcp] Fatal: ${err?.message ?? err}
+`);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map