shadow-claw 1.26.0 → 1.27.0

package/src/server/mcp/tools/client-tool-relay.ts

@@ -18,6 +18,8 @@ export interface ClientToolRelayOptions {
 export interface ClientToolRelay {
   discoverTools: () => Promise<McpTool[]>;
   attachToServer: (server: McpServer) => void;
+  getActiveClientId?: () => string;
+  setActiveClientId?: (id: string) => void;
 }
 
 export function createClientToolRelay(
@@ -28,7 +30,10 @@ export function createClientToolRelay(
 
   let cachedTools: McpTool[] = [];
   let cacheTime = 0;
+  let activeClientId = targetClientId || "";
   const registeredHandlers = new Set<string>();
+  const toolSupportingClientsMap = new Map<string, any[]>();
+  const toolDefMap = new Map<string, any>();
 
   async function discoverTools(): Promise<McpTool[]> {
     const now = Date.now();
@@ -36,36 +41,110 @@ export function createClientToolRelay(
       return cachedTools;
     }
 
-    const clientId = resolveTargetClientId(controlPlane, targetClientId);
-    if (!clientId) {
+    let clients: any[] = [];
+    try {
+      clients =
+        typeof controlPlane.getConnectedClients === "function"
+          ? controlPlane.getConnectedClients()
+          : typeof controlPlane.listClients === "function"
+            ? await controlPlane.listClients()
+            : [];
+    } catch (_) {}
+
+    if (!Array.isArray(clients) || clients.length === 0) {
+      toolSupportingClientsMap.clear();
+      toolDefMap.clear();
       return [];
     }
 
-    try {
-      const res = await controlPlane.sendCommand(clientId, "list-tools", {});
-      if (
-        res &&
-        res.success &&
-        res.data?.tools &&
-        Array.isArray(res.data.tools)
-      ) {
-        cachedTools = res.data.tools.map((t: any) => ({
-          name: t.name,
-          description:
-            t.description || `Relayed tool '${t.name}' from connected client.`,
-          inputSchema: t.inputSchema || { type: "object", properties: {} },
-          annotations: t.annotations,
-        }));
-        cacheTime = now;
-        return cachedTools;
+    toolSupportingClientsMap.clear();
+    toolDefMap.clear();
+
+    for (const c of clients) {
+      const cid = (c as any).clientId || (c as any).id;
+      if (!cid) continue;
+
+      try {
+        const res = await controlPlane.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 (err) {
+        console.warn(
+          `[ClientToolRelay] Failed to query tools from client ${cid}:`,
+          err,
+        );
       }
-    } catch (err) {
-      console.warn(
-        `[ClientToolRelay] Failed to query tools from client ${clientId}:`,
-        err,
-      );
     }
 
+    const targetId = resolveTargetClientId(
+      controlPlane,
+      activeClientId || targetClientId,
+    );
+    const toolMap = new Map<string, McpTool>();
+
+    for (const [toolName, t] of toolDefMap.entries()) {
+      const supportingClients = toolSupportingClientsMap.get(toolName) || [];
+      const supportingClientIds = supportingClients
+        .map((cl: any) => cl.clientId || cl.id)
+        .filter(Boolean);
+
+      const preferredClient =
+        supportingClients.find(
+          (cl: any) => (cl.clientId || cl.id) === targetId,
+        ) || 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: any) => `${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)}...)]`
+          : "";
+
+      toolMap.set(toolName, {
+        name: t.name,
+        description:
+          (t.description || `Relayed tool '${t.name}' from connected client.`) +
+          clientNote,
+        inputSchema: {
+          ...existingSchema,
+          type: "object",
+          properties,
+        },
+        annotations: t.annotations,
+      });
+    }
+
+    cachedTools = Array.from(toolMap.values());
+    cacheTime = now;
     return cachedTools;
   }
 
@@ -94,7 +173,49 @@ export function createClientToolRelay(
     _meta?: Record<string, unknown>,
     inputResponses?: Record<string, unknown>,
   ): Promise<McpToolCallResult> {
-    const clientId = resolveTargetClientId(controlPlane, targetClientId);
+    const connectedClients =
+      typeof controlPlane.getConnectedClients === "function"
+        ? controlPlane.getConnectedClients()
+        : typeof controlPlane.listClients === "function"
+          ? await controlPlane.listClients()
+          : [];
+    if (!Array.isArray(connectedClients) || connectedClients.length === 0) {
+      return {
+        resultType: "complete",
+        isError: true,
+        content: [
+          {
+            type: "text",
+            text: "Error: No connected ShadowClaw client available to execute tool.",
+          },
+        ],
+      };
+    }
+
+    if (toolDefMap.size === 0) {
+      await discoverTools();
+    }
+
+    const supportingClients = toolSupportingClientsMap.get(toolName) || [];
+    const supportingClientIds = supportingClients
+      .map((cl: any) => cl.clientId || cl.id)
+      .filter(Boolean);
+
+    let resolvedClientCandidate = args.clientId as string | undefined;
+    if (!resolvedClientCandidate) {
+      const activeCandidate = activeClientId || targetClientId;
+      const activeId = resolveTargetClientId(controlPlane, activeCandidate);
+      if (supportingClientIds.includes(activeId)) {
+        resolvedClientCandidate = activeId;
+      } else if (supportingClientIds.length > 0) {
+        resolvedClientCandidate = supportingClientIds[0];
+      }
+    }
+
+    const clientId = resolveTargetClientId(
+      controlPlane,
+      resolvedClientCandidate,
+    );
     if (!clientId) {
       return {
         resultType: "complete",
@@ -108,6 +229,23 @@ export function createClientToolRelay(
       };
     }
 
+    if (
+      supportingClientIds.length > 0 &&
+      !supportingClientIds.includes(clientId)
+    ) {
+      return {
+        resultType: "complete",
+        isError: true,
+        content: [
+          {
+            type: "text",
+            text: `Error: Tool '${toolName}' is not enabled or available on client '${clientId}'. (Available on: ${supportingClientIds.join(", ")})`,
+          },
+        ],
+        _meta: { clientId },
+      };
+    }
+
     // Interactive tool handling: ask_user via MRTR
     if (toolName === "ask_user") {
       if (!inputResponses || !inputResponses["response"]) {
@@ -147,14 +285,19 @@ export function createClientToolRelay(
                 : JSON.stringify(userResponse),
           },
         ],
+        _meta: {
+          clientId,
+        },
       };
     }
 
     // Standard tool execution via Control Plane invoke-tool command
     try {
+      const toolArgs = { ...args };
+      delete toolArgs.clientId;
       const res = await controlPlane.sendCommand(clientId, "invoke-tool", {
         toolName,
-        input: args,
+        input: toolArgs,
       });
 
       if (!res.success) {
@@ -167,6 +310,9 @@ export function createClientToolRelay(
               text: `Tool execution error: ${res.error || "Unknown client execution error"}`,
             },
           ],
+          _meta: {
+            clientId,
+          },
         };
       }
 
@@ -185,6 +331,9 @@ export function createClientToolRelay(
             text: textOutput,
           },
         ],
+        _meta: {
+          clientId,
+        },
       };
     } catch (err: any) {
       return {
@@ -196,6 +345,9 @@ export function createClientToolRelay(
             text: `Failed to dispatch tool '${toolName}' to client: ${err.message || String(err)}`,
           },
         ],
+        _meta: {
+          clientId,
+        },
       };
     }
   }
@@ -203,5 +355,10 @@ export function createClientToolRelay(
   return {
     discoverTools,
     attachToServer,
+    getActiveClientId: () =>
+      activeClientId || resolveTargetClientId(controlPlane, targetClientId),
+    setActiveClientId: (id: string) => {
+      activeClientId = id;
+    },
   };
 }

package/src/server/mcp/tools/mcp-tools.test.ts

@@ -2,6 +2,7 @@ import { describe, it, expect, jest } from "@jest/globals";
 import {
   registerBuiltInTools,
   SHADOWCLAW_BUILTIN_TOOLS,
+  resolveTargetClientId,
 } from "./built-in-tools.js";
 import { createClientToolRelay } from "./client-tool-relay.js";
 import { McpServer } from "../mcp-server.js";
@@ -585,4 +586,143 @@ describe("Client Tool Relay", () => {
       expect(resNoClient.result.content[0].text).toContain("No connected");
     }
   });
+
+  describe("resolveTargetClientId and multi-client routing", () => {
+    it("resolves target client by exact ID, index, prefix, and label", () => {
+      const mockControlPlane: any = {
+        getConnectedClients: jest.fn().mockReturnValue([
+          {
+            clientId: "client-01m1kxw07jtfvh0c4gmbfty2wz",
+            deviceLabel: "Linux Desktop",
+          },
+          {
+            clientId: "client-01m1n03c284hrtybdvx33zv7r4",
+            deviceLabel: "Pixel Phone",
+          },
+        ]),
+      };
+
+      // Default (no requestedId) -> first client
+      expect(resolveTargetClientId(mockControlPlane)).toBe(
+        "client-01m1kxw07jtfvh0c4gmbfty2wz",
+      );
+
+      // Exact ID
+      expect(
+        resolveTargetClientId(
+          mockControlPlane,
+          "client-01m1n03c284hrtybdvx33zv7r4",
+        ),
+      ).toBe("client-01m1n03c284hrtybdvx33zv7r4");
+
+      // Index "1"
+      expect(resolveTargetClientId(mockControlPlane, "1")).toBe(
+        "client-01m1n03c284hrtybdvx33zv7r4",
+      );
+
+      // Prefix match
+      expect(resolveTargetClientId(mockControlPlane, "01m1n03")).toBe(
+        "client-01m1n03c284hrtybdvx33zv7r4",
+      );
+
+      // Device label match
+      expect(resolveTargetClientId(mockControlPlane, "Pixel")).toBe(
+        "client-01m1n03c284hrtybdvx33zv7r4",
+      );
+    });
+
+    it("executes shadowclaw_set_active_client and routes multi-client tools", async () => {
+      const server = new McpServer();
+      let activeId = "";
+      const mockControlPlane: any = {
+        getConnectedClients: jest.fn().mockReturnValue([
+          { clientId: "c1", deviceLabel: "Client 1" },
+          { clientId: "c2", deviceLabel: "Client 2" },
+        ]),
+        setActiveClientId: jest.fn((id: string) => {
+          activeId = id;
+        }),
+        getActiveClientId: jest.fn(() => activeId),
+        sendCommand: jest.fn().mockImplementation(async (cid, action) => {
+          if (action === "list-tools") {
+            return {
+              success: true,
+              data: {
+                tools: [
+                  {
+                    name: "list_files",
+                    description: "List files",
+                    inputSchema: { type: "object", properties: {} },
+                  },
+                ],
+              },
+            };
+          }
+          if (action === "invoke-tool") {
+            return {
+              success: true,
+              data: { result: `Output from ${cid}` },
+            };
+          }
+          return { success: true };
+        }),
+      };
+
+      registerBuiltInTools(server, mockControlPlane);
+      const relay = createClientToolRelay(mockControlPlane);
+      relay.attachToServer(server);
+
+      // 1. Discover tools across multi-client: schema should have clientId enum
+      const tools = await server.getTools();
+      const listFilesTool = tools.find((t) => t.name === "list_files");
+      expect(listFilesTool).toBeDefined();
+      const props = listFilesTool?.inputSchema.properties as any;
+      expect(props?.clientId).toBeDefined();
+      expect(props?.clientId.enum).toEqual(["c1", "c2"]);
+
+      // 2. Run shadowclaw_set_active_client
+      const setRes = await server.handleRequest({
+        jsonrpc: "2.0",
+        id: 20,
+        method: "tools/call",
+        params: {
+          name: "shadowclaw_set_active_client",
+          arguments: { clientId: "c2" },
+        },
+      });
+
+      expect(mockControlPlane.setActiveClientId).toHaveBeenCalledWith("c2");
+      expect(setRes).not.toBeNull();
+
+      // 3. Invoking tool with explicit clientId c1 routes to c1
+      const callRes1 = await server.handleRequest({
+        jsonrpc: "2.0",
+        id: 21,
+        method: "tools/call",
+        params: {
+          name: "list_files",
+          arguments: { clientId: "c1" },
+        },
+      });
+
+      if (callRes1 && "result" in callRes1) {
+        expect(callRes1.result.content[0].text).toBe("Output from c1");
+      }
+
+      // 4. Invoking tool without clientId routes to active client c2
+      const callRes2 = await server.handleRequest({
+        jsonrpc: "2.0",
+        id: 22,
+        method: "tools/call",
+        params: {
+          name: "list_files",
+          arguments: {},
+        },
+      });
+
+      if (callRes2 && "result" in callRes2) {
+        expect(callRes2.result.content[0].text).toBe("Output from c2");
+      }
+    });
+  });
 });

package/src/server/middleware/static-files.test.ts

@@ -16,6 +16,11 @@ describe("static-files-middleware", () => {
     fsMock = {
       stat: jest.fn(),
       access: jest.fn(),
+      existsSync: jest.fn(() => false),
+      statSync: jest.fn(() => ({
+        isFile: () => false,
+        isDirectory: () => false,
+      })),
       constants: { F_OK: 0 },
     };
     rewriteMock = jest.fn(() => (_req: any, _res: any, next: any) => next());
@@ -361,4 +366,141 @@ describe("static-files-middleware", () => {
     );
     expect(next).not.toHaveBeenCalled();
   });
+
+  it("serves .well-known files with dotfiles allow option", async () => {
+    await register();
+    const middleware = app.use.mock.calls[1][0];
+
+    const req = {
+      originalUrl: "/.well-known/agent-skills/index.json",
+      url: "/.well-known/agent-skills/index.json",
+    };
+    const res = { setHeader: jest.fn(), sendFile: jest.fn() };
+    const next = jest.fn();
+
+    fsMock.stat.mockImplementation((_path: string, cb: any) =>
+      cb(null, { isDirectory: () => false }),
+    );
+
+    middleware(req, res, next);
+
+    expect(res.sendFile).toHaveBeenCalledWith(
+      expect.stringContaining("/root/.well-known/agent-skills/index.json"),
+      { dotfiles: "allow" },
+    );
+    expect(next).not.toHaveBeenCalled();
+  });
+
+  it("serves .agents files with dotfiles allow option", async () => {
+    await register();
+    const middleware = app.use.mock.calls[1][0];
+
+    const req = {
+      originalUrl: "/.agents/skills/main/toast/SKILL.md",
+      url: "/.agents/skills/main/toast/SKILL.md",
+    };
+    const res = { setHeader: jest.fn(), sendFile: jest.fn() };
+    const next = jest.fn();
+
+    fsMock.stat.mockImplementation((_path: string, cb: any) =>
+      cb(null, { isDirectory: () => false }),
+    );
+
+    middleware(req, res, next);
+
+    expect(res.sendFile).toHaveBeenCalledWith(
+      expect.stringContaining("/root/.agents/skills/main/toast/SKILL.md"),
+      { dotfiles: "allow" },
+    );
+    expect(next).not.toHaveBeenCalled();
+  });
+
+  it("serves index.html in allowed dot directories with dotfiles allow option", async () => {
+    await register();
+    const middleware = app.use.mock.calls[1][0];
+
+    const req = {
+      originalUrl: "/.well-known/agent-skills/",
+      url: "/.well-known/agent-skills/",
+    };
+    const res = { setHeader: jest.fn(), sendFile: jest.fn() };
+    const next = jest.fn();
+
+    fsMock.stat.mockImplementation((_path: string, cb: any) =>
+      cb(null, { isDirectory: () => true }),
+    );
+    fsMock.access.mockImplementation((_path: string, _mode: any, cb: any) =>
+      cb(null),
+    );
+
+    middleware(req, res, next);
+
+    expect(res.sendFile).toHaveBeenCalledWith(
+      expect.stringContaining("/root/.well-known/agent-skills/index.html"),
+      { dotfiles: "allow" },
+    );
+    expect(next).not.toHaveBeenCalled();
+  });
+
+  it("serves allowed dotfiles with subpath prefix and dotfiles allow option", async () => {
+    await register();
+    const middleware = app.use.mock.calls[1][0];
+
+    const req = {
+      originalUrl: "/shadow-claw/.well-known/agent-skills/index.json",
+      url: "/shadow-claw/.well-known/agent-skills/index.json",
+    };
+    const res = { setHeader: jest.fn(), sendFile: jest.fn() };
+    const next = jest.fn();
+
+    // The direct stat under /root/shadow-claw/... will fail (ENOENT), but stripped subpath stat succeeds
+    fsMock.stat.mockImplementation((targetPath: string, cb: any) => {
+      if (targetPath.includes("/root/shadow-claw/")) {
+        cb(new Error("ENOENT"));
+      } else {
+        cb(null, { isFile: () => true, isDirectory: () => false });
+      }
+    });
+
+    fsMock.existsSync.mockImplementation((p: string) =>
+      p.includes(".well-known"),
+    );
+    fsMock.statSync.mockImplementation(() => ({ isFile: () => true }));
+
+    middleware(req, res, next);
+
+    expect(res.sendFile).toHaveBeenCalledWith(
+      expect.stringContaining("/root/.well-known/agent-skills/index.json"),
+      { dotfiles: "allow" },
+    );
+    expect(next).not.toHaveBeenCalled();
+  });
+
+  it("blocks disallowed dotfiles from being served", async () => {
+    await register();
+    const middleware = app.use.mock.calls[1][0];
+
+    const disallowedPaths = [
+      "/.git/config",
+      "/.env",
+      "/.cache/db.sqlite",
+      "/.well-known/.env",
+      "/.agents/.git",
+      "/pages/.secret.txt",
+    ];
+
+    for (const disallowedPath of disallowedPaths) {
+      const req = {
+        originalUrl: disallowedPath,
+        url: disallowedPath,
+      };
+      const res = { setHeader: jest.fn(), sendFile: jest.fn() };
+      const next = jest.fn();
+
+      middleware(req, res, next);
+
+      expect(res.sendFile).not.toHaveBeenCalled();
+      expect(next).toHaveBeenCalled();
+    }
+  });
 });