shadow-claw 1.26.0 → 1.27.0

package/bin/commands/mcp.mjs

@@ -71,6 +71,22 @@ export const CLI_BUILTIN_TOOLS = [
       },
     },
   },
+  {
+    name: "shadowclaw_set_active_client",
+    description:
+      "Set the active default connected client used when no clientId is explicitly provided in tool calls.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        clientId: {
+          type: "string",
+          description:
+            "Target client ID (or index '0', '1', prefix, or device label) to make active.",
+        },
+      },
+      required: ["clientId"],
+    },
+  },
   {
     name: "shadowclaw_manage_backup",
     description:
@@ -95,6 +111,7 @@ export function createCliMcpEngine(options = {}) {
   const client = options.client || new CliControlClient(options);
   const relayClientTools = options.relayClientTools !== false;
   const targetClientId = options.targetClientId || options.clientTarget;
+  let activeClientId = targetClientId || "";
 
   const serverInfo = {
     name: "shadow-claw",
@@ -107,47 +124,138 @@ export function createCliMcpEngine(options = {}) {
   };
 
   async function resolveTargetId(requestedId) {
-    if (requestedId && typeof requestedId === "string" && requestedId.trim()) {
-      return requestedId.trim();
-    }
-    if (targetClientId) {
-      return targetClientId;
-    }
+    const candidate = requestedId || activeClientId || targetClientId;
     try {
       const clients = await client.listClients();
       if (Array.isArray(clients) && clients.length > 0) {
+        if (candidate && typeof candidate === "string" && candidate.trim()) {
+          const trimmed = candidate.trim();
+          const exact = clients.find((c) => (c.clientId || c.id) === trimmed);
+          if (exact) return exact.clientId || exact.id;
+
+          const idx = parseInt(trimmed, 10);
+          if (!isNaN(idx) && idx >= 0 && idx < clients.length) {
+            return clients[idx].clientId || clients[idx].id;
+          }
+
+          const prefix = clients.find(
+            (c) =>
+              (c.clientId || c.id || "").startsWith(trimmed) ||
+              (c.clientId || "").replace(/^client-/, "").startsWith(trimmed),
+          );
+          if (prefix) return prefix.clientId || prefix.id;
+
+          const byLabel = clients.find((c) =>
+            c.deviceLabel?.toLowerCase().includes(trimmed.toLowerCase()),
+          );
+          if (byLabel) return byLabel.clientId || byLabel.id;
+
+          return trimmed;
+        }
+
         return clients[0].clientId || clients[0].id || "";
       }
     } catch (_) {}
-    return "";
+    return typeof candidate === "string" ? candidate.trim() : "";
   }
 
+  const toolSupportingClientsMap = new Map();
+  const toolDefMap = new Map();
+
   async function getRelayedTools() {
     if (!relayClientTools) {
       return [];
     }
-    const clientId = await resolveTargetId();
-    if (!clientId) {
-      return [];
-    }
+    let clients = [];
     try {
-      const res = await client.sendCommand(clientId, "list-tools", {});
-      if (
-        res &&
-        res.success &&
-        res.data?.tools &&
-        Array.isArray(res.data.tools)
-      ) {
-        return res.data.tools.map((t) => ({
-          name: t.name,
-          description:
-            t.description || `Relayed tool '${t.name}' from connected client.`,
-          inputSchema: t.inputSchema || { type: "object", properties: {} },
-          annotations: t.annotations,
-        }));
-      }
+      clients = await client.listClients();
     } catch (_) {}
-    return [];
+
+    if (!Array.isArray(clients) || clients.length === 0) {
+      toolSupportingClientsMap.clear();
+      toolDefMap.clear();
+      return [];
+    }
+
+    toolSupportingClientsMap.clear();
+    toolDefMap.clear();
+
+    for (const c of clients) {
+      const cid = c.clientId || c.id;
+      if (!cid) continue;
+
+      try {
+        const res = await client.sendCommand(cid, "list-tools", {});
+        if (
+          res &&
+          res.success &&
+          res.data?.tools &&
+          Array.isArray(res.data.tools)
+        ) {
+          for (const t of res.data.tools) {
+            if (!toolDefMap.has(t.name)) {
+              toolDefMap.set(t.name, t);
+              toolSupportingClientsMap.set(t.name, []);
+            }
+            toolSupportingClientsMap.get(t.name).push(c);
+          }
+        }
+      } catch (_) {}
+    }
+
+    const activeTargetId = await resolveTargetId();
+    const relayedTools = [];
+
+    for (const [toolName, t] of toolDefMap.entries()) {
+      const supportingClients = toolSupportingClientsMap.get(toolName) || [];
+      const supportingClientIds = supportingClients
+        .map((cl) => cl.clientId || cl.id)
+        .filter(Boolean);
+
+      const preferredClient =
+        supportingClients.find(
+          (cl) => (cl.clientId || cl.id) === activeTargetId,
+        ) || supportingClients[0];
+      const toolDefaultId =
+        preferredClient?.clientId || preferredClient?.id || "";
+      const toolDefaultLabel = preferredClient?.deviceLabel || "Client";
+
+      const existingSchema =
+        t.inputSchema && typeof t.inputSchema === "object"
+          ? t.inputSchema
+          : { type: "object", properties: {} };
+
+      const properties = {
+        ...(existingSchema.properties || {}),
+        clientId: {
+          type: "string",
+          description: `Target ShadowClaw client ID (optional; defaults to ${toolDefaultId} [${toolDefaultLabel}]). Available on: ${supportingClients.map((cl) => `${cl.clientId || cl.id} (${cl.deviceLabel || "Client"})`).join(", ")}`,
+          enum: supportingClientIds,
+        },
+      };
+
+      const clientNote =
+        clients.length > 1
+          ? supportingClients.length > 1
+            ? ` [Default: ${toolDefaultLabel} (${toolDefaultId.slice(0, 14)}...)]`
+            : ` [Client: ${toolDefaultLabel} (${toolDefaultId.slice(0, 14)}...)]`
+          : "";
+
+      relayedTools.push({
+        name: t.name,
+        description:
+          (t.description || `Relayed tool '${t.name}' from connected client.`) +
+          clientNote,
+        inputSchema: {
+          ...existingSchema,
+          type: "object",
+          properties,
+        },
+        annotations: t.annotations,
+      });
+    }
+
+    return relayedTools;
   }
 
   async function handleMessage(request, headers = {}) {
@@ -260,6 +368,48 @@ export function createCliMcpEngine(options = {}) {
           };
         }
 
+        if (toolName === "shadowclaw_set_active_client") {
+          const targetId = await resolveTargetId(args.clientId);
+          if (!targetId) {
+            return {
+              jsonrpc: "2.0",
+              id: reqId,
+              result: {
+                resultType: "complete",
+                isError: true,
+                content: [
+                  {
+                    type: "text",
+                    text: `Error: Client '${args.clientId}' not found among connected clients.`,
+                  },
+                ],
+                _meta: { "io.modelcontextprotocol/serverInfo": serverInfo },
+              },
+            };
+          }
+          activeClientId = targetId;
+          console.error(
+            `[ShadowClaw MCP] Active default client set to: ${activeClientId}`,
+          );
+          return {
+            jsonrpc: "2.0",
+            id: reqId,
+            result: {
+              resultType: "complete",
+              content: [
+                {
+                  type: "text",
+                  text: `Active default client set to: ${activeClientId}`,
+                },
+              ],
+              _meta: {
+                activeClientId,
+                "io.modelcontextprotocol/serverInfo": serverInfo,
+              },
+            },
+          };
+        }
+
         if (toolName === "shadowclaw_send_message") {
           const targetId = await resolveTargetId(args.clientId);
           if (!targetId) {
@@ -391,26 +541,12 @@ export function createCliMcpEngine(options = {}) {
           };
         }
 
-        // Relayed interactive ask_user tool (MRTR)
-        if (toolName === "ask_user") {
-          if (!inputResponses || !inputResponses["response"]) {
-            return {
-              jsonrpc: "2.0",
-              id: reqId,
-              result: {
-                resultType: "input_required",
-                inputRequests: [
-                  {
-                    id: "response",
-                    type: "prompt",
-                    message:
-                      args.question || args.prompt || "User input requested",
-                  },
-                ],
-                _meta: { "io.modelcontextprotocol/serverInfo": serverInfo },
-              },
-            };
-          }
+        // Relayed interactive ask_user tool with MRTR response fulfillment if provided
+        if (
+          toolName === "ask_user" &&
+          inputResponses &&
+          inputResponses["response"]
+        ) {
           return {
             jsonrpc: "2.0",
             id: reqId,
@@ -425,7 +561,29 @@ export function createCliMcpEngine(options = {}) {
         }
 
         // Relayed client tools (invoke-tool)
-        const targetId = await resolveTargetId(args.clientId);
+        if (toolDefMap.size === 0) {
+          await getRelayedTools();
+        }
+
+        const supportingClients = toolSupportingClientsMap.get(toolName) || [];
+        const supportingClientIds = supportingClients
+          .map((cl) => cl.clientId || cl.id)
+          .filter(Boolean);
+
+        let targetId = "";
+        if (args.clientId) {
+          targetId = await resolveTargetId(args.clientId);
+        } else {
+          const activeSessionId = await resolveTargetId();
+          if (supportingClientIds.includes(activeSessionId)) {
+            targetId = activeSessionId;
+          } else if (supportingClientIds.length > 0) {
+            targetId = supportingClientIds[0];
+          } else {
+            targetId = activeSessionId;
+          }
+        }
+
         if (!targetId) {
           return {
             jsonrpc: "2.0",
@@ -441,11 +599,51 @@ export function createCliMcpEngine(options = {}) {
           };
         }
 
+        if (
+          supportingClientIds.length > 0 &&
+          !supportingClientIds.includes(targetId)
+        ) {
+          return {
+            jsonrpc: "2.0",
+            id: reqId,
+            result: {
+              resultType: "complete",
+              isError: true,
+              content: [
+                {
+                  type: "text",
+                  text: `Error: Tool '${toolName}' is not enabled or available on client '${targetId}'. (Available on: ${supportingClientIds.join(", ")})`,
+                },
+              ],
+              _meta: {
+                clientId: targetId,
+                "io.modelcontextprotocol/serverInfo": serverInfo,
+              },
+            },
+          };
+        }
+
         try {
-          const res = await client.sendCommand(targetId, "invoke-tool", {
-            toolName,
-            input: args,
-          });
+          console.error(
+            `[ShadowClaw MCP] Executing '${toolName}' on client: ${targetId}`,
+          );
+          const toolArgs = { ...args };
+          delete toolArgs.clientId;
+          const isInteractive = toolName === "ask_user";
+          const res = isInteractive
+            ? await client.sendCommand(
+                targetId,
+                "invoke-tool",
+                {
+                  toolName,
+                  input: toolArgs,
+                },
+                300000,
+              )
+            : await client.sendCommand(targetId, "invoke-tool", {
+                toolName,
+                input: toolArgs,
+              });
 
           const rawResult =
             res.data?.result !== undefined ? res.data.result : res.data;
@@ -454,14 +652,31 @@ export function createCliMcpEngine(options = {}) {
               ? rawResult
               : JSON.stringify(rawResult, null, 2);
 
+          const errorMessage =
+            res.error ||
+            (res.data && res.data.error) ||
+            "Unknown tool execution error";
+
           return {
             jsonrpc: "2.0",
             id: reqId,
             result: {
               resultType: "complete",
               isError: !res.success,
-              content: [{ type: "text", text: textOutput || "" }],
-              _meta: { "io.modelcontextprotocol/serverInfo": serverInfo },
+              content: [
+                {
+                  type: "text",
+                  text: res.success
+                    ? textOutput || ""
+                    : textOutput && textOutput !== "null" && textOutput !== "{}"
+                      ? `${textOutput}\n${errorMessage}`
+                      : `Tool execution error: ${errorMessage}`,
+                },
+              ],
+              _meta: {
+                clientId: targetId,
+                "io.modelcontextprotocol/serverInfo": serverInfo,
+              },
             },
           };
         } catch (err) {
@@ -472,7 +687,10 @@ export function createCliMcpEngine(options = {}) {
               resultType: "complete",
               isError: true,
               content: [{ type: "text", text: `Tool error: ${err.message}` }],
-              _meta: { "io.modelcontextprotocol/serverInfo": serverInfo },
+              _meta: {
+                clientId: targetId,
+                "io.modelcontextprotocol/serverInfo": serverInfo,
+              },
             },
           };
         }
@@ -511,6 +729,10 @@ export function createCliMcpEngine(options = {}) {
 
   return {
     handleMessage,
+    getActiveClientId: () => activeClientId,
+    setActiveClientId: (id) => {
+      activeClientId = id;
+    },
   };
 }
 

package/bin/commands/mcp.test.mjs

@@ -1,7 +1,24 @@
-import { describe, it, expect, jest } from "@jest/globals";
+import {
+  describe,
+  it,
+  expect,
+  jest,
+  beforeEach,
+  afterEach,
+} from "@jest/globals";
 import { createCliMcpEngine } from "./mcp.mjs";
 
 describe("CLI MCP Engine (createCliMcpEngine)", () => {
+  let errorSpy;
+
+  beforeEach(() => {
+    errorSpy = jest.spyOn(console, "error").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    errorSpy?.mockRestore();
+  });
+
   it("processes server/discover request", async () => {
     const mockClient = {
       listClients: jest
@@ -97,4 +114,261 @@ describe("CLI MCP Engine (createCliMcpEngine)", () => {
       groupId: undefined,
     });
   });
+
+  it("processes tools/call for relayed client tool (e.g. list_files)", async () => {
+    const mockClient = {
+      listClients: jest
+        .fn()
+        .mockResolvedValue([{ clientId: "c1", deviceLabel: "Browser Test" }]),
+      sendCommand: jest
+        .fn()
+        .mockImplementation(async (clientId, action, payload) => {
+          if (action === "invoke-tool" && payload.toolName === "list_files") {
+            return {
+              success: true,
+              data: {
+                result: ".agents/ MEMORY.md index.html -/",
+              },
+            };
+          }
+          return { success: false, error: "Not handled" };
+        }),
+    };
+
+    const engine = createCliMcpEngine({ client: mockClient });
+    const res = await engine.handleMessage({
+      jsonrpc: "2.0",
+      id: 4,
+      method: "tools/call",
+      params: {
+        name: "list_files",
+        arguments: {},
+      },
+    });
+
+    expect(res).toBeDefined();
+    expect(res.id).toBe(4);
+    expect(res.result.resultType).toBe("complete");
+    expect(res.result.isError).toBe(false);
+    expect(res.result.content[0].text).toBe(".agents/ MEMORY.md index.html -/");
+    expect(mockClient.sendCommand).toHaveBeenCalledWith("c1", "invoke-tool", {
+      toolName: "list_files",
+      input: {},
+    });
+  });
+
+  it("handles tools/call relayed client tool failure with informative error content", async () => {
+    const mockClient = {
+      listClients: jest
+        .fn()
+        .mockResolvedValue([{ clientId: "c1", deviceLabel: "Browser Test" }]),
+      sendCommand: jest.fn().mockImplementation(async () => {
+        return {
+          success: false,
+          error: "Permission denied reading directory",
+        };
+      }),
+    };
+
+    const engine = createCliMcpEngine({ client: mockClient });
+    const res = await engine.handleMessage({
+      jsonrpc: "2.0",
+      id: 5,
+      method: "tools/call",
+      params: {
+        name: "list_files",
+        arguments: { path: "restricted" },
+      },
+    });
+
+    expect(res).toBeDefined();
+    expect(res.id).toBe(5);
+    expect(res.result.resultType).toBe("complete");
+    expect(res.result.isError).toBe(true);
+    expect(res.result.content[0].text).toContain(
+      "Permission denied reading directory",
+    );
+  });
+
+  it("handles multi-client discovery and explicit clientId targeting", async () => {
+    const mockClient = {
+      listClients: jest.fn().mockResolvedValue([
+        { clientId: "client-alpha", deviceLabel: "Linux Desktop" },
+        { clientId: "client-beta", deviceLabel: "Android Phone" },
+      ]),
+      sendCommand: jest
+        .fn()
+        .mockImplementation(async (clientId, action, payload) => {
+          if (action === "list-tools") {
+            const tools = [
+              {
+                name: "list_files",
+                description: "List workspace files.",
+                inputSchema: {
+                  type: "object",
+                  properties: { path: { type: "string" } },
+                },
+              },
+            ];
+            if (clientId === "client-alpha") {
+              tools.push({
+                name: "ask_user",
+                description: "Ask user for confirmation.",
+                inputSchema: {
+                  type: "object",
+                  properties: { question: { type: "string" } },
+                },
+              });
+            }
+            return {
+              success: true,
+              data: { tools },
+            };
+          }
+          if (action === "invoke-tool") {
+            return {
+              success: true,
+              data: {
+                result: `Files from ${clientId}`,
+              },
+            };
+          }
+          return { success: false };
+        }),
+    };
+
+    const engine = createCliMcpEngine({ client: mockClient });
+
+    // 1. tools/list should augment schema with clientId enum and default client info
+    const listRes = await engine.handleMessage({
+      jsonrpc: "2.0",
+      id: 10,
+      method: "tools/list",
+    });
+
+    const listFilesTool = listRes.result.tools.find(
+      (t) => t.name === "list_files",
+    );
+    expect(listFilesTool).toBeDefined();
+    expect(listFilesTool.description).toContain("[Default: Linux Desktop");
+    expect(listFilesTool.inputSchema.properties.clientId).toBeDefined();
+    expect(listFilesTool.inputSchema.properties.clientId.enum).toEqual([
+      "client-alpha",
+      "client-beta",
+    ]);
+
+    // ask_user should ONLY be available on client-alpha
+    const askUserTool = listRes.result.tools.find((t) => t.name === "ask_user");
+    expect(askUserTool).toBeDefined();
+    expect(askUserTool.description).toContain("[Client: Linux Desktop");
+    expect(askUserTool.inputSchema.properties.clientId.enum).toEqual([
+      "client-alpha",
+    ]);
+
+    // 2. tools/call targeting client-beta explicitly
+    const callResBeta = await engine.handleMessage({
+      jsonrpc: "2.0",
+      id: 11,
+      method: "tools/call",
+      params: {
+        name: "list_files",
+        arguments: { clientId: "client-beta" },
+      },
+    });
+
+    expect(mockClient.sendCommand).toHaveBeenCalledWith(
+      "client-beta",
+      "invoke-tool",
+      {
+        toolName: "list_files",
+        input: {},
+      },
+    );
+    expect(callResBeta.result.content[0].text).toBe("Files from client-beta");
+
+    // 3. Switch active default client to client-beta
+    const setActiveRes = await engine.handleMessage({
+      jsonrpc: "2.0",
+      id: 12,
+      method: "tools/call",
+      params: {
+        name: "shadowclaw_set_active_client",
+        arguments: { clientId: "client-beta" },
+      },
+    });
+
+    expect(setActiveRes.result.content[0].text).toContain(
+      "Active default client set to: client-beta",
+    );
+
+    // 4. tools/call without clientId now defaults to client-beta for list_files
+    const callResDefault = await engine.handleMessage({
+      jsonrpc: "2.0",
+      id: 13,
+      method: "tools/call",
+      params: {
+        name: "list_files",
+        arguments: {},
+      },
+    });
+
+    expect(callResDefault.result.content[0].text).toBe(
+      "Files from client-beta",
+    );
+
+    // 5. Attempting to call ask_user on client-beta should be REJECTED because client-beta does not support it
+    const unsupportedRes = await engine.handleMessage({
+      jsonrpc: "2.0",
+      id: 14,
+      method: "tools/call",
+      params: {
+        name: "ask_user",
+        arguments: { clientId: "client-beta", question: "Prompt client beta?" },
+      },
+    });
+
+    expect(unsupportedRes.result.isError).toBe(true);
+    expect(unsupportedRes.result.content[0].text).toContain(
+      "Tool 'ask_user' is not enabled or available on client 'client-beta'",
+    );
+    expect(unsupportedRes.result.content[0].text).toContain(
+      "Available on: client-alpha",
+    );
+
+    // 6. Calling ask_user without clientId should automatically default to client-alpha
+    // (the only supporting client), even though active default is client-beta!
+    const askUserRes = await engine.handleMessage({
+      jsonrpc: "2.0",
+      id: 15,
+      method: "tools/call",
+      params: {
+        name: "ask_user",
+        arguments: { question: "Are you ready?" },
+      },
+    });
+
+    expect(mockClient.sendCommand).toHaveBeenCalledWith(
+      "client-alpha",
+      "invoke-tool",
+      {
+        toolName: "ask_user",
+        input: { question: "Are you ready?" },
+      },
+      300000,
+    );
+    expect(askUserRes.result.content[0].text).toBe("Files from client-alpha");
+
+    // 7. tools/call for ask_user with inputResponses returns fulfilled response
+    const fulfilledRes = await engine.handleMessage({
+      jsonrpc: "2.0",
+      id: 16,
+      method: "tools/call",
+      params: {
+        name: "ask_user",
+        arguments: { question: "Are you ready?" },
+        inputResponses: { response: "Yes, ready to go!" },
+      },
+    });
+    expect(fulfilledRes.result.content[0].text).toBe("Yes, ready to go!");
+  });
 });