unraidclaw 0.1.14 → 0.1.16

package/dist/registry.js

@@ -0,0 +1,1172 @@
+// src/tools/util.ts
+function textResult(data) {
+  return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+}
+var failures = /* @__PURE__ */ new WeakSet();
+function isErrorResult(result) {
+  return failures.has(result);
+}
+function errorResult(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  const result = { content: [{ type: "text", text: `Error: ${message}` }] };
+  failures.add(result);
+  return result;
+}
+function checkParams(params, allowed) {
+  for (const key of Object.keys(params)) {
+    if (allowed.includes(key)) continue;
+    const near = allowed.find((a) => a.toLowerCase() === key.toLowerCase());
+    throw new Error(
+      near ? `Unknown parameter "${key}". Did you mean "${near}"? Nothing was sent to the server.` : `Unknown parameter "${key}". Allowed parameters are: ${allowed.join(", ")}. Nothing was sent to the server.`
+    );
+  }
+  if (params.dryRun !== void 0 && typeof params.dryRun !== "boolean") {
+    throw new Error(
+      `"dryRun" must be true or false, not ${JSON.stringify(params.dryRun)}. Nothing was sent to the server.`
+    );
+  }
+}
+
+// src/tools/health.ts
+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: {
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
+      }
+    },
+    execute: async (_id, params) => {
+      try {
+        return textResult(await getClient(params.server).get("/api/health"));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  });
+}
+
+// src/tools/docker.ts
+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: {
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
+      }
+    },
+    execute: async (_id, params) => {
+      try {
+        return textResult(await getClient(params.server).get("/api/docker/containers"));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  });
+  api.registerTool({
+    name: "unraid_docker_inspect",
+    description: "Get detailed information about a specific Docker container including ports, mounts, and network mode.",
+    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"]
+    },
+    execute: async (_id, params) => {
+      try {
+        return textResult(await getClient(params.server).get(`/api/docker/containers/${params.id}`));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  });
+  api.registerTool({
+    name: "unraid_docker_logs",
+    description: "Get logs from a specific Docker container.",
+    parameters: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: "Container ID or name" },
+        tail: { type: "integer", minimum: 1, maximum: 1e4, description: "Number of lines from the end (default: 100)" },
+        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"]
+    },
+    execute: async (_id, params) => {
+      try {
+        const query = {};
+        if (params.tail) query.tail = String(params.tail);
+        if (params.since) query.since = String(params.since);
+        return textResult(await getClient(params.server).get(`/api/docker/containers/${params.id}/logs`, query));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  });
+  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"]
+      },
+      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.",
+    parameters: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: "Container ID or name" },
+        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 getClient(params.server).delete(`/api/docker/containers/${params.id}${query}`));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  });
+  api.registerTool({
+    name: "unraid_docker_create",
+    description: "Create and start a new Docker container on the Unraid server. Specify image, optional name, port mappings, volume mounts, environment variables, restart policy, network, and Unraid's advanced settings: extra docker run options, post arguments, a fixed IP on a custom network, privileged mode, CPU pinning and host devices.",
+    parameters: {
+      type: "object",
+      properties: {
+        image: { type: "string", description: "Docker image to use (e.g. vikunja/vikunja:latest)" },
+        name: { type: "string", description: "Optional container name" },
+        ports: {
+          type: "array",
+          items: { type: "string" },
+          description: "Port mappings in host:container format (e.g. ['3456:3456'])"
+        },
+        volumes: {
+          type: "array",
+          items: { type: "string" },
+          description: "Volume mounts in host:container format (e.g. ['/mnt/cache/appdata/vikunja:/app/vikunja'])"
+        },
+        env: {
+          type: "array",
+          items: { type: "string" },
+          description: "Environment variables in KEY=VALUE format"
+        },
+        restart: {
+          type: "string",
+          enum: ["no", "always", "unless-stopped", "on-failure"],
+          description: "Restart policy (default: unless-stopped)"
+        },
+        network: { type: "string", description: "Network to attach the container to" },
+        extraArgs: {
+          type: "string",
+          description: "Extra docker run options, space separated, as Unraid's Extra Parameters field (e.g. '--gpus all', '--cap-add=SYS_ADMIN --memory=8g', '--hostname=media'). Must start with an option. Only letters, digits, : . , / + = _ - and single spaces; no quotes or shell characters."
+        },
+        postArgs: {
+          type: "string",
+          description: "Arguments appended after the image as the container command, space separated, as Unraid's Post Arguments field (e.g. '--config /config/app.yml'). Same character rules as extraArgs."
+        },
+        staticIp: {
+          type: "string",
+          description: "Fixed IPv4 or IPv6 address for the container (Unraid's Fixed IP field). Needs a user-defined network such as a macvlan, ipvlan or custom bridge; docker refuses it on bridge, host and none."
+        },
+        privileged: { type: "boolean", description: "Run the container privileged, with full host access (default: false)" },
+        cpuset: { type: "string", description: "CPUs the container may run on, as docker --cpuset-cpus reads it (e.g. '0-3,8')" },
+        devices: {
+          type: "array",
+          items: { type: "string" },
+          description: "Host devices to pass through, as docker --device reads them (e.g. ['/dev/dri', '/dev/ttyUSB0:/dev/ttyUSB0:rwm'])"
+        },
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
+      },
+      required: ["image"]
+    },
+    execute: async (_id, params) => {
+      try {
+        const { server, ...body } = params;
+        return textResult(await getClient(server).post("/api/docker/containers", body));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  });
+}
+
+// src/tools/ca.ts
+function registerCaTools(api, getClient) {
+  api.registerTool({
+    name: "unraid_ca_search",
+    description: "Search the Unraid Community Applications catalog by name, description, Docker image or maintainer. Returns matching apps with their icon, categories and whether UnraidClaw can install them. Use this to find an app before calling unraid_ca_app or unraid_ca_install.",
+    parameters: {
+      type: "object",
+      properties: {
+        q: { type: "string", description: "Search text, e.g. 'plex' or 'backup tool'. All words must match." },
+        limit: { type: "number", description: "Maximum results to return (1-100, default: 25)" },
+        includeDeprecated: { type: "boolean", description: "Include templates the maintainer deprecated (default: false)" },
+        includePlugins: { type: "boolean", description: "Include Unraid plugin (.plg) entries, which are not containers (default: false)" },
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
+      },
+      required: ["q"]
+    },
+    execute: async (_id, params) => {
+      try {
+        const query = { q: String(params.q ?? "") };
+        if (params.limit) query.limit = String(params.limit);
+        if (params.includeDeprecated) query.includeDeprecated = "true";
+        if (params.includePlugins) query.includePlugins = "true";
+        return textResult(await getClient(params.server).get("/api/ca/search", query));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  });
+  api.registerTool({
+    name: "unraid_ca_app",
+    description: "Get the full Community Applications template for one app: its Docker image, icon, WebUI, network mode, and every configurable port, volume and environment variable with its default. Also reports which required fields have no default and any reason the app cannot be installed. Several apps share a name; pass repo to disambiguate when the call reports an ambiguity.",
+    parameters: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "App name exactly as it appears in the catalog, e.g. 'Jellyfin'" },
+        repo: { type: "string", description: `Owning repository, e.g. "linuxserver's Repository". Required when several templates share the name.` },
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
+      },
+      required: ["name"]
+    },
+    execute: async (_id, params) => {
+      try {
+        const query = {};
+        if (params.repo) query.repo = String(params.repo);
+        return textResult(
+          await getClient(params.server).get(
+            `/api/ca/app/${encodeURIComponent(String(params.name))}`,
+            query
+          )
+        );
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  });
+  api.registerTool({
+    name: "unraid_ca_install",
+    description: "Install a Community Applications app on the Unraid server using its template defaults. Writes an Unraid docker-manager template and has Unraid create and start the container, so it appears on the Docker tab like any other app. Required fields with no default must be supplied in overrides; call unraid_ca_app first to see them. Pass dryRun=true to get the resolved template and a preview of the docker command without changing anything. Refuses apps whose templates need unsupported or unsafe options rather than installing something different from the template.",
+    parameters: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "App name exactly as it appears in the catalog, e.g. 'Jellyfin'" },
+        repo: { type: "string", description: "Owning repository. Required when several templates share the name." },
+        containerName: {
+          type: "string",
+          description: "Name for the new container. Defaults to the app name. Letters, digits, dot, dash and underscore only."
+        },
+        overrides: {
+          type: "object",
+          additionalProperties: { type: "string" },
+          description: "Values for template fields, keyed by the field's name or its container-side target, e.g. {'/data/tvshows': '/mnt/user/media/tv', 'PUID': '99'}. An unknown key is an error."
+        },
+        dryRun: {
+          type: "boolean",
+          description: "Resolve and validate everything and return the plan without installing (default: false)"
+        },
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
+      },
+      required: ["name"],
+      additionalProperties: false
+    },
+    execute: async (_id, params) => {
+      try {
+        checkParams(params, ["name", "repo", "containerName", "overrides", "dryRun", "server"]);
+        const body = {};
+        if (params.repo) body.repo = params.repo;
+        if (params.containerName) body.name = params.containerName;
+        if (params.overrides) body.overrides = params.overrides;
+        if (params.dryRun !== void 0) body.dryRun = params.dryRun;
+        return textResult(
+          await getClient(params.server).post(
+            `/api/ca/app/${encodeURIComponent(String(params.name))}/install`,
+            body
+          )
+        );
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  }, { optional: true });
+  api.registerTool({
+    name: "unraid_ca_update",
+    description: "Update an app that is already installed on the Unraid server: pulls the newest image for the tag it runs and recreates the container from the template saved on the server, keeping its ports, paths, variables and its running or stopped state. The name is the INSTALLED CONTAINER NAME as shown on the Docker tab, not the app's name in the Community Applications catalog; call unraid_docker_list to find it and never guess it from a catalog name. Nothing is refreshed from the catalog, so values the user changed are kept. A failed pull leaves the running app untouched, the previous image is never deleted, and no appdata is removed. Pass dryRun=true to see the resolved configuration and the exact docker command without changing anything.",
+    parameters: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "Installed container name, e.g. 'jellyfin'. Not the catalog app name." },
+        dryRun: {
+          type: "boolean",
+          description: "Check everything and report what would happen without pulling or recreating anything (default: false)"
+        },
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
+      },
+      required: ["name"],
+      additionalProperties: false
+    },
+    execute: async (_id, params) => {
+      try {
+        checkParams(params, ["name", "dryRun", "server"]);
+        const body = {};
+        if (params.dryRun !== void 0) body.dryRun = params.dryRun;
+        return textResult(
+          await getClient(params.server).post(
+            `/api/ca/app/${encodeURIComponent(String(params.name))}/update`,
+            body
+          )
+        );
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  }, { optional: true });
+  api.registerTool({
+    name: "unraid_ca_remove",
+    description: "Remove an installed app's Docker container from the Unraid server. The name is the INSTALLED CONTAINER NAME as shown on the Docker tab, not the app's name in the Community Applications catalog; call unraid_docker_list to find it and never guess it from a catalog name. Only the container is removed: its appdata, its Docker volumes, its image and the saved template all stay, so the app can be recreated with the same configuration. Pass dryRun=true to see exactly what would be removed and what would be kept.",
+    parameters: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "Installed container name, e.g. 'jellyfin'. Not the catalog app name." },
+        dryRun: {
+          type: "boolean",
+          description: "Report what would be removed and what would be kept, without removing anything (default: false)"
+        },
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
+      },
+      required: ["name"],
+      additionalProperties: false
+    },
+    execute: async (_id, params) => {
+      try {
+        checkParams(params, ["name", "dryRun", "server"]);
+        const body = {};
+        if (params.dryRun !== void 0) body.dryRun = params.dryRun;
+        return textResult(
+          await getClient(params.server).post(
+            `/api/ca/app/${encodeURIComponent(String(params.name))}/remove`,
+            body
+          )
+        );
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  }, { optional: true });
+}
+
+// src/tools/plugins.ts
+function registerPluginTools(api, getClient) {
+  api.registerTool({
+    name: "unraid_plugins_list",
+    description: "List the Unraid plugins (.plg) installed on the server, with author, version, update URL and whether an update is already staged. Unraid plugins are not Docker containers and not Community Applications: they install files and run scripts on the server itself. Plugins marked builtin belong to Unraid OS and cannot be changed through UnraidClaw.",
+    parameters: {
+      type: "object",
+      properties: {
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
+      }
+    },
+    execute: async (_id, params) => {
+      try {
+        return textResult(await getClient(params.server).get("/api/plugins"));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  });
+  api.registerTool({
+    name: "unraid_plugin_info",
+    description: "Show one installed Unraid plugin in full: its metadata, support link, Unraid version requirements, changelog text and the structure of the files it installs. Inline scripts inside the plugin are described but never returned or executed.",
+    parameters: {
+      type: "object",
+      properties: {
+        plugin: {
+          type: "string",
+          description: "Plugin file name, e.g. 'unassigned.devices.plg'. The .plg suffix is optional."
+        },
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
+      },
+      required: ["plugin"]
+    },
+    execute: async (_id, params) => {
+      try {
+        return textResult(
+          await getClient(params.server).get(
+            `/api/plugins/${encodeURIComponent(String(params.plugin))}`
+          )
+        );
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  });
+  api.registerTool(
+    {
+      name: "unraid_plugin_install",
+      description: "Install an Unraid plugin from an explicit https URL to a .plg file. The plugin file is an installer that Unraid runs as root, so this executes code from whoever controls that URL: only use a URL the user gave you or one from a source they trust. The URL must be https, public, credential-free and end in .plg. Use dryRun first to see exactly what would happen. This is not the way to install Community Applications apps; those are Docker containers (unraid_ca_install).",
+      parameters: {
+        type: "object",
+        properties: {
+          url: {
+            type: "string",
+            description: "Direct https URL of the .plg file, e.g. 'https://example.com/myplugin.plg'"
+          },
+          dryRun: {
+            type: "boolean",
+            description: "Validate the URL and return the plan without downloading, writing or installing anything (default: false)"
+          },
+          server: { type: "string", description: "Target server name (optional, uses default server)" }
+        },
+        required: ["url"],
+        additionalProperties: false
+      },
+      execute: async (_id, params) => {
+        try {
+          checkParams(params, ["url", "dryRun", "server"]);
+          const body = { url: String(params.url ?? "") };
+          if (params.dryRun !== void 0) body.dryRun = params.dryRun;
+          return textResult(
+            await getClient(params.server).post("/api/plugins/install", body)
+          );
+        } catch (err) {
+          return errorResult(err);
+        }
+      }
+    },
+    { optional: true }
+  );
+  api.registerTool(
+    {
+      name: "unraid_plugin_check_updates",
+      description: "Check whether a newer version of an installed Unraid plugin has been published, and stage it for installation. This is not a read-only lookup: it downloads the plugin file from the plugin's own update URL and writes it to the plugin manager's staging directory, where this tool's update call and the Unraid web UI will then offer to install it. Nothing is installed or executed by the check. Run this before unraid_plugin_update.",
+      parameters: {
+        type: "object",
+        properties: {
+          plugin: { type: "string", description: "Plugin file name, e.g. 'unassigned.devices.plg'" },
+          dryRun: {
+            type: "boolean",
+            description: "Return the plan without downloading or staging anything (default: false)"
+          },
+          server: { type: "string", description: "Target server name (optional, uses default server)" }
+        },
+        required: ["plugin"],
+        additionalProperties: false
+      },
+      execute: async (_id, params) => {
+        try {
+          checkParams(params, ["plugin", "dryRun", "server"]);
+          const body = {};
+          if (params.dryRun !== void 0) body.dryRun = params.dryRun;
+          return textResult(
+            await getClient(params.server).post(
+              `/api/plugins/${encodeURIComponent(String(params.plugin))}/check`,
+              body
+            )
+          );
+        } catch (err) {
+          return errorResult(err);
+        }
+      }
+    },
+    { optional: true }
+  );
+  api.registerTool(
+    {
+      name: "unraid_plugin_update",
+      description: "Install the plugin version staged by unraid_plugin_check_updates. Unraid's plugin manager runs the new plugin's install scripts as root and there is no rollback. The result says whether the installed version actually changed; a plugin manager exit code alone is not treated as success.",
+      parameters: {
+        type: "object",
+        properties: {
+          plugin: { type: "string", description: "Plugin file name, e.g. 'unassigned.devices.plg'" },
+          dryRun: {
+            type: "boolean",
+            description: "Return the plan, including which version would replace which, without installing (default: false)"
+          },
+          server: { type: "string", description: "Target server name (optional, uses default server)" }
+        },
+        required: ["plugin"],
+        additionalProperties: false
+      },
+      execute: async (_id, params) => {
+        try {
+          checkParams(params, ["plugin", "dryRun", "server"]);
+          const body = {};
+          if (params.dryRun !== void 0) body.dryRun = params.dryRun;
+          return textResult(
+            await getClient(params.server).post(
+              `/api/plugins/${encodeURIComponent(String(params.plugin))}/update`,
+              body
+            )
+          );
+        } catch (err) {
+          return errorResult(err);
+        }
+      }
+    },
+    { optional: true }
+  );
+  api.registerTool(
+    {
+      name: "unraid_plugin_remove",
+      description: "Remove an installed Unraid plugin through the plugin manager. The plugin's own removal scripts run as root and decide what they delete: some keep their configuration and data, others delete it, so removal cannot be promised to be data-preserving. Anything depending on the plugin stops working. Use dryRun first and confirm with the user before removing.",
+      parameters: {
+        type: "object",
+        properties: {
+          plugin: { type: "string", description: "Plugin file name, e.g. 'unassigned.devices.plg'" },
+          dryRun: {
+            type: "boolean",
+            description: "Return the plan and its warnings without removing anything (default: false)"
+          },
+          server: { type: "string", description: "Target server name (optional, uses default server)" }
+        },
+        required: ["plugin"],
+        additionalProperties: false
+      },
+      execute: async (_id, params) => {
+        try {
+          checkParams(params, ["plugin", "dryRun", "server"]);
+          const body = {};
+          if (params.dryRun !== void 0) body.dryRun = params.dryRun;
+          return textResult(
+            await getClient(params.server).post(
+              `/api/plugins/${encodeURIComponent(String(params.plugin))}/remove`,
+              body
+            )
+          );
+        } catch (err) {
+          return errorResult(err);
+        }
+      }
+    },
+    { optional: true }
+  );
+}
+
+// src/tools/vms.ts
+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: {
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
+      }
+    },
+    execute: async (_id, params) => {
+      try {
+        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_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: {
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
+      }
+    },
+    execute: async (_id, params) => {
+      try {
+        return textResult(await getClient(params.server).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: {
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
+      }
+    },
+    execute: async (_id, params) => {
+      try {
+        return textResult(await getClient(params.server).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: {
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
+      }
+    },
+    execute: async (_id, params) => {
+      try {
+        return textResult(await getClient(params.server).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: {
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
+      }
+    },
+    execute: async (_id, params) => {
+      try {
+        return textResult(await getClient(params.server).get("/api/array/parity/status"));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  });
+  api.registerTool({
+    name: "unraid_parity_start",
+    description: "Start a parity check. Defaults to non-correcting (read-only) for safety. Set correct=true for a correcting check.",
+    parameters: {
+      type: "object",
+      properties: {
+        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 getClient(params.server).post("/api/array/parity/start", { correct: params.correct ?? false }));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  });
+  api.registerTool({
+    name: "unraid_parity_pause",
+    description: "Pause a running parity check.",
+    parameters: {
+      type: "object",
+      properties: {
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
+      }
+    },
+    execute: async (_id, params) => {
+      try {
+        return textResult(await getClient(params.server).post("/api/array/parity/pause"));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  });
+  api.registerTool({
+    name: "unraid_parity_resume",
+    description: "Resume a paused parity check.",
+    parameters: {
+      type: "object",
+      properties: {
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
+      }
+    },
+    execute: async (_id, params) => {
+      try {
+        return textResult(await getClient(params.server).post("/api/array/parity/resume"));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  });
+  api.registerTool({
+    name: "unraid_parity_cancel",
+    description: "Cancel a running or paused parity check.",
+    parameters: {
+      type: "object",
+      properties: {
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
+      }
+    },
+    execute: async (_id, params) => {
+      try {
+        return textResult(await getClient(params.server).post("/api/array/parity/cancel"));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  });
+}
+
+// src/tools/disks.ts
+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: {
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
+      }
+    },
+    execute: async (_id, params) => {
+      try {
+        return textResult(await getClient(params.server).get("/api/disks"));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  });
+  api.registerTool({
+    name: "unraid_disk_details",
+    description: "Get details for a specific disk: size, used, free, usedPercent, temp, status, and fsType.",
+    parameters: {
+      type: "object",
+      properties: {
+        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 getClient(params.server).get(`/api/disks/${params.id}`));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  });
+}
+
+// src/tools/shares.ts
+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: {
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
+      }
+    },
+    execute: async (_id, params) => {
+      try {
+        return textResult(await getClient(params.server).get("/api/shares"));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  });
+  api.registerTool({
+    name: "unraid_share_details",
+    description: "Get details for a specific user share by name. The 'free' and 'size' fields are in kilobytes (KiB).",
+    parameters: {
+      type: "object",
+      properties: {
+        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 getClient(params.server).get(`/api/shares/${params.name}`));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  });
+  api.registerTool({
+    name: "unraid_share_update",
+    description: "Update safe settings for a user share. Only affects metadata and future write behavior -- does not move existing data.",
+    parameters: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "Share name to update" },
+        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" },
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
+      },
+      required: ["name"]
+    },
+    execute: async (_id, params) => {
+      try {
+        const { name, server, ...updates } = params;
+        return textResult(await getClient(server).patch(`/api/shares/${name}`, updates));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  });
+}
+
+// src/tools/system.ts
+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: {
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
+      }
+    },
+    execute: async (_id, params) => {
+      try {
+        return textResult(await getClient(params.server).get("/api/system/info"));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  });
+  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: {
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
+      }
+    },
+    execute: async (_id, params) => {
+      try {
+        return textResult(await getClient(params.server).get("/api/system/metrics"));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  });
+  api.registerTool({
+    name: "unraid_service_list",
+    description: "List system services and their current state.",
+    parameters: {
+      type: "object",
+      properties: {
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
+      }
+    },
+    execute: async (_id, params) => {
+      try {
+        return textResult(await getClient(params.server).get("/api/system/services"));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  });
+  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: {
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
+      }
+    },
+    execute: async (_id, params) => {
+      try {
+        return textResult(await getClient(params.server).post("/api/system/reboot"));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  });
+  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: {
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
+      }
+    },
+    execute: async (_id, params) => {
+      try {
+        return textResult(await getClient(params.server).post("/api/system/shutdown"));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  });
+}
+
+// src/tools/notifications.ts
+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: {
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
+      }
+    },
+    execute: async (_id, params) => {
+      try {
+        return textResult(await getClient(params.server).get("/api/notifications"));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  });
+  api.registerTool({
+    name: "unraid_notification_create",
+    description: "Create a new system notification.",
+    parameters: {
+      type: "object",
+      properties: {
+        title: { type: "string", description: "Notification title" },
+        subject: { type: "string", description: "Notification subject" },
+        description: { type: "string", description: "Notification body text" },
+        importance: { type: "string", enum: ["normal", "warning", "alert"], description: "Importance level: alert, warning, or normal" },
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
+      },
+      required: ["title", "subject", "description"]
+    },
+    execute: async (_id, params) => {
+      try {
+        const body = {
+          title: params.title,
+          subject: params.subject,
+          description: params.description
+        };
+        if (params.importance) body.importance = params.importance;
+        return textResult(await getClient(params.server).post("/api/notifications", body));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  });
+  api.registerTool({
+    name: "unraid_notification_archive",
+    description: "Archive a notification (mark as read/handled).",
+    parameters: {
+      type: "object",
+      properties: {
+        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 getClient(params.server).post(`/api/notifications/${params.id}/archive`));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  });
+  api.registerTool({
+    name: "unraid_notification_delete",
+    description: "Delete a notification permanently.",
+    parameters: {
+      type: "object",
+      properties: {
+        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 getClient(params.server).delete(`/api/notifications/${params.id}`));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  });
+}
+
+// src/tools/network.ts
+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: {
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
+      }
+    },
+    execute: async (_id, params) => {
+      try {
+        return textResult(await getClient(params.server).get("/api/network"));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  });
+}
+
+// src/tools/users.ts
+function registerUserTools(api, getClient) {
+  api.registerTool({
+    name: "unraid_user_me",
+    description: "Get information about the current authenticated user.",
+    parameters: {
+      type: "object",
+      properties: {
+        server: { type: "string", description: "Target server name (optional, uses default server)" }
+      }
+    },
+    execute: async (_id, params) => {
+      try {
+        return textResult(await getClient(params.server).get("/api/users/me"));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  });
+}
+
+// src/tools/logs.ts
+function registerLogTools(api, getClient) {
+  api.registerTool({
+    name: "unraid_syslog",
+    description: "Get recent syslog entries from the Unraid server. Returns the most recent log lines.",
+    parameters: {
+      type: "object",
+      properties: {
+        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 getClient(params.server).get("/api/logs/syslog", query));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  });
+}
+
+// src/registry.ts
+function registerTools(api, getClient) {
+  registerHealthTools(api, getClient);
+  registerDockerTools(api, getClient);
+  registerCaTools(api, getClient);
+  registerPluginTools(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);
+}
+var READ_ONLY = /* @__PURE__ */ new Set([
+  "unraid_health_check",
+  "unraid_docker_list",
+  "unraid_docker_inspect",
+  "unraid_docker_logs",
+  "unraid_ca_search",
+  "unraid_ca_app",
+  "unraid_plugins_list",
+  "unraid_plugin_info",
+  "unraid_vm_list",
+  "unraid_vm_inspect",
+  "unraid_array_status",
+  "unraid_parity_status",
+  "unraid_disk_list",
+  "unraid_disk_details",
+  "unraid_share_list",
+  "unraid_share_details",
+  "unraid_system_info",
+  "unraid_system_metrics",
+  "unraid_service_list",
+  "unraid_notification_list",
+  "unraid_network_info",
+  "unraid_user_me",
+  "unraid_syslog"
+]);
+export {
+  READ_ONLY,
+  isErrorResult,
+  registerTools
+};