@ouro.bot/cli 0.1.0-alpha.733 → 0.1.0-alpha.734

package/dist/repertoire/tools-unraid.js

@@ -0,0 +1,353 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unraidToolDefinitions = exports.SANCTUARY_SYSTEM_QUERY = exports.SANCTUARY_NOTIFICATIONS_QUERY = exports.SANCTUARY_DISKS_QUERY = exports.SANCTUARY_STORAGE_QUERY = exports.SANCTUARY_CONTAINER_LOGS_QUERY = exports.SANCTUARY_CONTAINERS_QUERY = void 0;
+exports.normalizeDockerStatus = normalizeDockerStatus;
+exports.createUnraidReadTools = createUnraidReadTools;
+const node_crypto_1 = require("node:crypto");
+const runtime_1 = require("../nerves/runtime");
+const unraid_client_1 = require("./unraid-client");
+exports.SANCTUARY_CONTAINERS_QUERY = `query SanctuaryContainers {
+  docker { containers(skipCache: true) { id names state status autoStart } }
+}`;
+exports.SANCTUARY_CONTAINER_LOGS_QUERY = `query SanctuaryContainerLogs($id: PrefixedID!, $tail: Int!) {
+  docker { logs(id: $id, tail: $tail) { containerId lines { timestamp message } cursor } }
+}`;
+exports.SANCTUARY_STORAGE_QUERY = `query SanctuaryStorage {
+  vars { id }
+  array { state capacity { kilobytes { used free total } } }
+  shares { id name used free size }
+}`;
+exports.SANCTUARY_DISKS_QUERY = `query SanctuaryDisks {
+  disks { id name smartStatus temperature }
+  array { parityCheckStatus { status date duration errors progress correcting paused running } }
+}`;
+exports.SANCTUARY_NOTIFICATIONS_QUERY = `query SanctuaryNotifications {
+  notifications { list(filter: {type: UNREAD, offset: 0, limit: 100}) { id timestamp importance title subject description type } }
+}`;
+exports.SANCTUARY_SYSTEM_QUERY = `query SanctuarySystem {
+  vars { id name version }
+  info { time os { uptime } versions { core { unraid api } } }
+  array { state }
+}`;
+function utf8Bytes(value) { return Buffer.byteLength(value, "utf8"); }
+function identifier(value, label, maxBytes = 128) {
+    if (typeof value !== "string" || value.length === 0 || utf8Bytes(value) > maxBytes || value.includes("\uFFFD")) {
+        throw new unraid_client_1.UnraidClientError("invalid_response", `${label} is invalid`);
+    }
+    return value;
+}
+function display(value, maxBytes) {
+    if (typeof value !== "string")
+        return { value: "", truncated: true };
+    const bytes = Buffer.from(value, "utf8");
+    if (bytes.length <= maxBytes)
+        return { value, truncated: false };
+    let prefix = bytes.subarray(0, maxBytes - 3).toString("utf8");
+    while (prefix.endsWith("\uFFFD"))
+        prefix = prefix.slice(0, -1);
+    return { value: `${prefix}...`, truncated: true };
+}
+const DURATION = "(?:Less than a second|About a (?:minute|hour|day|week|month|year)|(?:[1-9][0-9]*) (?:seconds?|minutes?|hours?|days?|weeks?|months?|years?))";
+const RUNNING = new RegExp(`^Up ${DURATION}(?: \\((?:healthy|unhealthy|health: starting)\\))?$`, "u");
+const EXITED = new RegExp(`^Exited \\((0|[1-9][0-9]*)\\) ${DURATION} ago$`, "u");
+const RESTARTING = new RegExp(`^Restarting \\((0|[1-9][0-9]*)\\) ${DURATION} ago$`, "u");
+function exitCode(match) {
+    const value = Number(match[1]);
+    return Number.isSafeInteger(value) && value >= 0 && value <= 4_294_967_295 ? value : null;
+}
+function normalizeDockerStatus(structuredState, status) {
+    if (typeof status !== "string")
+        return { state: "unknown", exitCode: null, degraded: true };
+    const state = typeof structuredState === "string" ? structuredState.toUpperCase() : "";
+    if (state === "RUNNING" && RUNNING.test(status))
+        return { state: "running", exitCode: null, degraded: false };
+    const exited = status.match(EXITED);
+    if (state === "EXITED" && exited) {
+        const code = exitCode(exited);
+        return code === null ? { state: "unknown", exitCode: null, degraded: true } : { state: "exited", exitCode: code, degraded: false };
+    }
+    const restarting = status.match(RESTARTING);
+    if ((state === "RUNNING" || state === "EXITED") && restarting) {
+        const code = exitCode(restarting);
+        return code === null ? { state: "unknown", exitCode: null, degraded: true } : { state: "restarting", exitCode: code, degraded: false };
+    }
+    return { state: "unknown", exitCode: null, degraded: true };
+}
+function numberOrNull(value) {
+    const number = typeof value === "bigint" ? Number(value) : typeof value === "string" && /^-?[0-9]+$/u.test(value) ? Number(value) : value;
+    return typeof number === "number" && Number.isSafeInteger(number) && number >= 0 ? number : null;
+}
+function percent(used, free) {
+    if (used === null || free === null || used + free === 0)
+        return null;
+    return Number(((used / (used + free)) * 100).toFixed(2));
+}
+function record(value, label) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new unraid_client_1.UnraidClientError("invalid_response", `${label} is invalid`);
+    return value;
+}
+function array(value, label) {
+    if (!Array.isArray(value))
+        throw new unraid_client_1.UnraidClientError("invalid_response", `${label} is invalid`);
+    return value;
+}
+function fail(error) {
+    const normalized = error instanceof unraid_client_1.UnraidClientError
+        ? error
+        : new unraid_client_1.UnraidClientError("invalid_response", error instanceof Error ? error.message : String(error));
+    return { ok: false, error: { code: normalized.code, message: normalized.message, degraded: true } };
+}
+function containerName(names) {
+    const values = array(names, "container names");
+    if (values.length !== 1)
+        throw new unraid_client_1.UnraidClientError("invalid_response", "container names are ambiguous");
+    return identifier(values[0], "container name").replace(/^\//u, "");
+}
+function mapContainers(data) {
+    const docker = record(data.docker, "docker response");
+    const raw = array(docker.containers, "container list");
+    const truncated = raw.length > 200;
+    const containers = raw.slice(0, 200).map((entry) => {
+        const item = record(entry, "container");
+        const id = unraid_client_1.UnraidClient.assertPrefixedId(identifier(item.id, "container id", 256));
+        const name = containerName(item.names);
+        const shownStatus = display(item.status, 256);
+        const normalized = normalizeDockerStatus(item.state, shownStatus.value);
+        return {
+            id,
+            name,
+            autostart: typeof item.autoStart === "boolean" ? item.autoStart : false,
+            ...normalized,
+            degraded: normalized.degraded || shownStatus.truncated || typeof item.autoStart !== "boolean",
+            status: shownStatus.value,
+        };
+    }).sort((a, b) => a.name.localeCompare(b.name) || a.id.localeCompare(b.id));
+    return { containers, truncated };
+}
+function validTimestamp(value) {
+    if (typeof value !== "string" || utf8Bytes(value) > 64 || !/(?:Z|[+-][0-9]{2}:[0-9]{2})$/u.test(value))
+        return null;
+    const time = Date.parse(value);
+    return Number.isFinite(time) ? new Date(time).toISOString() : null;
+}
+function liveSourceIdentityDigest(value) {
+    const prefixedId = identifier(value, "server identity", 129);
+    if (!/^[0-9a-f]{64}:[0-9a-f]{64}$/u.test(prefixedId))
+        throw new unraid_client_1.UnraidClientError("invalid_response", "server identity is invalid");
+    return (0, node_crypto_1.createHash)("sha256").update(prefixedId).digest("hex");
+}
+function createUnraidReadTools(client) {
+    const listContainers = async () => {
+        try {
+            const data = await client.read(exports.SANCTUARY_CONTAINERS_QUERY, {});
+            return { ok: true, data: mapContainers(data) };
+        }
+        catch (error) {
+            return fail(error);
+        }
+    };
+    return {
+        listContainers,
+        async getContainerLogs(args) {
+            try {
+                const wanted = identifier(args.container, "container argument");
+                if (!Number.isInteger(args.tailLines) || args.tailLines < 1 || args.tailLines > 200)
+                    throw new unraid_client_1.UnraidClientError("invalid_response", "tailLines must be an integer from 1 to 200");
+                const listed = await listContainers();
+                if (!listed.ok)
+                    return listed;
+                const matches = listed.data.containers.filter((container) => container.name === wanted);
+                if (matches.length === 0)
+                    return { ok: false, error: { code: "not_found", message: `container '${wanted}' was not found`, degraded: true } };
+                if (matches.length !== 1)
+                    return { ok: false, error: { code: "ambiguous", message: `container '${wanted}' is ambiguous`, degraded: true } };
+                const target = matches[0];
+                const data = await client.read(exports.SANCTUARY_CONTAINER_LOGS_QUERY, { id: target.id, tail: args.tailLines });
+                const logs = record(record(data.docker, "docker response").logs, "container logs");
+                if (logs.containerId !== target.id)
+                    throw new unraid_client_1.UnraidClientError("invalid_response", "container log identity drifted");
+                const text = array(logs.lines, "container log lines").map((line) => display(record(line, "log line").message, 1_000_000).value).join("\n");
+                const originalBytes = utf8Bytes(text);
+                const suffix = Buffer.from(text, "utf8").subarray(Math.max(0, originalBytes - 65_536)).toString("utf8").replace(/^\uFFFD/u, "");
+                const returnedBytes = utf8Bytes(suffix);
+                return { ok: true, data: { container: { id: target.id, name: target.name }, text: suffix, originalBytes, returnedBytes, truncated: returnedBytes < originalBytes } };
+            }
+            catch (error) {
+                return fail(error);
+            }
+        },
+        async getStorage() {
+            try {
+                const data = await client.read(exports.SANCTUARY_STORAGE_QUERY, {});
+                const sourceIdentityDigest = liveSourceIdentityDigest(record(data.vars, "vars").id);
+                const arrayRecord = record(data.array, "array");
+                const kb = record(record(arrayRecord.capacity, "array capacity").kilobytes, "array capacity kilobytes");
+                const usedKb = numberOrNull(kb.used);
+                const freeKb = numberOrNull(kb.free);
+                const usedBytes = usedKb === null ? null : usedKb * 1024;
+                const freeBytes = freeKb === null ? null : freeKb * 1024;
+                const state = display(arrayRecord.state, 128);
+                const rawShares = array(data.shares, "shares");
+                const truncated = rawShares.length > 256;
+                const shares = rawShares.slice(0, 256).map((entry) => {
+                    const item = record(entry, "share");
+                    const name = identifier(item.name, "share name");
+                    const used = numberOrNull(item.used);
+                    const free = numberOrNull(item.free);
+                    return { name, usedBytes: used, freeBytes: free, usedPercent: percent(used, free), degraded: used === null || free === null };
+                }).sort((a, b) => a.name.localeCompare(b.name));
+                return { ok: true, data: { sourceIdentityDigest, array: { state: state.value, usedBytes, freeBytes, usedPercent: percent(usedBytes, freeBytes), degraded: state.truncated || usedBytes === null || freeBytes === null }, shares, truncated } };
+            }
+            catch (error) {
+                return fail(error);
+            }
+        },
+        async getDisks() {
+            try {
+                const data = await client.read(exports.SANCTUARY_DISKS_QUERY, {});
+                const rawDisks = array(data.disks, "disks");
+                const truncated = rawDisks.length > 64;
+                const disks = rawDisks.slice(0, 64).map((entry) => {
+                    const item = record(entry, "disk");
+                    const id = identifier(item.id, "disk id");
+                    const name = identifier(item.name, "disk name");
+                    const smartRaw = typeof item.smartStatus === "string" ? item.smartStatus.toLowerCase() : "";
+                    const smart = smartRaw === "passed" ? "passed" : smartRaw === "failed" ? "failed" : "unknown";
+                    const temperatureC = typeof item.temperature === "number" && Number.isFinite(item.temperature) ? item.temperature : null;
+                    return { id, name, smart, temperatureC, degraded: smart === "unknown" || temperatureC === null };
+                }).sort((a, b) => a.name.localeCompare(b.name) || a.id.localeCompare(b.id));
+                const parityRaw = record(record(data.array, "array").parityCheckStatus, "parity status");
+                const completedAt = validTimestamp(parityRaw.date);
+                const errors = numberOrNull(parityRaw.errors);
+                const result = errors === 0 && typeof parityRaw.status === "string" && /complete|success/i.test(parityRaw.status) ? "success" : errors !== null && errors > 0 ? "failed" : "unknown";
+                const elapsedMs = completedAt ? Date.now() - Date.parse(completedAt) : null;
+                const ageHours = elapsedMs !== null && elapsedMs >= 0 ? elapsedMs / 3_600_000 : null;
+                return { ok: true, data: { disks, parity: { result, completedAt, ageHours, degraded: result === "unknown" || completedAt === null || ageHours === null }, truncated } };
+            }
+            catch (error) {
+                return fail(error);
+            }
+        },
+        async getNotifications() {
+            try {
+                const data = await client.read(exports.SANCTUARY_NOTIFICATIONS_QUERY, {});
+                const raw = array(record(data.notifications, "notifications").list, "notification list");
+                const truncated = raw.length > 100;
+                const unacknowledged = raw.slice(0, 100).map((entry) => {
+                    const item = record(entry, "notification");
+                    const id = identifier(item.id, "notification id");
+                    const createdAt = validTimestamp(item.timestamp);
+                    const importance = typeof item.importance === "string" ? item.importance.toLowerCase() : "";
+                    const severity = importance === "info" || importance === "warning" || importance === "error" ? importance : "unknown";
+                    const title = display(item.title, 160);
+                    const subject = display(item.subject, 250);
+                    const description = display(item.description, 250);
+                    const summary = display([subject.value, description.value].filter(Boolean).join("\n"), 500);
+                    return { id, createdAt, severity, title: title.value, summary: summary.value, degraded: !createdAt || severity === "unknown" || title.truncated || subject.truncated || description.truncated || summary.truncated };
+                }).sort((a, b) => {
+                    if (a.createdAt && b.createdAt)
+                        return b.createdAt.localeCompare(a.createdAt);
+                    if (a.createdAt)
+                        return -1;
+                    if (b.createdAt)
+                        return 1;
+                    return a.id.localeCompare(b.id);
+                });
+                return { ok: true, data: { unacknowledged, truncated } };
+            }
+            catch (error) {
+                return fail(error);
+            }
+        },
+        async getSystem() {
+            try {
+                const data = await client.read(exports.SANCTUARY_SYSTEM_QUERY, {});
+                const vars = record(data.vars, "vars");
+                const info = record(data.info, "info");
+                const versions = record(record(info.versions, "versions").core, "core versions");
+                const sourceIdentityDigest = liveSourceIdentityDigest(vars.id);
+                const name = display(vars.name, 128);
+                const unraid = display(versions.unraid ?? vars.version, 128);
+                const api = display(versions.api, 128);
+                const state = display(record(data.array, "array").state, 128);
+                const uptimeSeconds = numberOrNull(record(info.os, "os").uptime);
+                return { ok: true, data: { sourceIdentityDigest, serverName: name.value, unraidVersion: unraid.value, apiVersion: api.value, arrayState: state.value, uptimeSeconds, degraded: name.truncated || unraid.truncated || api.truncated || state.truncated || uptimeSeconds === null } };
+            }
+            catch (error) {
+                return fail(error);
+            }
+        },
+    };
+}
+const emptyParameters = { type: "object", properties: {}, additionalProperties: false };
+function missingRuntime() {
+    return JSON.stringify({ ok: false, error: { code: "invalid_response", message: "Sanctuary runtime is unavailable", degraded: true } });
+}
+function readDefinition(name, description, method) {
+    return {
+        tool: { type: "function", function: { name, description, parameters: emptyParameters } },
+        handler: async (_args, ctx) => JSON.stringify(ctx?.sanctuary ? await ctx.sanctuary[method]() : JSON.parse(missingRuntime())),
+        riskProfile: { mutates: "none", risk: "low" },
+    };
+}
+exports.unraidToolDefinitions = [
+    readDefinition("unraid_list_containers", "List bounded Sanctuary Docker container status.", "listContainers"),
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "unraid_get_container_logs",
+                description: "Read the recent bounded log suffix for one exact Sanctuary container name.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        container: { type: "string" },
+                        tailLines: { type: "integer", minimum: 1, maximum: 200 },
+                    },
+                    required: ["container", "tailLines"],
+                    additionalProperties: false,
+                },
+            },
+        },
+        handler: async (args, ctx) => JSON.stringify(ctx?.sanctuary
+            ? await ctx.sanctuary.getContainerLogs({ container: String(args.container), tailLines: Number(args.tailLines) })
+            : JSON.parse(missingRuntime())),
+        riskProfile: { mutates: "none", risk: "low" },
+    },
+    readDefinition("unraid_get_storage", "Read bounded Sanctuary array and share capacity health.", "getStorage"),
+    readDefinition("unraid_get_disks", "Read bounded Sanctuary disk SMART, temperature, and parity health.", "getDisks"),
+    readDefinition("unraid_get_notifications", "Read bounded unacknowledged Sanctuary notifications.", "getNotifications"),
+    readDefinition("unraid_get_system", "Read bounded Sanctuary system and version health.", "getSystem"),
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "unraid_restart_container",
+                description: "Propose restarting one exact existing allowlisted Sanctuary container. Execution requires human approval.",
+                parameters: {
+                    type: "object",
+                    properties: { container: { type: "string" } },
+                    required: ["container"],
+                    additionalProperties: false,
+                },
+            },
+        },
+        handler: async (args, ctx) => JSON.stringify(ctx?.sanctuary
+            ? await ctx.sanctuary.restartContainer({ container: String(args.container) })
+            : JSON.parse(missingRuntime())),
+        riskProfile: { mutates: "external_side_effect", risk: "high", reason: "restarts one existing allowlisted Docker container" },
+        approvalPolicy: () => ({
+            kind: "required",
+            policyId: "sanctuary.unraid.restart.v1",
+            actionClass: "unraid.container.restart",
+            requiresSoleCall: true,
+        }),
+    },
+];
+(0, runtime_1.emitNervesEvent)({
+    component: "repertoire",
+    event: "repertoire.unraid_tools_loaded",
+    message: "typed Unraid tools loaded",
+    meta: { operations: 6 },
+});

package/dist/repertoire/tools.js

@@ -25,6 +25,8 @@ const tools_surface_1 = require("./tools-surface");
 const mcp_tools_1 = require("./mcp-tools");
 const tools_voice_1 = require("./tools-voice");
 const shell_sessions_1 = require("./shell-sessions");
+const tools_unraid_1 = require("./tools-unraid");
+const tools_flow_1 = require("./tools-flow");
 function safeGetAgentRoot() {
     try {
         return (0, identity_1.getAgentRoot)();
@@ -33,6 +35,14 @@ function safeGetAgentRoot() {
         return undefined;
     }
 }
+function isSanctuaryAgent() {
+    try {
+        return (0, identity_1.getAgentName)() === "sanctuary";
+    }
+    catch {
+        return false;
+    }
+}
 // Re-export types and constants used by the rest of the codebase
 var tools_base_2 = require("./tools-base");
 Object.defineProperty(exports, "tools", { enumerable: true, get: function () { return tools_base_2.tools; } });
@@ -45,7 +55,7 @@ Object.defineProperty(exports, "speakTool", { enumerable: true, get: function ()
 var tools_surface_2 = require("./tools-surface");
 Object.defineProperty(exports, "surfaceToolDef", { enumerable: true, get: function () { return tools_surface_2.surfaceToolDef; } });
 // All tool definitions in a single registry
-const allDefinitions = [...tools_base_1.baseToolDefinitions, ...tools_bluebubbles_1.bluebubblesToolDefinitions, ...tools_teams_1.teamsToolDefinitions, ...ado_semantic_1.adoSemanticToolDefinitions, ...tools_github_1.githubToolDefinitions, ...tools_bundle_1.bundleToolDefinitions, ...tools_voice_1.voiceToolDefinitions, tools_surface_1.surfaceToolDefinition];
+const allDefinitions = [...tools_base_1.baseToolDefinitions, ...tools_bluebubbles_1.bluebubblesToolDefinitions, ...tools_teams_1.teamsToolDefinitions, ...ado_semantic_1.adoSemanticToolDefinitions, ...tools_github_1.githubToolDefinitions, ...tools_bundle_1.bundleToolDefinitions, ...tools_voice_1.voiceToolDefinitions, ...tools_unraid_1.unraidToolDefinitions, tools_surface_1.surfaceToolDefinition];
 const COMMERCE_AUTHORITY_TOOLS = new Set(["stripe_create_card", "flight_hold", "flight_book"]);
 // MCP tool definitions — populated each time getToolsForChannel() is called with an mcpManager.
 // Kept separate from allDefinitions so execTool can find them.
@@ -85,6 +95,14 @@ function filterByCapability(toolList, providerCapabilities) {
 // When toolPreferences is provided, matching preferences are appended to tool descriptions.
 // When providerCapabilities is provided, tools with requiredCapability are filtered.
 function getToolsForChannel(capabilities, toolPreferences, _context, providerCapabilities, mcpManager, _chatModel) {
+    if (capabilities?.channel === "telegram" && isSanctuaryAgent()) {
+        return [
+            ...tools_unraid_1.unraidToolDefinitions.map((definition) => definition.tool),
+            tools_flow_1.ponderTool,
+            tools_flow_1.settleTool,
+            tools_flow_1.speakTool,
+        ];
+    }
     const baseTools = baseToolsForCapabilities();
     const bluebubblesTools = capabilities?.channel === "bluebubbles"
         ? tools_bluebubbles_1.bluebubblesToolDefinitions.map((d) => d.tool)

package/dist/repertoire/unraid-client.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnraidClient = exports.UnraidClientError = void 0;
+const runtime_1 = require("../nerves/runtime");
+class UnraidClientError extends Error {
+    code;
+    ambiguous;
+    constructor(code, message, ambiguous = false, options = {}) {
+        super(limitUtf8(message, 240), options.cause === undefined ? undefined : { cause: options.cause });
+        this.code = code;
+        this.ambiguous = ambiguous;
+        this.name = "UnraidClientError";
+    }
+}
+exports.UnraidClientError = UnraidClientError;
+function limitUtf8(value, maxBytes) {
+    const bytes = Buffer.from(value, "utf8");
+    if (bytes.length <= maxBytes)
+        return value;
+    return bytes.subarray(0, Math.max(0, maxBytes - 3)).toString("utf8").replace(/\uFFFD+$/u, "") + "...";
+}
+function canonicalEndpoint(value) {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        throw new Error("Unraid GraphQL endpoint is invalid");
+    }
+    if ((url.protocol !== "http:" && url.protocol !== "https:") || url.username || url.password || url.search || url.hash) {
+        throw new Error("Unraid GraphQL endpoint is invalid");
+    }
+    return url.toString();
+}
+function statusError(status) {
+    if (status === 401)
+        return new UnraidClientError("unauthorized", "Unraid GraphQL request was unauthorized");
+    if (status === 403)
+        return new UnraidClientError("forbidden", "Unraid GraphQL request was forbidden");
+    return new UnraidClientError("transport", `Unraid GraphQL request failed with HTTP ${status}`);
+}
+class UnraidClient {
+    endpoint;
+    apiKey;
+    fetchImpl;
+    sleep;
+    readTimeoutMs;
+    mutationTimeoutMs;
+    constructor(options) {
+        this.endpoint = canonicalEndpoint(options.endpoint);
+        this.apiKey = options.apiKey.trim();
+        if (!this.apiKey)
+            throw new Error("Unraid API key is missing");
+        this.fetchImpl = options.fetch ?? fetch;
+        this.sleep = options.sleep ?? ((milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)));
+        this.readTimeoutMs = options.readTimeoutMs ?? 10_000;
+        this.mutationTimeoutMs = options.mutationTimeoutMs ?? 15_000;
+    }
+    static assertPrefixedId(value) {
+        if (Buffer.byteLength(value, "utf8") > 256 || !/^[^:]+:[^:]+$/u.test(value)) {
+            throw new Error("Unraid identifier must be one bounded prefixed ID");
+        }
+        return value;
+    }
+    read(document, variables, signal) {
+        return this.execute("read", document, variables, signal);
+    }
+    mutate(document, variables, signal) {
+        return this.execute("mutation", document, variables, signal);
+    }
+    async execute(kind, document, variables, signal) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "repertoire",
+            event: "repertoire.unraid_request_start",
+            message: "Unraid GraphQL request started",
+            meta: { kind },
+        });
+        const delays = [250, 1000];
+        const maxAttempts = kind === "read" ? 3 : 1;
+        for (let attempt = 0;; attempt += 1) {
+            const timeout = AbortSignal.timeout(kind === "read" ? this.readTimeoutMs : this.mutationTimeoutMs);
+            const requestSignal = signal ? AbortSignal.any([signal, timeout]) : timeout;
+            let response;
+            try {
+                response = await this.fetchImpl(this.endpoint, {
+                    method: "POST",
+                    headers: { "x-api-key": this.apiKey, "Content-Type": "application/json" },
+                    body: JSON.stringify({ query: document, variables }),
+                    signal: requestSignal,
+                });
+            }
+            catch (error) {
+                const timedOut = timeout.aborted && !signal?.aborted;
+                if (kind === "read" && !timedOut && !signal?.aborted && attempt < maxAttempts - 1) {
+                    await this.sleep(delays[attempt]);
+                    continue;
+                }
+                const normalized = new UnraidClientError(timedOut ? "timeout" : "transport", timedOut ? "Unraid GraphQL request timed out" : "Unraid GraphQL transport failed", kind === "mutation" && !timedOut, { cause: error });
+                this.emitError(kind, normalized);
+                throw normalized;
+            }
+            if (!response.ok) {
+                if (kind === "read" && [429, 502, 503, 504].includes(response.status) && attempt < maxAttempts - 1) {
+                    await this.sleep(delays[attempt]);
+                    continue;
+                }
+                const error = statusError(response.status);
+                this.emitError(kind, error);
+                throw error;
+            }
+            let envelope;
+            try {
+                envelope = await response.json();
+            }
+            catch (cause) {
+                const error = new UnraidClientError("invalid_response", "Unraid GraphQL returned invalid JSON", false, { cause });
+                this.emitError(kind, error);
+                throw error;
+            }
+            if (!envelope || typeof envelope !== "object" || Array.isArray(envelope)) {
+                const error = new UnraidClientError("invalid_response", "Unraid GraphQL response envelope is invalid");
+                this.emitError(kind, error);
+                throw error;
+            }
+            const record = envelope;
+            if (Array.isArray(record.errors) && record.errors.length > 0) {
+                const error = new UnraidClientError("graphql", "Unraid GraphQL operation failed");
+                this.emitError(kind, error);
+                throw error;
+            }
+            if (!record.data || typeof record.data !== "object" || Array.isArray(record.data)) {
+                const error = new UnraidClientError("invalid_response", "Unraid GraphQL response omitted data");
+                this.emitError(kind, error);
+                throw error;
+            }
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.unraid_request_end",
+                message: "Unraid GraphQL request completed",
+                meta: { kind, attempt: attempt + 1 },
+            });
+            return record.data;
+        }
+    }
+    emitError(kind, error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "repertoire",
+            event: "repertoire.unraid_request_error",
+            message: "Unraid GraphQL request failed",
+            meta: { kind, code: error.code, ambiguous: error.ambiguous },
+        });
+    }
+}
+exports.UnraidClient = UnraidClient;