unraidclaw 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+declare function register(api: any): void;
+
+export { register as default };

package/dist/index.js

@@ -0,0 +1,844 @@
+// src/client.ts
+var UnraidApiError = class extends Error {
+  constructor(message, statusCode, errorCode) {
+    super(message);
+    this.statusCode = statusCode;
+    this.errorCode = errorCode;
+    this.name = "UnraidApiError";
+  }
+};
+var UnraidClient = class {
+  configResolver;
+  tlsConfigured = false;
+  constructor(configResolver) {
+    this.configResolver = configResolver;
+  }
+  getConfig() {
+    const cfg = this.configResolver();
+    if (!cfg.serverUrl) {
+      throw new UnraidApiError("UnraidClaw serverUrl not configured", 0, "CONFIG_ERROR");
+    }
+    if (!this.tlsConfigured && cfg.tlsSkipVerify && cfg.serverUrl.startsWith("https")) {
+      process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
+      this.tlsConfigured = true;
+    }
+    return {
+      baseUrl: cfg.serverUrl.replace(/\/+$/, ""),
+      apiKey: cfg.apiKey || ""
+    };
+  }
+  async get(path, query) {
+    const { baseUrl } = this.getConfig();
+    let url = `${baseUrl}${path}`;
+    if (query) {
+      const params = new URLSearchParams(query);
+      url += `?${params.toString()}`;
+    }
+    return this.request("GET", url);
+  }
+  async post(path, body) {
+    const { baseUrl } = this.getConfig();
+    return this.request("POST", `${baseUrl}${path}`, body);
+  }
+  async patch(path, body) {
+    const { baseUrl } = this.getConfig();
+    return this.request("PATCH", `${baseUrl}${path}`, body);
+  }
+  async delete(path) {
+    const { baseUrl } = this.getConfig();
+    return this.request("DELETE", `${baseUrl}${path}`);
+  }
+  async request(method, url, body) {
+    const { apiKey } = this.getConfig();
+    const headers = {
+      "x-api-key": apiKey
+    };
+    const init = { method, headers };
+    if (body !== void 0) {
+      headers["Content-Type"] = "application/json";
+      init.body = JSON.stringify(body);
+    }
+    let response;
+    try {
+      response = await fetch(url, init);
+    } catch (err) {
+      throw new UnraidApiError(
+        `Connection failed: ${err instanceof Error ? err.message : "Unknown error"}`,
+        0,
+        "CONNECTION_ERROR"
+      );
+    }
+    const json = await response.json();
+    if (!json.ok) {
+      throw new UnraidApiError(
+        json.error.message,
+        response.status,
+        json.error.code
+      );
+    }
+    return json.data;
+  }
+};
+
+// src/tools/util.ts
+function textResult(data) {
+  return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+}
+function errorResult(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  return { content: [{ type: "text", text: `Error: ${message}` }] };
+}
+
+// src/tools/health.ts
+function registerHealthTools(api, client) {
+  api.registerTool({
+    name: "unraid_health_check",
+    description: "Check the health status of the Unraid server connection, including API and GraphQL reachability.",
+    parameters: { type: "object" },
+    execute: async () => {
+      try {
+        return textResult(await client.get("/api/health"));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  });
+}
+
+// src/tools/docker.ts
+function registerDockerTools(api, client) {
+  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" },
+    execute: async () => {
+      try {
+        return textResult(await client.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" }
+      },
+      required: ["id"]
+    },
+    execute: async (_id, params) => {
+      try {
+        return textResult(await client.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: "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)" }
+      },
+      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 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`));
+      } 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" }
+      },
+      required: ["id"]
+    },
+    execute: async (_id, params) => {
+      try {
+        return textResult(await client.post(`/api/docker/containers/${params.id}/unpause`));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  });
+  api.registerTool({
+    name: "unraid_docker_remove",
+    description: "Remove a Docker container. This is a destructive operation that cannot be undone.",
+    parameters: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: "Container ID or name" }
+      },
+      required: ["id"]
+    },
+    execute: async (_id, params) => {
+      try {
+        return textResult(await client.delete(`/api/docker/containers/${params.id}`));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  });
+}
+
+// src/tools/vms.ts
+function registerVMTools(api, client) {
+  api.registerTool({
+    name: "unraid_vm_list",
+    description: "List all virtual machines on the Unraid server with their current state.",
+    parameters: { type: "object" },
+    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);
+      }
+    }
+  });
+  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`));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  });
+  api.registerTool({
+    name: "unraid_vm_stop",
+    description: "Gracefully stop a running virtual machine (ACPI shutdown).",
+    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}/stop`));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  });
+  api.registerTool({
+    name: "unraid_vm_pause",
+    description: "Pause a running virtual machine (suspend to RAM).",
+    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}/pause`));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  });
+  api.registerTool({
+    name: "unraid_vm_resume",
+    description: "Resume a paused 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}/resume`));
+      } 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).",
+    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}/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.",
+    parameters: { type: "object" },
+    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" },
+    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" },
+    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" },
+    execute: async () => {
+      try {
+        return textResult(await client.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)."
+        }
+      }
+    },
+    execute: async (_id, params) => {
+      try {
+        return textResult(await client.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" },
+    execute: async () => {
+      try {
+        return textResult(await client.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" },
+    execute: async () => {
+      try {
+        return textResult(await client.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" },
+    execute: async () => {
+      try {
+        return textResult(await client.post("/api/array/parity/cancel"));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  });
+}
+
+// src/tools/disks.ts
+function registerDiskTools(api, client) {
+  api.registerTool({
+    name: "unraid_disk_list",
+    description: "List all disks in the Unraid server with basic info (name, size, temp, status).",
+    parameters: { type: "object" },
+    execute: async () => {
+      try {
+        return textResult(await client.get("/api/disks"));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  });
+  api.registerTool({
+    name: "unraid_disk_details",
+    description: "Get detailed information about a specific disk including SMART data and health status.",
+    parameters: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: "Disk ID (e.g., 'disk1', 'parity')" }
+      },
+      required: ["id"]
+    },
+    execute: async (_id, params) => {
+      try {
+        return textResult(await client.get(`/api/disks/${params.id}`));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  });
+}
+
+// src/tools/shares.ts
+function registerShareTools(api, client) {
+  api.registerTool({
+    name: "unraid_share_list",
+    description: "List all user shares on the Unraid server with their settings and usage.",
+    parameters: { type: "object" },
+    execute: async () => {
+      try {
+        return textResult(await client.get("/api/shares"));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  });
+  api.registerTool({
+    name: "unraid_share_details",
+    description: "Get details for a specific user share by name.",
+    parameters: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "Share name" }
+      },
+      required: ["name"]
+    },
+    execute: async (_id, params) => {
+      try {
+        return textResult(await client.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 \u2014 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" }
+      },
+      required: ["name"]
+    },
+    execute: async (_id, params) => {
+      try {
+        const { name, ...updates } = params;
+        return textResult(await client.patch(`/api/shares/${name}`, updates));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  });
+}
+
+// src/tools/system.ts
+function registerSystemTools(api, client) {
+  api.registerTool({
+    name: "unraid_system_info",
+    description: "Get system information including OS, CPU, memory, and Unraid/kernel versions.",
+    parameters: { type: "object" },
+    execute: async () => {
+      try {
+        return textResult(await client.get("/api/system/info"));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  });
+  api.registerTool({
+    name: "unraid_system_metrics",
+    description: "Get live system metrics: CPU usage, memory usage, load average, and uptime.",
+    parameters: { type: "object" },
+    execute: async () => {
+      try {
+        return textResult(await client.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" },
+    execute: async () => {
+      try {
+        return textResult(await client.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" },
+    execute: async () => {
+      try {
+        return textResult(await client.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" },
+    execute: async () => {
+      try {
+        return textResult(await client.post("/api/system/shutdown"));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  });
+}
+
+// src/tools/notifications.ts
+function registerNotificationTools(api, client) {
+  api.registerTool({
+    name: "unraid_notification_list",
+    description: "List all system notifications with their importance level and archive status.",
+    parameters: { type: "object" },
+    execute: async () => {
+      try {
+        return textResult(await client.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", description: "Importance level: alert, warning, or normal" }
+      },
+      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 client.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" }
+      },
+      required: ["id"]
+    },
+    execute: async (_id, params) => {
+      try {
+        return textResult(await client.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" }
+      },
+      required: ["id"]
+    },
+    execute: async (_id, params) => {
+      try {
+        return textResult(await client.delete(`/api/notifications/${params.id}`));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  });
+}
+
+// src/tools/network.ts
+function registerNetworkTools(api, client) {
+  api.registerTool({
+    name: "unraid_network_info",
+    description: "Get network information including hostname, gateway, DNS servers, and all network interfaces.",
+    parameters: { type: "object" },
+    execute: async () => {
+      try {
+        return textResult(await client.get("/api/network"));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  });
+}
+
+// src/tools/users.ts
+function registerUserTools(api, client) {
+  api.registerTool({
+    name: "unraid_user_me",
+    description: "Get information about the current authenticated user.",
+    parameters: { type: "object" },
+    execute: async () => {
+      try {
+        return textResult(await client.get("/api/users/me"));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  });
+}
+
+// src/tools/logs.ts
+function registerLogTools(api, client) {
+  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)."
+        }
+      }
+    },
+    execute: async (_id, params) => {
+      try {
+        const query = {};
+        if (params.lines) query.lines = String(params.lines);
+        return textResult(await client.get("/api/logs/syslog", query));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  });
+}
+
+// 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 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 39 tools${cfg.serverUrl ? ", server: " + cfg.serverUrl : " (config will resolve at runtime)"}`);
+}
+export {
+  register as default
+};

package/openclaw.plugin.json

@@ -0,0 +1,36 @@
+{
+  "id": "unraidclaw",
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {
+      "serverUrl": {
+        "type": "string",
+        "description": "URL of the UnraidClaw server (e.g., http://192.168.1.100:9876)"
+      },
+      "apiKey": {
+        "type": "string",
+        "description": "API key for authenticating with UnraidClaw"
+      },
+      "tlsSkipVerify": {
+        "type": "boolean",
+        "description": "Skip TLS certificate verification (for self-signed certs)",
+        "default": false
+      }
+    },
+    "required": ["serverUrl", "apiKey"]
+  },
+  "uiHints": {
+    "serverUrl": {
+      "label": "Server URL",
+      "placeholder": "https://192.168.1.100:9876"
+    },
+    "apiKey": {
+      "label": "API Key",
+      "sensitive": true
+    },
+    "tlsSkipVerify": {
+      "label": "Skip TLS Verification"
+    }
+  }
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "unraidclaw",
+  "version": "0.1.0",
+  "description": "OpenClaw plugin to manage your Unraid server — Docker, VMs, array, shares, system, and more.",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "openclaw": {
+    "extensions": ["./dist/index.js"]
+  },
+  "files": [
+    "dist",
+    "openclaw.plugin.json"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  },
+  "devDependencies": {
+    "@unraidclaw/shared": "workspace:*",
+    "typescript": "^5.7.0",
+    "@types/node": "^22.0.0",
+    "tsup": "^8.5.0"
+  }
+}