adhdev 0.9.76-rc.4 → 0.9.76-rc.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adhdev",
-  "version": "0.9.76-rc.4",
+  "version": "0.9.76-rc.6",
   "description": "ADHDev — Agent Dashboard Hub for Dev. Remote-control AI coding agents from anywhere.",
   "main": "dist/index.js",
   "bin": {
@@ -47,7 +47,7 @@
     "node": ">=18"
   },
   "dependencies": {
-    "@adhdev/daemon-core": "0.9.76-rc.4",
+    "@adhdev/daemon-core": "0.9.76-rc.6",
     "@adhdev/ghostty-vt-node": "*",
     "@modelcontextprotocol/sdk": "^1.0.0",
     "@xterm/addon-serialize": "^0.14.0",

package/vendor/mcp-server/index.js

@@ -6,6 +6,10 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -22,6 +26,14 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  parseArgs: () => parseArgs
+});
+module.exports = __toCommonJS(index_exports);
 
 // src/server.ts
 var import_server = require("@modelcontextprotocol/sdk/server/index.js");
@@ -234,6 +246,104 @@ var CloudTransport = class {
   }
 };
 
+// src/transports/ipc.ts
+var DEFAULT_IPC_PORT = 19222;
+var DEFAULT_IPC_PATH = "/ipc";
+var IpcTransport = class {
+  port;
+  path;
+  constructor(opts = {}) {
+    this.port = opts.port ?? DEFAULT_IPC_PORT;
+    this.path = opts.path || DEFAULT_IPC_PATH;
+  }
+  async ping() {
+    try {
+      const res = await fetch(`http://127.0.0.1:${this.port}/health`);
+      return res.ok;
+    } catch {
+      return false;
+    }
+  }
+  async getStatus() {
+    return this.command("get_status_metadata");
+  }
+  async command(type, args = {}) {
+    return this.sendIpcCommand(type, args);
+  }
+  async meshCommand(targetDaemonId, command, args = {}) {
+    return this.sendIpcCommand("mesh_relay_command", {
+      targetDaemonId,
+      command,
+      args
+    });
+  }
+  async sendIpcCommand(type, args) {
+    const WebSocketCtor = globalThis.WebSocket;
+    if (!WebSocketCtor) {
+      throw new Error("WebSocket is not available in this Node runtime; Node 20+ is required for daemon IPC mode");
+    }
+    return new Promise((resolve, reject) => {
+      const requestId = `mcp_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+      const ws = new WebSocketCtor(`ws://127.0.0.1:${this.port}${this.path}`);
+      let settled = false;
+      const finish = (fn) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timeout);
+        try {
+          ws.close();
+        } catch {
+        }
+        fn();
+      };
+      const timeout = setTimeout(() => {
+        finish(() => reject(new Error(`Daemon IPC command '${type}' timed out after 15s`)));
+      }, 15e3);
+      const send = () => {
+        ws.send(JSON.stringify({
+          type: "ext:command",
+          payload: { command: type, args, requestId }
+        }));
+      };
+      ws.addEventListener("open", () => {
+        ws.send(JSON.stringify({
+          type: "ext:register",
+          payload: {
+            ideType: "mcp-server",
+            ideVersion: "1.0.0",
+            extensionVersion: "1.0.0",
+            instanceId: `mcp-server-${process.pid}`,
+            machineId: "mcp-server",
+            workspaceFolders: []
+          }
+        }));
+      });
+      ws.addEventListener("message", (event) => {
+        try {
+          const raw = typeof event.data === "string" ? event.data : String(event.data);
+          const msg = JSON.parse(raw);
+          if (msg?.type === "daemon:welcome") {
+            send();
+            return;
+          }
+          if (msg?.type !== "ext:command_result") return;
+          if (msg?.payload?.requestId !== requestId) return;
+          const payload = msg.payload;
+          if (payload?.success === false) {
+            finish(() => reject(new Error(payload.error || `Daemon IPC command '${type}' failed`)));
+            return;
+          }
+          finish(() => resolve(payload?.result ?? payload));
+        } catch {
+        }
+      });
+      ws.addEventListener("error", () => {
+        finish(() => reject(new Error(`Cannot connect to daemon IPC at ws://127.0.0.1:${this.port}${this.path}`)));
+      });
+    });
+  }
+};
+
 // src/transports/mode.ts
 function isLocalTransport(transport) {
   return typeof transport.command === "function";
@@ -1270,6 +1380,15 @@ function findNode(mesh, nodeId) {
   if (!node) throw new Error(`Node '${nodeId}' is not a member of mesh '${mesh.name}'`);
   return node;
 }
+async function commandForNode(ctx, node, command, args = {}) {
+  if (ctx.transport instanceof IpcTransport && node.daemonId) {
+    return ctx.transport.meshCommand(node.daemonId, command, args);
+  }
+  if (isLocalTransport(ctx.transport)) {
+    return ctx.transport.command(command, args);
+  }
+  throw new Error(`Command '${command}' requires daemon IPC/local transport for node '${node.id}'`);
+}
 var MESH_STATUS_TOOL = {
   name: "mesh_status",
   description: "Get the current status of all nodes in the repo mesh \u2014 health, git state, active sessions. Use this to decide which node to send work to.",
@@ -1387,7 +1506,7 @@ async function meshStatus(ctx) {
         entry.isDirty = status?.isDirty;
         entry.uncommittedChanges = status?.uncommittedChanges ?? 0;
       } else if (isLocalTransport(transport)) {
-        const statusResult = await transport.command("git_status", { workspace: node.workspace });
+        const statusResult = await commandForNode(ctx, node, "git_status", { workspace: node.workspace });
         const status = statusResult?.status ?? statusResult;
         entry.health = status?.isGitRepo ? status?.isDirty ? "dirty" : "online" : "degraded";
         entry.branch = status?.branch;
@@ -1433,9 +1552,10 @@ async function meshSendTask(ctx, args) {
     return JSON.stringify({ error: `Node '${args.node_id}' is read-only` });
   }
   if (isLocalTransport(ctx.transport)) {
-    await ctx.transport.command("send_chat", {
+    await commandForNode(ctx, node, "send_chat", {
       message: args.message,
-      sessionId: args.session_id
+      sessionId: args.session_id,
+      targetSessionId: args.session_id
     });
     return JSON.stringify({ success: true, nodeId: args.node_id, sessionId: args.session_id });
   } else {
@@ -1443,10 +1563,11 @@ async function meshSendTask(ctx, args) {
   }
 }
 async function meshReadChat(ctx, args) {
-  findNode(ctx.mesh, args.node_id);
+  const node = findNode(ctx.mesh, args.node_id);
   if (isLocalTransport(ctx.transport)) {
-    const result = await ctx.transport.command("read_chat", {
+    const result = await commandForNode(ctx, node, "read_chat", {
       sessionId: args.session_id,
+      targetSessionId: args.session_id,
       tailLimit: args.tail ?? 10
     });
     return JSON.stringify(result, null, 2);
@@ -1457,7 +1578,7 @@ async function meshReadChat(ctx, args) {
 async function meshLaunchSession(ctx, args) {
   const node = findNode(ctx.mesh, args.node_id);
   if (isLocalTransport(ctx.transport)) {
-    const result = await ctx.transport.command("launch_cli", {
+    const result = await commandForNode(ctx, node, "launch_cli", {
       cliType: args.type,
       dir: node.workspace,
       settings: {
@@ -1481,10 +1602,10 @@ async function meshGitStatus(ctx, args) {
       diff: result?.diff ?? null
     }, null, 2);
   } else if (isLocalTransport(ctx.transport)) {
-    const statusResult = await ctx.transport.command("git_status", {
+    const statusResult = await commandForNode(ctx, node, "git_status", {
       workspace: node.workspace
     });
-    const diffResult = await ctx.transport.command("git_diff_summary", {
+    const diffResult = await commandForNode(ctx, node, "git_diff_summary", {
       workspace: node.workspace
     });
     return JSON.stringify({
@@ -1503,7 +1624,7 @@ async function meshCheckpoint(ctx, args) {
     return JSON.stringify({ error: `Node '${args.node_id}' is read-only \u2014 cannot checkpoint` });
   }
   if (isLocalTransport(ctx.transport)) {
-    const result = await ctx.transport.command("git_checkpoint", {
+    const result = await commandForNode(ctx, node, "git_checkpoint", {
       workspace: node.workspace,
       message: args.message
     });
@@ -1513,10 +1634,11 @@ async function meshCheckpoint(ctx, args) {
   }
 }
 async function meshApprove(ctx, args) {
-  findNode(ctx.mesh, args.node_id);
+  const node = findNode(ctx.mesh, args.node_id);
   if (isLocalTransport(ctx.transport)) {
-    const result = await ctx.transport.command("resolve_action", {
+    const result = await commandForNode(ctx, node, "resolve_action", {
       sessionId: args.session_id,
+      targetSessionId: args.session_id,
       action: args.action === "reject" ? "reject" : "approve"
     });
     return JSON.stringify(result, null, 2);
@@ -1527,10 +1649,10 @@ async function meshApprove(ctx, args) {
 
 // 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 transport = opts.mode === "cloud" ? new CloudTransport({ apiKey: opts.apiKey, baseUrl: opts.baseUrl }) : opts.mode === "ipc" ? new IpcTransport({ port: opts.port }) : 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.`;
+    const hint = opts.mode === "local" ? `Make sure the standalone daemon is running (adhdev standalone or npx @adhdev/daemon-standalone).` : opts.mode === "ipc" ? `Make sure the cloud daemon is running with local IPC enabled (adhdev daemon).` : `Check your API key and network connectivity.`;
     process.stderr.write(`[adhdev-mcp] Cannot reach ${opts.mode} daemon. ${hint}
 `);
     process.exit(1);
@@ -1613,7 +1735,7 @@ async function startMcpServer(opts) {
 `);
       }
     }
-    if (!mesh && transport instanceof LocalTransport) {
+    if (!mesh && (transport instanceof LocalTransport || transport instanceof IpcTransport)) {
       try {
         const result = await transport.command("get_mesh", { meshId: opts.meshId });
         if (result?.success && result.mesh) {
@@ -1817,13 +1939,14 @@ async function startMcpServer(opts) {
 }
 
 // src/index.ts
-function parseArgs(argv) {
+function parseArgs(argv, env = process.env) {
   const args = argv.slice(2);
   let apiKey;
   let baseUrl;
   let port;
   let password;
   let meshId;
+  let explicitMode;
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
     if ((arg === "--api-key" || arg === "-k") && args[i + 1]) {
@@ -1832,6 +1955,12 @@ function parseArgs(argv) {
       apiKey = arg.slice("--api-key=".length);
     } else if (arg === "--base-url" && args[i + 1]) {
       baseUrl = args[++i];
+    } else if (arg === "--mode" && args[i + 1]) {
+      const value = String(args[++i]).trim();
+      if (value === "local" || value === "cloud" || value === "ipc") explicitMode = value;
+    } else if (arg?.startsWith("--mode=")) {
+      const value = arg.slice("--mode=".length).trim();
+      if (value === "local" || value === "cloud" || value === "ipc") explicitMode = value;
     } else if (arg === "--port" && args[i + 1]) {
       port = Number(args[++i]);
     } else if (arg?.startsWith("--port=")) {
@@ -1847,10 +1976,14 @@ function parseArgs(argv) {
       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;
-  if (!meshId && process.env.ADHDEV_MESH_ID) meshId = process.env.ADHDEV_MESH_ID;
-  const mode = apiKey ? "cloud" : "local";
+  if (!apiKey && env.ADHDEV_API_KEY) apiKey = env.ADHDEV_API_KEY;
+  if (!password && env.ADHDEV_PASSWORD) password = env.ADHDEV_PASSWORD;
+  if (!meshId && env.ADHDEV_MESH_ID) meshId = env.ADHDEV_MESH_ID;
+  if (!explicitMode && env.ADHDEV_MCP_TRANSPORT) {
+    const value = env.ADHDEV_MCP_TRANSPORT.trim();
+    if (value === "local" || value === "cloud" || value === "ipc") explicitMode = value;
+  }
+  const mode = explicitMode || (apiKey ? "cloud" : meshId && env.ADHDEV_INLINE_MESH ? "ipc" : "local");
   return { mode, port, password, apiKey, baseUrl, meshId };
 }
 function printHelp() {
@@ -1860,10 +1993,12 @@ adhdev-mcp \u2014 ADHDev MCP Server
 Usage:
   adhdev-mcp                                    Local mode (requires standalone daemon)
   adhdev-mcp --api-key <key>                    Cloud mode (ADHDev cloud API)
+  adhdev-mcp --mode ipc --repo-mesh <mesh_id>   Cloud daemon IPC mesh mode
   adhdev-mcp --repo-mesh <mesh_id>              Mesh mode (coordinator-scoped tools)
 
 Options:
-  --port <n>              Standalone daemon port (default: 3847)
+  --mode <mode>           Transport: local, cloud, or ipc
+  --port <n>              Standalone or IPC daemon port (defaults: local 3847, ipc 19222)
   --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
@@ -1874,6 +2009,7 @@ Environment variables:
   ADHDEV_API_KEY      API key (cloud mode)
   ADHDEV_PASSWORD     Daemon password (local mode)
   ADHDEV_MESH_ID      Mesh ID (mesh mode)
+  ADHDEV_MCP_TRANSPORT Transport: local, cloud, or ipc
 
 Standard tools:   list_daemons, list_sessions, launch_session, stop_session, check_pending, read_chat, send_chat, approve, git_status, git_log, git_diff, git_checkpoint, git_push, screenshot
 Mesh tools:       mesh_status, mesh_list_nodes, mesh_send_task, mesh_read_chat, mesh_launch_session, mesh_git_status, mesh_checkpoint, mesh_approve
@@ -1884,4 +2020,8 @@ startMcpServer(parseArgs(process.argv)).catch((err) => {
 `);
   process.exit(1);
 });
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parseArgs
+});
 //# sourceMappingURL=index.js.map