adhdev 0.9.65 → 0.9.67

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adhdev",
-  "version": "0.9.65",
+  "version": "0.9.67",
   "description": "ADHDev — Agent Dashboard Hub for Dev. Remote-control AI coding agents from anywhere.",
   "main": "dist/index.js",
   "bin": {

package/vendor/mcp-server/index.js

@@ -1,5 +1,27 @@
 #!/usr/bin/env node
 "use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 
 // src/server.ts
 var import_server = require("@modelcontextprotocol/sdk/server/index.js");
@@ -1242,6 +1264,248 @@ async function checkPendingCloud(transport, daemonId, format) {
 ${lines.join("\n\n")}`;
 }
 
+// src/tools/mesh-tools.ts
+function findNode(mesh, nodeId) {
+  const node = mesh.nodes.find((n) => n.id === nodeId);
+  if (!node) throw new Error(`Node '${nodeId}' is not a member of mesh '${mesh.name}'`);
+  return node;
+}
+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.",
+  inputSchema: {
+    type: "object",
+    properties: {}
+  }
+};
+var MESH_LIST_NODES_TOOL = {
+  name: "mesh_list_nodes",
+  description: "List all nodes in the mesh with their capabilities, platform, and workspace paths.",
+  inputSchema: {
+    type: "object",
+    properties: {}
+  }
+};
+var MESH_SEND_TASK_TOOL = {
+  name: "mesh_send_task",
+  description: "Send a natural-language task to an agent session on a mesh node. The agent will execute the task autonomously.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      node_id: { type: "string", description: "Target node ID (from mesh_list_nodes)." },
+      session_id: { type: "string", description: "Agent session ID on the target node." },
+      message: { type: "string", description: "Natural-language task to send to the agent." }
+    },
+    required: ["node_id", "session_id", "message"]
+  }
+};
+var MESH_READ_CHAT_TOOL = {
+  name: "mesh_read_chat",
+  description: "Read recent chat messages from a delegated agent session on a mesh node. Use this to check progress.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      node_id: { type: "string", description: "Target node ID." },
+      session_id: { type: "string", description: "Agent session ID to read from." },
+      tail: { type: "number", description: "Number of recent messages to return (default: 10)." }
+    },
+    required: ["node_id", "session_id"]
+  }
+};
+var MESH_LAUNCH_SESSION_TOOL = {
+  name: "mesh_launch_session",
+  description: "Launch a new agent session on a mesh node. Returns the session ID for subsequent send_task/read_chat calls.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      node_id: { type: "string", description: "Target node ID." },
+      type: { type: "string", description: 'Provider type (e.g. "claude-cli", "gemini-cli", "cursor").' }
+    },
+    required: ["node_id", "type"]
+  }
+};
+var MESH_GIT_STATUS_TOOL = {
+  name: "mesh_git_status",
+  description: "Get git status for a mesh node workspace \u2014 branch, dirty state, changed files.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      node_id: { type: "string", description: "Target node ID." }
+    },
+    required: ["node_id"]
+  }
+};
+var MESH_CHECKPOINT_TOOL = {
+  name: "mesh_checkpoint",
+  description: "Create a git checkpoint (commit) on a mesh node workspace.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      node_id: { type: "string", description: "Target node ID." },
+      message: { type: "string", description: "Checkpoint commit message." }
+    },
+    required: ["node_id", "message"]
+  }
+};
+var MESH_APPROVE_TOOL = {
+  name: "mesh_approve",
+  description: "Approve or reject a pending action on a delegated agent session.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      node_id: { type: "string", description: "Target node ID." },
+      session_id: { type: "string", description: "Agent session ID with pending approval." },
+      action: { type: "string", enum: ["approve", "reject"], description: "Action to take." }
+    },
+    required: ["node_id", "session_id", "action"]
+  }
+};
+var ALL_MESH_TOOLS = [
+  MESH_STATUS_TOOL,
+  MESH_LIST_NODES_TOOL,
+  MESH_SEND_TASK_TOOL,
+  MESH_READ_CHAT_TOOL,
+  MESH_LAUNCH_SESSION_TOOL,
+  MESH_GIT_STATUS_TOOL,
+  MESH_CHECKPOINT_TOOL,
+  MESH_APPROVE_TOOL
+];
+async function meshStatus(ctx) {
+  const { mesh, transport } = ctx;
+  const results = [];
+  for (const node of mesh.nodes) {
+    const entry = {
+      nodeId: node.id,
+      workspace: node.workspace
+    };
+    try {
+      if (isLocalTransport(transport)) {
+        const statusResult = await transport.command("git_status", { workspace: node.workspace });
+        const status = statusResult?.status ?? statusResult;
+        entry.health = status?.isGitRepo ? status?.isDirty ? "dirty" : "online" : "degraded";
+        entry.branch = status?.branch;
+        entry.isDirty = status?.isDirty;
+        entry.uncommittedChanges = status?.uncommittedChanges ?? 0;
+      } else {
+        entry.health = "unknown";
+        entry.note = "Cloud status probe not yet implemented for mesh nodes";
+      }
+    } catch (e) {
+      entry.health = "degraded";
+      entry.error = e.message;
+    }
+    results.push(entry);
+  }
+  return JSON.stringify({
+    meshId: mesh.id,
+    meshName: mesh.name,
+    repoIdentity: mesh.repoIdentity,
+    policy: mesh.policy,
+    refreshedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    nodes: results
+  }, null, 2);
+}
+async function meshListNodes(ctx) {
+  const { mesh } = ctx;
+  return JSON.stringify({
+    meshId: mesh.id,
+    meshName: mesh.name,
+    nodes: mesh.nodes.map((n) => ({
+      nodeId: n.id,
+      workspace: n.workspace,
+      repoRoot: n.repoRoot,
+      isLocalWorktree: n.isLocalWorktree,
+      policy: n.policy,
+      userOverrides: n.userOverrides
+    }))
+  }, null, 2);
+}
+async function meshSendTask(ctx, args) {
+  const node = findNode(ctx.mesh, args.node_id);
+  if (node.policy.readOnly) {
+    return JSON.stringify({ error: `Node '${args.node_id}' is read-only` });
+  }
+  if (isLocalTransport(ctx.transport)) {
+    await ctx.transport.command("send_chat", {
+      message: args.message,
+      sessionId: args.session_id
+    });
+    return JSON.stringify({ success: true, nodeId: args.node_id, sessionId: args.session_id });
+  } else {
+    return JSON.stringify({ error: "Cloud mesh send_task not yet implemented" });
+  }
+}
+async function meshReadChat(ctx, args) {
+  findNode(ctx.mesh, args.node_id);
+  if (isLocalTransport(ctx.transport)) {
+    const result = await ctx.transport.command("read_chat", {
+      sessionId: args.session_id,
+      tailLimit: args.tail ?? 10
+    });
+    return JSON.stringify(result, null, 2);
+  } else {
+    return JSON.stringify({ error: "Cloud mesh read_chat not yet implemented" });
+  }
+}
+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", {
+      type: args.type,
+      dir: node.workspace
+    });
+    return JSON.stringify(result, null, 2);
+  } else {
+    return JSON.stringify({ error: "Cloud mesh launch_session not yet implemented" });
+  }
+}
+async function meshGitStatus(ctx, args) {
+  const node = findNode(ctx.mesh, args.node_id);
+  if (isLocalTransport(ctx.transport)) {
+    const statusResult = await ctx.transport.command("git_status", {
+      workspace: node.workspace
+    });
+    const diffResult = await ctx.transport.command("git_diff_summary", {
+      workspace: node.workspace
+    });
+    return JSON.stringify({
+      nodeId: args.node_id,
+      workspace: node.workspace,
+      status: statusResult?.status ?? statusResult,
+      diff: diffResult?.diffSummary ?? diffResult
+    }, null, 2);
+  } else {
+    return JSON.stringify({ error: "Cloud mesh git_status not yet implemented" });
+  }
+}
+async function meshCheckpoint(ctx, args) {
+  const node = findNode(ctx.mesh, args.node_id);
+  if (node.policy.readOnly) {
+    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", {
+      workspace: node.workspace,
+      message: args.message
+    });
+    return JSON.stringify(result, null, 2);
+  } else {
+    return JSON.stringify({ error: "Cloud mesh checkpoint not yet implemented" });
+  }
+}
+async function meshApprove(ctx, args) {
+  findNode(ctx.mesh, args.node_id);
+  if (isLocalTransport(ctx.transport)) {
+    const result = await ctx.transport.command("resolve_action", {
+      sessionId: args.session_id,
+      action: args.action === "reject" ? "reject" : "approve"
+    });
+    return JSON.stringify(result, null, 2);
+  } else {
+    return JSON.stringify({ error: "Cloud mesh approve not yet implemented" });
+  }
+}
+
 // 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 });
@@ -1253,6 +1517,150 @@ async function startMcpServer(opts) {
     process.exit(1);
   }
   const isLocal = opts.mode === "local";
+  if (opts.meshId) {
+    let mesh;
+    if (opts.mode === "cloud" && opts.apiKey) {
+      try {
+        const base = opts.baseUrl || "https://api.adhf.dev";
+        const res = await fetch(`${base}/api/v1/repo-meshes/${opts.meshId}`, {
+          headers: { "Authorization": `Bearer ${opts.apiKey}`, "Content-Type": "application/json" }
+        });
+        if (res.ok) {
+          const data = await res.json();
+          const rm = data.mesh;
+          const nodes = data.nodes || [];
+          let policy = {};
+          try {
+            policy = JSON.parse(rm.policy_json || rm.policy || "{}");
+          } catch {
+          }
+          let coordinator = {};
+          try {
+            coordinator = JSON.parse(rm.coordinator_json || rm.coordinator_config || "{}");
+          } catch {
+          }
+          mesh = {
+            id: rm.id,
+            name: rm.name,
+            repoIdentity: rm.repo_identity,
+            repoRemoteUrl: rm.repo_remote_url,
+            defaultBranch: rm.default_branch,
+            policy: {
+              requirePreTaskCheckpoint: false,
+              requirePostTaskCheckpoint: true,
+              requireApprovalForPush: true,
+              requireApprovalForDestructiveGit: true,
+              dirtyWorkspaceBehavior: "warn",
+              maxParallelTasks: 2,
+              ...policy
+            },
+            coordinator,
+            nodes: nodes.map((n) => ({
+              id: n.id,
+              workspace: n.workspace,
+              repoRoot: n.repo_root,
+              userOverrides: {},
+              policy: {},
+              isLocalWorktree: false
+            })),
+            createdAt: rm.created_at,
+            updatedAt: rm.updated_at
+          };
+          process.stderr.write(`[adhdev-mcp] Loaded mesh config from cloud API
+`);
+        }
+      } catch (e) {
+        process.stderr.write(`[adhdev-mcp] Cloud mesh fetch failed, falling back to local: ${e.message}
+`);
+      }
+    }
+    if (!mesh) {
+      try {
+        const { getMesh } = await import("@adhdev/daemon-core");
+        mesh = getMesh(opts.meshId);
+      } catch (e) {
+        process.stderr.write(`[adhdev-mcp] Failed to load mesh config: ${e.message}
+`);
+        process.exit(1);
+      }
+    }
+    if (!mesh) {
+      process.stderr.write(`[adhdev-mcp] Mesh '${opts.meshId}' not found in ${opts.mode === "cloud" ? "cloud or local" : "local"} config. Use 'adhdev mesh list' to see available meshes.
+`);
+      process.exit(1);
+    }
+    const meshCtx = { mesh, transport };
+    let coordinatorPrompt = "";
+    try {
+      const { buildCoordinatorSystemPrompt } = await import("@adhdev/daemon-core");
+      coordinatorPrompt = buildCoordinatorSystemPrompt({ mesh });
+    } catch {
+      coordinatorPrompt = `You are a Repo Mesh Coordinator for "${mesh.name}" (${mesh.repoIdentity}). Use mesh_* tools to orchestrate work.`;
+    }
+    const server2 = new import_server.Server(
+      { name: "adhdev-mcp-server", version: "0.9.67" },
+      { capabilities: { tools: {}, resources: {} } }
+    );
+    const { ListResourcesRequestSchema, ReadResourceRequestSchema } = await import("@modelcontextprotocol/sdk/types.js");
+    server2.setRequestHandler(ListResourcesRequestSchema, async () => ({
+      resources: [{
+        uri: "coordinator://system-prompt",
+        name: "Coordinator System Prompt",
+        description: `System prompt for mesh "${mesh.name}" coordinator`,
+        mimeType: "text/plain"
+      }]
+    }));
+    server2.setRequestHandler(ReadResourceRequestSchema, async (req) => {
+      if (req.params.uri === "coordinator://system-prompt") {
+        return { contents: [{ uri: req.params.uri, mimeType: "text/plain", text: coordinatorPrompt }] };
+      }
+      throw new Error(`Unknown resource: ${req.params.uri}`);
+    });
+    server2.setRequestHandler(import_types.ListToolsRequestSchema, async () => ({ tools: ALL_MESH_TOOLS }));
+    server2.setRequestHandler(import_types.CallToolRequestSchema, async (req) => {
+      const { name, arguments: args } = req.params;
+      const a = args ?? {};
+      try {
+        let text;
+        switch (name) {
+          case "mesh_status":
+            text = await meshStatus(meshCtx);
+            break;
+          case "mesh_list_nodes":
+            text = await meshListNodes(meshCtx);
+            break;
+          case "mesh_send_task":
+            text = await meshSendTask(meshCtx, a);
+            break;
+          case "mesh_read_chat":
+            text = await meshReadChat(meshCtx, a);
+            break;
+          case "mesh_launch_session":
+            text = await meshLaunchSession(meshCtx, a);
+            break;
+          case "mesh_git_status":
+            text = await meshGitStatus(meshCtx, a);
+            break;
+          case "mesh_checkpoint":
+            text = await meshCheckpoint(meshCtx, a);
+            break;
+          case "mesh_approve":
+            text = await meshApprove(meshCtx, a);
+            break;
+          default:
+            return { content: [{ type: "text", text: `Unknown tool: ${name}` }], isError: true };
+        }
+        return { content: [{ type: "text", text }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: `Error: ${err?.message ?? String(err)}` }], isError: true };
+      }
+    });
+    const stdioTransport2 = new import_stdio.StdioServerTransport();
+    await server2.connect(stdioTransport2);
+    process.stderr.write(`[adhdev-mcp] Server running in ${opts.mode} mesh mode \u2014 mesh: ${mesh.name} (${mesh.repoIdentity})
+`);
+    return;
+  }
   const allTools = [
     LIST_DAEMONS_TOOL,
     LIST_SESSIONS_TOOL,
@@ -1270,7 +1678,7 @@ async function startMcpServer(opts) {
     ...isLocal ? [SCREENSHOT_TOOL] : []
   ];
   const server = new import_server.Server(
-    { name: "adhdev-mcp-server", version: "0.9.65" },
+    { name: "adhdev-mcp-server", version: "0.9.66" },
     { capabilities: { tools: {} } }
   );
   server.setRequestHandler(import_types.ListToolsRequestSchema, async () => ({ tools: allTools }));
@@ -1373,6 +1781,7 @@ function parseArgs(argv) {
   let baseUrl;
   let port;
   let password;
+  let meshId;
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
     if ((arg === "--api-key" || arg === "-k") && args[i + 1]) {
@@ -1387,6 +1796,10 @@ function parseArgs(argv) {
       port = Number(arg.slice("--port=".length));
     } else if (arg === "--password" && args[i + 1]) {
       password = args[++i];
+    } else if ((arg === "--repo-mesh" || arg === "--mesh") && args[i + 1]) {
+      meshId = args[++i];
+    } else if (arg?.startsWith("--repo-mesh=")) {
+      meshId = arg.slice("--repo-mesh=".length);
     } else if (arg === "--help" || arg === "-h") {
       printHelp();
       process.exit(0);
@@ -1394,30 +1807,34 @@ function parseArgs(argv) {
   }
   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";
-  return { mode, port, password, apiKey, baseUrl };
+  return { mode, port, password, apiKey, baseUrl, meshId };
 }
 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)
+  adhdev-mcp                                    Local mode (requires standalone daemon)
+  adhdev-mcp --api-key <key>                    Cloud mode (ADHDev cloud API)
+  adhdev-mcp --repo-mesh <mesh_id>              Mesh mode (coordinator-scoped tools)
 
 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
+  --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
+  --repo-mesh <mesh_id>   Enable mesh mode \u2014 exposes only mesh-scoped coordinator tools
+  --help                  Show this help
 
 Environment variables:
   ADHDEV_API_KEY      API key (cloud mode)
   ADHDEV_PASSWORD     Daemon password (local mode)
+  ADHDEV_MESH_ID      Mesh ID (mesh mode)
 
-Local mode 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
-Cloud mode 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
+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
 `.trim());
 }
 startMcpServer(parseArgs(process.argv)).catch((err) => {