unraidclaw 0.1.5 → 0.1.6

package/dist/index.d.ts

@@ -1,3 +1,21 @@
+interface ClientConfig {
+    serverUrl: string;
+    apiKey: string;
+    tlsSkipVerify?: boolean;
+}
+declare class UnraidClient {
+    private configResolver;
+    private insecureAgent;
+    constructor(configResolver: () => ClientConfig);
+    private getConfig;
+    get<T>(path: string, query?: Record<string, string>): Promise<T>;
+    post<T>(path: string, body?: unknown): Promise<T>;
+    patch<T>(path: string, body?: unknown): Promise<T>;
+    delete<T>(path: string): Promise<T>;
+    private doRequest;
+}
+
+type ClientResolver = (serverName?: string) => UnraidClient;
 declare function register(api: any): void;
 
-export { register as default };
+export { type ClientResolver, register as default };

package/dist/index.js

@@ -115,14 +115,19 @@ function errorResult(err) {
 }
 
 // src/tools/health.ts
-function registerHealthTools(api, client) {
+function registerHealthTools(api, getClient) {
   api.registerTool({
     name: "unraid_health_check",
     description: "Check the health status of the Unraid server connection, including API and GraphQL reachability.",
-    parameters: { type: "object", properties: {} },
-    execute: async () => {
+    parameters: {
+      type: "object",
+      properties: {
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
+      }
+    },
+    execute: async (_id, params) => {
       try {
-        return textResult(await client.get("/api/health"));
+        return textResult(await getClient(params.server).get("/api/health"));
       } catch (err) {
         return errorResult(err);
       }
@@ -131,14 +136,19 @@ function registerHealthTools(api, client) {
 }
 
 // src/tools/docker.ts
-function registerDockerTools(api, client) {
+function registerDockerTools(api, getClient) {
   api.registerTool({
     name: "unraid_docker_list",
     description: "List all Docker containers on the Unraid server with their current state, image, and status.",
-    parameters: { type: "object", properties: {} },
-    execute: async () => {
+    parameters: {
+      type: "object",
+      properties: {
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
+      }
+    },
+    execute: async (_id, params) => {
       try {
-        return textResult(await client.get("/api/docker/containers"));
+        return textResult(await getClient(params.server).get("/api/docker/containers"));
       } catch (err) {
         return errorResult(err);
       }
@@ -150,13 +160,14 @@ function registerDockerTools(api, client) {
     parameters: {
       type: "object",
       properties: {
-        id: { type: "string", description: "Container ID or name" }
+        id: { type: "string", description: "Container ID or name" },
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
       },
       required: ["id"]
     },
     execute: async (_id, params) => {
       try {
-        return textResult(await client.get(`/api/docker/containers/${params.id}`));
+        return textResult(await getClient(params.server).get(`/api/docker/containers/${params.id}`));
       } catch (err) {
         return errorResult(err);
       }
@@ -170,7 +181,8 @@ function registerDockerTools(api, client) {
       properties: {
         id: { type: "string", description: "Container ID or name" },
         tail: { type: "number", description: "Number of lines from the end (default: 100)" },
-        since: { type: "string", description: "Show logs since timestamp (e.g., 2024-01-01T00:00:00Z)" }
+        since: { type: "string", description: "Show logs since timestamp (e.g., 2024-01-01T00:00:00Z)" },
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
       },
       required: ["id"]
     },
@@ -179,102 +191,39 @@ function registerDockerTools(api, client) {
         const query = {};
         if (params.tail) query.tail = String(params.tail);
         if (params.since) query.since = String(params.since);
-        return textResult(await client.get(`/api/docker/containers/${params.id}/logs`, query));
-      } catch (err) {
-        return errorResult(err);
-      }
-    }
-  });
-  api.registerTool({
-    name: "unraid_docker_start",
-    description: "Start a stopped Docker container.",
-    parameters: {
-      type: "object",
-      properties: {
-        id: { type: "string", description: "Container ID or name" }
-      },
-      required: ["id"]
-    },
-    execute: async (_id, params) => {
-      try {
-        return textResult(await client.post(`/api/docker/containers/${params.id}/start`));
-      } catch (err) {
-        return errorResult(err);
-      }
-    }
-  });
-  api.registerTool({
-    name: "unraid_docker_stop",
-    description: "Stop a running Docker container.",
-    parameters: {
-      type: "object",
-      properties: {
-        id: { type: "string", description: "Container ID or name" }
-      },
-      required: ["id"]
-    },
-    execute: async (_id, params) => {
-      try {
-        return textResult(await client.post(`/api/docker/containers/${params.id}/stop`));
+        return textResult(await getClient(params.server).get(`/api/docker/containers/${params.id}/logs`, query));
       } catch (err) {
         return errorResult(err);
       }
     }
   });
-  api.registerTool({
-    name: "unraid_docker_restart",
-    description: "Restart a Docker container.",
-    parameters: {
-      type: "object",
-      properties: {
-        id: { type: "string", description: "Container ID or name" }
-      },
-      required: ["id"]
-    },
-    execute: async (_id, params) => {
-      try {
-        return textResult(await client.post(`/api/docker/containers/${params.id}/restart`));
-      } catch (err) {
-        return errorResult(err);
-      }
-    }
-  });
-  api.registerTool({
-    name: "unraid_docker_pause",
-    description: "Pause a running Docker container (freeze all processes).",
-    parameters: {
-      type: "object",
-      properties: {
-        id: { type: "string", description: "Container ID or name" }
-      },
-      required: ["id"]
-    },
-    execute: async (_id, params) => {
-      try {
-        return textResult(await client.post(`/api/docker/containers/${params.id}/pause`));
-      } catch (err) {
-        return errorResult(err);
-      }
-    }
-  });
-  api.registerTool({
-    name: "unraid_docker_unpause",
-    description: "Unpause a paused Docker container.",
-    parameters: {
-      type: "object",
-      properties: {
-        id: { type: "string", description: "Container ID or name" }
+  for (const [toolName, desc, action] of [
+    ["unraid_docker_start", "Start a stopped Docker container.", "start"],
+    ["unraid_docker_stop", "Stop a running Docker container.", "stop"],
+    ["unraid_docker_restart", "Restart a Docker container.", "restart"],
+    ["unraid_docker_pause", "Pause a running Docker container (freeze all processes).", "pause"],
+    ["unraid_docker_unpause", "Unpause a paused Docker container.", "unpause"]
+  ]) {
+    api.registerTool({
+      name: toolName,
+      description: desc,
+      parameters: {
+        type: "object",
+        properties: {
+          id: { type: "string", description: "Container ID or name" },
+          server: { type: "string", description: "Target server name (optional, uses default server)" }
+        },
+        required: ["id"]
       },
-      required: ["id"]
-    },
-    execute: async (_id, params) => {
-      try {
-        return textResult(await client.post(`/api/docker/containers/${params.id}/unpause`));
-      } catch (err) {
-        return errorResult(err);
+      execute: async (_id, params) => {
+        try {
+          return textResult(await getClient(params.server).post(`/api/docker/containers/${params.id}/${action}`));
+        } catch (err) {
+          return errorResult(err);
+        }
       }
-    }
-  });
+    });
+  }
   api.registerTool({
     name: "unraid_docker_remove",
     description: "Remove a Docker container. Pass force=true to stop and remove in one step. This is a destructive operation that cannot be undone.",
@@ -282,14 +231,15 @@ function registerDockerTools(api, client) {
       type: "object",
       properties: {
         id: { type: "string", description: "Container ID or name" },
-        force: { type: "boolean", description: "Stop the container before removing (default: false)" }
+        force: { type: "boolean", description: "Stop the container before removing (default: false)" },
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
       },
       required: ["id"]
     },
     execute: async (_id, params) => {
       try {
         const query = params.force ? "?force=true" : "";
-        return textResult(await client.delete(`/api/docker/containers/${params.id}${query}`));
+        return textResult(await getClient(params.server).delete(`/api/docker/containers/${params.id}${query}`));
       } catch (err) {
         return errorResult(err);
       }
@@ -323,13 +273,15 @@ function registerDockerTools(api, client) {
           enum: ["no", "always", "unless-stopped", "on-failure"],
           description: "Restart policy (default: unless-stopped)"
         },
-        network: { type: "string", description: "Network to attach the container to" }
+        network: { type: "string", description: "Network to attach the container to" },
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
       },
       required: ["image"]
     },
     execute: async (_id, params) => {
       try {
-        return textResult(await client.post("/api/docker/containers", params));
+        const { server, ...body } = params;
+        return textResult(await getClient(server).post("/api/docker/containers", body));
       } catch (err) {
         return errorResult(err);
       }
@@ -338,194 +290,127 @@ function registerDockerTools(api, client) {
 }
 
 // src/tools/vms.ts
-function registerVMTools(api, client) {
+function registerVMTools(api, getClient) {
   api.registerTool({
     name: "unraid_vm_list",
     description: "List all virtual machines on the Unraid server with their current state.",
-    parameters: { type: "object", properties: {} },
-    execute: async () => {
-      try {
-        return textResult(await client.get("/api/vms"));
-      } catch (err) {
-        return errorResult(err);
-      }
-    }
-  });
-  api.registerTool({
-    name: "unraid_vm_inspect",
-    description: "Get detailed information about a specific virtual machine.",
     parameters: {
       type: "object",
       properties: {
-        id: { type: "string", description: "VM ID or name" }
-      },
-      required: ["id"]
-    },
-    execute: async (_id, params) => {
-      try {
-        return textResult(await client.get(`/api/vms/${params.id}`));
-      } catch (err) {
-        return errorResult(err);
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
       }
-    }
-  });
-  api.registerTool({
-    name: "unraid_vm_start",
-    description: "Start a stopped virtual machine.",
-    parameters: {
-      type: "object",
-      properties: {
-        id: { type: "string", description: "VM ID or name" }
-      },
-      required: ["id"]
     },
     execute: async (_id, params) => {
       try {
-        return textResult(await client.post(`/api/vms/${params.id}/start`));
+        return textResult(await getClient(params.server).get("/api/vms"));
       } catch (err) {
         return errorResult(err);
       }
     }
   });
+  for (const [name, desc, action] of [
+    ["unraid_vm_inspect", "Get detailed information about a specific virtual machine.", null],
+    ["unraid_vm_start", "Start a stopped virtual machine.", "start"],
+    ["unraid_vm_stop", "Gracefully stop a running virtual machine (ACPI shutdown).", "stop"],
+    ["unraid_vm_pause", "Pause a running virtual machine (suspend to RAM).", "pause"],
+    ["unraid_vm_resume", "Resume a paused virtual machine.", "resume"],
+    ["unraid_vm_force_stop", "Force stop a virtual machine (equivalent to pulling the power plug). This is destructive and may cause data loss.", "force-stop"],
+    ["unraid_vm_reboot", "Reboot a running virtual machine (ACPI reboot).", "reboot"]
+  ]) {
+    api.registerTool(
+      {
+        name,
+        description: desc,
+        parameters: {
+          type: "object",
+          properties: {
+            id: { type: "string", description: "VM ID or name" },
+            server: { type: "string", description: "Target server name (optional, uses default server)" }
+          },
+          required: ["id"]
+        },
+        execute: async (_id, params) => {
+          try {
+            const client = getClient(params.server);
+            if (action) {
+              return textResult(await client.post(`/api/vms/${params.id}/${action}`));
+            }
+            return textResult(await client.get(`/api/vms/${params.id}`));
+          } catch (err) {
+            return errorResult(err);
+          }
+        }
+      },
+      ...name === "unraid_vm_force_stop" ? [{ optional: true }] : []
+    );
+  }
+}
+
+// src/tools/array.ts
+function registerArrayTools(api, getClient) {
   api.registerTool({
-    name: "unraid_vm_stop",
-    description: "Gracefully stop a running virtual machine (ACPI shutdown).",
+    name: "unraid_array_status",
+    description: "Get the current status of the Unraid array including state, capacity, disks, and parities. Capacity is in kilobytes (KiB). Disk 'size' fields are in kilobytes (KiB).",
     parameters: {
       type: "object",
       properties: {
-        id: { type: "string", description: "VM ID or name" }
-      },
-      required: ["id"]
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
+      }
     },
     execute: async (_id, params) => {
       try {
-        return textResult(await client.post(`/api/vms/${params.id}/stop`));
+        return textResult(await getClient(params.server).get("/api/array/status"));
       } catch (err) {
         return errorResult(err);
       }
     }
   });
   api.registerTool({
-    name: "unraid_vm_pause",
-    description: "Pause a running virtual machine (suspend to RAM).",
+    name: "unraid_array_start",
+    description: "Start the Unraid array. This will mount all disks and start Docker/VMs if configured.",
     parameters: {
       type: "object",
       properties: {
-        id: { type: "string", description: "VM ID or name" }
-      },
-      required: ["id"]
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
+      }
     },
     execute: async (_id, params) => {
       try {
-        return textResult(await client.post(`/api/vms/${params.id}/pause`));
+        return textResult(await getClient(params.server).post("/api/array/start"));
       } catch (err) {
         return errorResult(err);
       }
     }
   });
   api.registerTool({
-    name: "unraid_vm_resume",
-    description: "Resume a paused virtual machine.",
+    name: "unraid_array_stop",
+    description: "Stop the Unraid array. This will stop all Docker containers and VMs, then unmount all disks.",
     parameters: {
       type: "object",
       properties: {
-        id: { type: "string", description: "VM ID or name" }
-      },
-      required: ["id"]
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
+      }
     },
     execute: async (_id, params) => {
       try {
-        return textResult(await client.post(`/api/vms/${params.id}/resume`));
+        return textResult(await getClient(params.server).post("/api/array/stop"));
       } catch (err) {
         return errorResult(err);
       }
     }
   });
-  api.registerTool(
-    {
-      name: "unraid_vm_force_stop",
-      description: "Force stop a virtual machine (equivalent to pulling the power plug). This is destructive and may cause data loss.",
-      parameters: {
-        type: "object",
-        properties: {
-          id: { type: "string", description: "VM ID or name" }
-        },
-        required: ["id"]
-      },
-      execute: async (_id, params) => {
-        try {
-          return textResult(await client.post(`/api/vms/${params.id}/force-stop`));
-        } catch (err) {
-          return errorResult(err);
-        }
-      }
-    }
-  );
   api.registerTool({
-    name: "unraid_vm_reboot",
-    description: "Reboot a running virtual machine (ACPI reboot).",
+    name: "unraid_parity_status",
+    description: "Get the current parity check status (running, progress, speed, errors).",
     parameters: {
       type: "object",
       properties: {
-        id: { type: "string", description: "VM ID or name" }
-      },
-      required: ["id"]
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
+      }
     },
     execute: async (_id, params) => {
       try {
-        return textResult(await client.post(`/api/vms/${params.id}/reboot`));
-      } catch (err) {
-        return errorResult(err);
-      }
-    }
-  });
-}
-
-// src/tools/array.ts
-function registerArrayTools(api, client) {
-  api.registerTool({
-    name: "unraid_array_status",
-    description: "Get the current status of the Unraid array including state, capacity, disks, and parities. Capacity is in kilobytes (KiB). Disk 'size' fields are in kilobytes (KiB).",
-    parameters: { type: "object", properties: {} },
-    execute: async () => {
-      try {
-        return textResult(await client.get("/api/array/status"));
-      } catch (err) {
-        return errorResult(err);
-      }
-    }
-  });
-  api.registerTool({
-    name: "unraid_array_start",
-    description: "Start the Unraid array. This will mount all disks and start Docker/VMs if configured.",
-    parameters: { type: "object", properties: {} },
-    execute: async () => {
-      try {
-        return textResult(await client.post("/api/array/start"));
-      } catch (err) {
-        return errorResult(err);
-      }
-    }
-  });
-  api.registerTool({
-    name: "unraid_array_stop",
-    description: "Stop the Unraid array. This will stop all Docker containers and VMs, then unmount all disks.",
-    parameters: { type: "object", properties: {} },
-    execute: async () => {
-      try {
-        return textResult(await client.post("/api/array/stop"));
-      } catch (err) {
-        return errorResult(err);
-      }
-    }
-  });
-  api.registerTool({
-    name: "unraid_parity_status",
-    description: "Get the current parity check status (running, progress, speed, errors).",
-    parameters: { type: "object", properties: {} },
-    execute: async () => {
-      try {
-        return textResult(await client.get("/api/array/parity/status"));
+        return textResult(await getClient(params.server).get("/api/array/parity/status"));
       } catch (err) {
         return errorResult(err);
       }
@@ -540,12 +425,13 @@ function registerArrayTools(api, client) {
         correct: {
           type: "boolean",
           description: "If true, run a correcting parity check. Defaults to false (non-correcting)."
-        }
+        },
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
       }
     },
     execute: async (_id, params) => {
       try {
-        return textResult(await client.post("/api/array/parity/start", { correct: params.correct ?? false }));
+        return textResult(await getClient(params.server).post("/api/array/parity/start", { correct: params.correct ?? false }));
       } catch (err) {
         return errorResult(err);
       }
@@ -554,10 +440,15 @@ function registerArrayTools(api, client) {
   api.registerTool({
     name: "unraid_parity_pause",
     description: "Pause a running parity check.",
-    parameters: { type: "object", properties: {} },
-    execute: async () => {
+    parameters: {
+      type: "object",
+      properties: {
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
+      }
+    },
+    execute: async (_id, params) => {
       try {
-        return textResult(await client.post("/api/array/parity/pause"));
+        return textResult(await getClient(params.server).post("/api/array/parity/pause"));
       } catch (err) {
         return errorResult(err);
       }
@@ -566,10 +457,15 @@ function registerArrayTools(api, client) {
   api.registerTool({
     name: "unraid_parity_resume",
     description: "Resume a paused parity check.",
-    parameters: { type: "object", properties: {} },
-    execute: async () => {
+    parameters: {
+      type: "object",
+      properties: {
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
+      }
+    },
+    execute: async (_id, params) => {
       try {
-        return textResult(await client.post("/api/array/parity/resume"));
+        return textResult(await getClient(params.server).post("/api/array/parity/resume"));
       } catch (err) {
         return errorResult(err);
       }
@@ -578,10 +474,15 @@ function registerArrayTools(api, client) {
   api.registerTool({
     name: "unraid_parity_cancel",
     description: "Cancel a running or paused parity check.",
-    parameters: { type: "object", properties: {} },
-    execute: async () => {
+    parameters: {
+      type: "object",
+      properties: {
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
+      }
+    },
+    execute: async (_id, params) => {
       try {
-        return textResult(await client.post("/api/array/parity/cancel"));
+        return textResult(await getClient(params.server).post("/api/array/parity/cancel"));
       } catch (err) {
         return errorResult(err);
       }
@@ -590,14 +491,19 @@ function registerArrayTools(api, client) {
 }
 
 // src/tools/disks.ts
-function registerDiskTools(api, client) {
+function registerDiskTools(api, getClient) {
   api.registerTool({
     name: "unraid_disk_list",
     description: "List all disks (data + parity) with name, size, used, free, usedPercent, temp, status, and fsType.",
-    parameters: { type: "object", properties: {} },
-    execute: async () => {
+    parameters: {
+      type: "object",
+      properties: {
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
+      }
+    },
+    execute: async (_id, params) => {
       try {
-        return textResult(await client.get("/api/disks"));
+        return textResult(await getClient(params.server).get("/api/disks"));
       } catch (err) {
         return errorResult(err);
       }
@@ -609,13 +515,14 @@ function registerDiskTools(api, client) {
     parameters: {
       type: "object",
       properties: {
-        id: { type: "string", description: "Disk ID (e.g., 'disk1', 'parity')" }
+        id: { type: "string", description: "Disk ID (e.g., 'disk1', 'parity')" },
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
       },
       required: ["id"]
     },
     execute: async (_id, params) => {
       try {
-        return textResult(await client.get(`/api/disks/${params.id}`));
+        return textResult(await getClient(params.server).get(`/api/disks/${params.id}`));
       } catch (err) {
         return errorResult(err);
       }
@@ -624,14 +531,19 @@ function registerDiskTools(api, client) {
 }
 
 // src/tools/shares.ts
-function registerShareTools(api, client) {
+function registerShareTools(api, getClient) {
   api.registerTool({
     name: "unraid_share_list",
     description: "List all user shares on the Unraid server with their settings and usage. The 'free' and 'size' fields are in kilobytes (KiB).",
-    parameters: { type: "object", properties: {} },
-    execute: async () => {
+    parameters: {
+      type: "object",
+      properties: {
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
+      }
+    },
+    execute: async (_id, params) => {
       try {
-        return textResult(await client.get("/api/shares"));
+        return textResult(await getClient(params.server).get("/api/shares"));
       } catch (err) {
         return errorResult(err);
       }
@@ -643,13 +555,14 @@ function registerShareTools(api, client) {
     parameters: {
       type: "object",
       properties: {
-        name: { type: "string", description: "Share name" }
+        name: { type: "string", description: "Share name" },
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
       },
       required: ["name"]
     },
     execute: async (_id, params) => {
       try {
-        return textResult(await client.get(`/api/shares/${params.name}`));
+        return textResult(await getClient(params.server).get(`/api/shares/${params.name}`));
       } catch (err) {
         return errorResult(err);
       }
@@ -657,7 +570,7 @@ function registerShareTools(api, client) {
   });
   api.registerTool({
     name: "unraid_share_update",
-    description: "Update safe settings for a user share. Only affects metadata and future write behavior \u2014 does not move existing data.",
+    description: "Update safe settings for a user share. Only affects metadata and future write behavior -- does not move existing data.",
     parameters: {
       type: "object",
       properties: {
@@ -665,14 +578,15 @@ function registerShareTools(api, client) {
         comment: { type: "string", description: "Share description/comment" },
         allocator: { type: "string", description: "Disk allocation method: highwater, fill, or most-free" },
         floor: { type: "string", description: "Minimum free space per disk (e.g. '0' or '50000')" },
-        splitLevel: { type: "string", description: "Split level for distributing files across disks" }
+        splitLevel: { type: "string", description: "Split level for distributing files across disks" },
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
       },
       required: ["name"]
     },
     execute: async (_id, params) => {
       try {
-        const { name, ...updates } = params;
-        return textResult(await client.patch(`/api/shares/${name}`, updates));
+        const { name, server, ...updates } = params;
+        return textResult(await getClient(server).patch(`/api/shares/${name}`, updates));
       } catch (err) {
         return errorResult(err);
       }
@@ -681,14 +595,19 @@ function registerShareTools(api, client) {
 }
 
 // src/tools/system.ts
-function registerSystemTools(api, client) {
+function registerSystemTools(api, getClient) {
   api.registerTool({
     name: "unraid_system_info",
     description: "Get system information: OS (platform, hostname, uptime), CPU (model, cores, threads), memory (total, used, free, percent), and CPU load averages (1m, 5m, 15m).",
-    parameters: { type: "object", properties: {} },
-    execute: async () => {
+    parameters: {
+      type: "object",
+      properties: {
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
+      }
+    },
+    execute: async (_id, params) => {
       try {
-        return textResult(await client.get("/api/system/info"));
+        return textResult(await getClient(params.server).get("/api/system/info"));
       } catch (err) {
         return errorResult(err);
       }
@@ -697,10 +616,15 @@ function registerSystemTools(api, client) {
   api.registerTool({
     name: "unraid_system_metrics",
     description: "Get live system metrics: memory (total, used, free bytes, percent) and CPU load averages (1m, 5m, 15m). Lightweight endpoint for polling.",
-    parameters: { type: "object", properties: {} },
-    execute: async () => {
+    parameters: {
+      type: "object",
+      properties: {
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
+      }
+    },
+    execute: async (_id, params) => {
       try {
-        return textResult(await client.get("/api/system/metrics"));
+        return textResult(await getClient(params.server).get("/api/system/metrics"));
       } catch (err) {
         return errorResult(err);
       }
@@ -709,10 +633,15 @@ function registerSystemTools(api, client) {
   api.registerTool({
     name: "unraid_service_list",
     description: "List system services and their current state.",
-    parameters: { type: "object", properties: {} },
-    execute: async () => {
+    parameters: {
+      type: "object",
+      properties: {
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
+      }
+    },
+    execute: async (_id, params) => {
       try {
-        return textResult(await client.get("/api/system/services"));
+        return textResult(await getClient(params.server).get("/api/system/services"));
       } catch (err) {
         return errorResult(err);
       }
@@ -721,10 +650,15 @@ function registerSystemTools(api, client) {
   api.registerTool({
     name: "unraid_system_reboot",
     description: "Reboot the Unraid server. This is a destructive operation that will interrupt all running services, VMs, and containers.",
-    parameters: { type: "object", properties: {} },
-    execute: async () => {
+    parameters: {
+      type: "object",
+      properties: {
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
+      }
+    },
+    execute: async (_id, params) => {
       try {
-        return textResult(await client.post("/api/system/reboot"));
+        return textResult(await getClient(params.server).post("/api/system/reboot"));
       } catch (err) {
         return errorResult(err);
       }
@@ -733,10 +667,15 @@ function registerSystemTools(api, client) {
   api.registerTool({
     name: "unraid_system_shutdown",
     description: "Shut down the Unraid server. This is a destructive operation that will power off the server.",
-    parameters: { type: "object", properties: {} },
-    execute: async () => {
+    parameters: {
+      type: "object",
+      properties: {
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
+      }
+    },
+    execute: async (_id, params) => {
       try {
-        return textResult(await client.post("/api/system/shutdown"));
+        return textResult(await getClient(params.server).post("/api/system/shutdown"));
       } catch (err) {
         return errorResult(err);
       }
@@ -745,14 +684,19 @@ function registerSystemTools(api, client) {
 }
 
 // src/tools/notifications.ts
-function registerNotificationTools(api, client) {
+function registerNotificationTools(api, getClient) {
   api.registerTool({
     name: "unraid_notification_list",
     description: "List all system notifications with their importance level and archive status.",
-    parameters: { type: "object", properties: {} },
-    execute: async () => {
+    parameters: {
+      type: "object",
+      properties: {
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
+      }
+    },
+    execute: async (_id, params) => {
       try {
-        return textResult(await client.get("/api/notifications"));
+        return textResult(await getClient(params.server).get("/api/notifications"));
       } catch (err) {
         return errorResult(err);
       }
@@ -767,7 +711,8 @@ function registerNotificationTools(api, client) {
         title: { type: "string", description: "Notification title" },
         subject: { type: "string", description: "Notification subject" },
         description: { type: "string", description: "Notification body text" },
-        importance: { type: "string", description: "Importance level: alert, warning, or normal" }
+        importance: { type: "string", description: "Importance level: alert, warning, or normal" },
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
       },
       required: ["title", "subject", "description"]
     },
@@ -779,7 +724,7 @@ function registerNotificationTools(api, client) {
           description: params.description
         };
         if (params.importance) body.importance = params.importance;
-        return textResult(await client.post("/api/notifications", body));
+        return textResult(await getClient(params.server).post("/api/notifications", body));
       } catch (err) {
         return errorResult(err);
       }
@@ -791,13 +736,14 @@ function registerNotificationTools(api, client) {
     parameters: {
       type: "object",
       properties: {
-        id: { type: "string", description: "Notification ID" }
+        id: { type: "string", description: "Notification ID" },
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
       },
       required: ["id"]
     },
     execute: async (_id, params) => {
       try {
-        return textResult(await client.post(`/api/notifications/${params.id}/archive`));
+        return textResult(await getClient(params.server).post(`/api/notifications/${params.id}/archive`));
       } catch (err) {
         return errorResult(err);
       }
@@ -809,13 +755,14 @@ function registerNotificationTools(api, client) {
     parameters: {
       type: "object",
       properties: {
-        id: { type: "string", description: "Notification ID" }
+        id: { type: "string", description: "Notification ID" },
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
       },
       required: ["id"]
     },
     execute: async (_id, params) => {
       try {
-        return textResult(await client.delete(`/api/notifications/${params.id}`));
+        return textResult(await getClient(params.server).delete(`/api/notifications/${params.id}`));
       } catch (err) {
         return errorResult(err);
       }
@@ -824,14 +771,19 @@ function registerNotificationTools(api, client) {
 }
 
 // src/tools/network.ts
-function registerNetworkTools(api, client) {
+function registerNetworkTools(api, getClient) {
   api.registerTool({
     name: "unraid_network_info",
     description: "Get network information including hostname, gateway, DNS servers, and all network interfaces.",
-    parameters: { type: "object", properties: {} },
-    execute: async () => {
+    parameters: {
+      type: "object",
+      properties: {
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
+      }
+    },
+    execute: async (_id, params) => {
       try {
-        return textResult(await client.get("/api/network"));
+        return textResult(await getClient(params.server).get("/api/network"));
       } catch (err) {
         return errorResult(err);
       }
@@ -840,14 +792,19 @@ function registerNetworkTools(api, client) {
 }
 
 // src/tools/users.ts
-function registerUserTools(api, client) {
+function registerUserTools(api, getClient) {
   api.registerTool({
     name: "unraid_user_me",
     description: "Get information about the current authenticated user.",
-    parameters: { type: "object", properties: {} },
-    execute: async () => {
+    parameters: {
+      type: "object",
+      properties: {
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
+      }
+    },
+    execute: async (_id, params) => {
       try {
-        return textResult(await client.get("/api/users/me"));
+        return textResult(await getClient(params.server).get("/api/users/me"));
       } catch (err) {
         return errorResult(err);
       }
@@ -856,7 +813,7 @@ function registerUserTools(api, client) {
 }
 
 // src/tools/logs.ts
-function registerLogTools(api, client) {
+function registerLogTools(api, getClient) {
   api.registerTool({
     name: "unraid_syslog",
     description: "Get recent syslog entries from the Unraid server. Returns the most recent log lines.",
@@ -866,14 +823,15 @@ function registerLogTools(api, client) {
         lines: {
           type: "number",
           description: "Number of log lines to retrieve (1-1000, default 50)."
-        }
+        },
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
       }
     },
     execute: async (_id, params) => {
       try {
         const query = {};
         if (params.lines) query.lines = String(params.lines);
-        return textResult(await client.get("/api/logs/syslog", query));
+        return textResult(await getClient(params.server).get("/api/logs/syslog", query));
       } catch (err) {
         return errorResult(err);
       }
@@ -882,29 +840,53 @@ function registerLogTools(api, client) {
 }
 
 // src/index.ts
-function resolveConfig(api) {
-  if (api.config?.serverUrl) return api.config;
-  if (api.pluginConfig?.serverUrl) return api.pluginConfig;
-  const nested = api.config?.plugins?.entries?.unraidclaw?.config;
-  if (nested?.serverUrl) return nested;
-  return { serverUrl: "", apiKey: "" };
+function resolveServers(api) {
+  const raw = api.config?.servers ?? api.pluginConfig?.servers ?? api.config?.plugins?.entries?.unraidclaw?.config?.servers;
+  if (Array.isArray(raw) && raw.length > 0) return raw;
+  const single = api.config?.serverUrl ? api.config : api.pluginConfig?.serverUrl ? api.pluginConfig : api.config?.plugins?.entries?.unraidclaw?.config;
+  if (single?.serverUrl) {
+    return [{ name: "default", serverUrl: single.serverUrl, apiKey: single.apiKey, tlsSkipVerify: single.tlsSkipVerify, default: true }];
+  }
+  return [];
 }
 function register(api) {
   const log = api.logger || console;
-  const client = new UnraidClient(() => resolveConfig(api));
-  registerHealthTools(api, client);
-  registerDockerTools(api, client);
-  registerVMTools(api, client);
-  registerArrayTools(api, client);
-  registerDiskTools(api, client);
-  registerShareTools(api, client);
-  registerSystemTools(api, client);
-  registerNotificationTools(api, client);
-  registerNetworkTools(api, client);
-  registerUserTools(api, client);
-  registerLogTools(api, client);
-  const cfg = resolveConfig(api);
-  log.info(`UnraidClaw: registered 40 tools${cfg.serverUrl ? ", server: " + cfg.serverUrl : " (config will resolve at runtime)"}`);
+  const clients = /* @__PURE__ */ new Map();
+  function getClient(serverName) {
+    const servers2 = resolveServers(api);
+    if (servers2.length === 0) {
+      return new UnraidClient(() => ({ serverUrl: "", apiKey: "" }));
+    }
+    const target = serverName ? servers2.find((s) => s.name === serverName) : servers2.find((s) => s.default) ?? servers2[0];
+    if (!target) {
+      throw new Error(`Server "${serverName}" not found. Available: ${servers2.map((s) => s.name).join(", ")}`);
+    }
+    let client = clients.get(target.name);
+    if (!client) {
+      client = new UnraidClient(() => ({ serverUrl: target.serverUrl, apiKey: target.apiKey, tlsSkipVerify: target.tlsSkipVerify }));
+      clients.set(target.name, client);
+    }
+    return client;
+  }
+  registerHealthTools(api, getClient);
+  registerDockerTools(api, getClient);
+  registerVMTools(api, getClient);
+  registerArrayTools(api, getClient);
+  registerDiskTools(api, getClient);
+  registerShareTools(api, getClient);
+  registerSystemTools(api, getClient);
+  registerNotificationTools(api, getClient);
+  registerNetworkTools(api, getClient);
+  registerUserTools(api, getClient);
+  registerLogTools(api, getClient);
+  const servers = resolveServers(api);
+  if (servers.length > 1) {
+    log.info(`UnraidClaw: registered tools for ${servers.length} servers: ${servers.map((s) => s.name).join(", ")}`);
+  } else if (servers.length === 1) {
+    log.info(`UnraidClaw: registered tools, server: ${servers[0].serverUrl}`);
+  } else {
+    log.info(`UnraidClaw: registered tools (config will resolve at runtime)`);
+  }
 }
 export {
   register as default

package/openclaw.plugin.json

@@ -6,19 +6,49 @@
     "properties": {
       "serverUrl": {
         "type": "string",
-        "description": "URL of the UnraidClaw server (e.g., http://192.168.1.100:9876)"
+        "description": "URL of the UnraidClaw server (single-server mode)"
       },
       "apiKey": {
         "type": "string",
-        "description": "API key for authenticating with UnraidClaw"
+        "description": "API key for authenticating with UnraidClaw (single-server mode)"
       },
       "tlsSkipVerify": {
         "type": "boolean",
         "description": "Skip TLS certificate verification (for self-signed certs)",
         "default": false
+      },
+      "servers": {
+        "type": "array",
+        "description": "Multiple UnraidClaw servers (multi-server mode)",
+        "items": {
+          "type": "object",
+          "properties": {
+            "name": {
+              "type": "string",
+              "description": "Server name used to target this server in tool calls"
+            },
+            "serverUrl": {
+              "type": "string",
+              "description": "URL of the UnraidClaw server"
+            },
+            "apiKey": {
+              "type": "string",
+              "description": "API key for authenticating with this server"
+            },
+            "tlsSkipVerify": {
+              "type": "boolean",
+              "description": "Skip TLS certificate verification",
+              "default": false
+            },
+            "default": {
+              "type": "boolean",
+              "description": "Use this server when no server name is specified"
+            }
+          },
+          "required": ["name", "serverUrl", "apiKey"]
+        }
       }
-    },
-    "required": ["serverUrl", "apiKey"]
+    }
   },
   "uiHints": {
     "serverUrl": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unraidclaw",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "OpenClaw plugin to manage your Unraid server — Docker, VMs, array, shares, system, and more.",
   "type": "module",
   "main": "dist/index.js",