@ornncompute/cli 1.0.72 → 1.0.97

package/vendor/capabilities/capabilities/evidence.js

@@ -1,145 +0,0 @@
-import { z } from "zod";
-import { defineCapability, } from "../capability.js";
-const positionals = z.array(z.string()).default([]);
-export const evidenceInput = z
-    .object({
-    $positionals: positionals,
-    before: z.string().optional(),
-    count: z.string().optional(),
-    cursor: z.string().optional(),
-    end: z.string().optional(),
-    follow: z.boolean().optional(),
-    guided: z.boolean().optional(),
-    interval: z.string().optional(),
-    limit: z.string().optional(),
-    maxPoints: z.string().optional(),
-    start: z.string().optional(),
-    stream: z.enum(["kernel", "serial"]).optional(),
-    timeout: z.string().optional(),
-})
-    .strict();
-function runtime(context) {
-    const interaction = context.cli?.interaction;
-    if (!interaction?.evidence)
-        throw new Error("The CLI evidence runtime is unavailable.");
-    return interaction;
-}
-function execute(command) {
-    return (context, input) => runtime(context).evidence(command, input, context);
-}
-function cliOnly({ automation, category, command, description, human, id, order, outcome, references, related, }) {
-    const executor = command.length === 1 ? "check" : `${command[0]}.${command[1]}`;
-    return defineCapability({
-        id,
-        domain: "observability",
-        roles: ["user"],
-        description,
-        mutation: "read",
-        input: evidenceInput,
-        cli: {
-            command,
-            vnext: {
-                arguments: "semantic",
-                audience: "customer",
-                category,
-                order,
-                outcome,
-                human,
-                automation,
-                acceptedReferences: references,
-                resumableStates: ["no data", "unavailable", "streaming", "ended", "interrupted"],
-                related,
-            },
-        },
-        mcp: false,
-        slack: false,
-        execute: execute(executor),
-    });
-}
-export const checkCapability = cliOnly({
-    id: "evidence.check",
-    command: ["check"],
-    category: "journey",
-    order: 4,
-    description: "Compose lifecycle, reachability, authoritative health, metrics, and logs for one machine or cluster.",
-    outcome: "Check one exact machine or cluster without turning missing evidence into health.",
-    human: "ornn check [<canonical-resource-id-or-exact-hostname>] [--follow] [--start <time> --end <time>]",
-    automation: "ornn check <canonical-machine-or-cluster-id> --start <time> --end <time> --max-points 240 --limit 200 --format json",
-    references: [
-        "canonical machine ID",
-        "exact unique machine hostname",
-        "canonical cluster ID",
-        "invocation-local guided choice",
-    ],
-    related: [
-        "connect",
-        "machines metrics",
-        "machines logs",
-        "clusters metrics",
-        "clusters logs",
-        "cost",
-    ],
-});
-export const machineMetricsCapability = cliOnly({
-    id: "evidence.machine_metrics",
-    command: ["machines", "metrics"],
-    category: "resource",
-    order: 560,
-    description: "Read or follow bounded customer-safe metrics for one exact machine.",
-    outcome: "Return normalized machine metrics with explicit evidence state and window.",
-    human: "ornn machines metrics [<machine-id-or-exact-hostname>] [--guided] [--start <time> --end <time>] [--max-points <1-500>] [--follow]",
-    automation: "ornn machines metrics <canonical-machine-id> --start <time> --end <time> --max-points 240 --format json",
-    references: [
-        "canonical machine ID",
-        "exact unique machine hostname",
-        "invocation-local guided choice",
-    ],
-    related: ["check", "machines logs"],
-});
-export const machineLogsCapability = cliOnly({
-    id: "evidence.machine_logs",
-    command: ["machines", "logs"],
-    category: "resource",
-    order: 561,
-    description: "Read or follow bounded customer-safe kernel or serial logs for one exact machine.",
-    outcome: "Return normalized machine logs with opaque pagination and unsafe lines omitted.",
-    human: "ornn machines logs [<machine-id-or-exact-hostname>] [--guided] [--stream kernel|serial] [--limit <1-500>] [--cursor <cursor>] [--follow]",
-    automation: "ornn machines logs <canonical-machine-id> --stream kernel --limit 200 --format json",
-    references: [
-        "canonical machine ID",
-        "exact unique machine hostname",
-        "invocation-local guided choice",
-    ],
-    related: ["check", "machines metrics"],
-});
-export const clusterMetricsCapability = cliOnly({
-    id: "evidence.cluster_metrics",
-    command: ["clusters", "metrics"],
-    category: "resource",
-    order: 562,
-    description: "Read or follow bounded customer-safe metrics for every member of one exact cluster.",
-    outcome: "Return normalized per-machine cluster metrics without changing cluster health.",
-    human: "ornn clusters metrics [<cluster-id>] [--guided] [--start <time> --end <time>] [--max-points <1-500>] [--follow]",
-    automation: "ornn clusters metrics <canonical-cluster-id> --start <time> --end <time> --max-points 240 --format json",
-    references: ["canonical cluster ID", "invocation-local guided choice"],
-    related: ["check", "clusters logs"],
-});
-export const clusterLogsCapability = cliOnly({
-    id: "evidence.cluster_logs",
-    command: ["clusters", "logs"],
-    category: "resource",
-    order: 563,
-    description: "Read or follow bounded customer-safe logs for every member of one exact cluster.",
-    outcome: "Return normalized per-machine cluster logs without exposing staff or supplier details.",
-    human: "ornn clusters logs [<cluster-id>] [--guided] [--stream kernel|serial] [--limit <1-500>] [--follow]",
-    automation: "ornn clusters logs <canonical-cluster-id> --stream kernel --limit 200 --format json",
-    references: ["canonical cluster ID", "invocation-local guided choice"],
-    related: ["check", "clusters metrics"],
-});
-export const evidenceCapabilities = [
-    checkCapability,
-    machineMetricsCapability,
-    machineLogsCapability,
-    clusterMetricsCapability,
-    clusterLogsCapability,
-];

package/vendor/capabilities/capabilities/external-buckets.js

@@ -1,191 +0,0 @@
-import { z } from "zod";
-import { defineCapability, } from "../capability.js";
-const pageInput = z
-    .object({
-    $positionals: z.array(z.string()).optional(),
-    cursor: z.string().optional(),
-    limit: z.union([z.string(), z.number()]).optional(),
-})
-    .strict();
-const showInput = z
-    .object({
-    $positionals: z.array(z.string()).optional(),
-})
-    .strict();
-const verificationInput = z
-    .object({
-    $positionals: z.array(z.string()).optional(),
-    idempotencyKey: z.string().optional(),
-})
-    .strict();
-const disconnectInput = z
-    .object({
-    $positionals: z.array(z.string()).optional(),
-    idempotencyKey: z.string().optional(),
-    yes: z.boolean().optional(),
-})
-    .strict();
-const connectInput = z
-    .object({
-    $positionals: z.array(z.string()).optional(),
-    accessKeyId: z.string().optional(),
-    accountId: z.string().optional(),
-    bucket: z.string().optional(),
-    endpointUrl: z.string().optional(),
-    idempotencyKey: z.string().optional(),
-    name: z.string().optional(),
-    prefix: z.string().optional(),
-    readOnly: z.boolean().optional(),
-    readWrite: z.boolean().optional(),
-    region: z.string().optional(),
-    secretAccessKeyFile: z.string().optional(),
-    url: z.string().optional(),
-    yes: z.boolean().optional(),
-})
-    .strict();
-const credentialInput = z
-    .object({
-    $positionals: z.array(z.string()).optional(),
-    accessKeyId: z.string().optional(),
-    idempotencyKey: z.string().optional(),
-    secretAccessKeyFile: z.string().optional(),
-    yes: z.boolean().optional(),
-})
-    .strict();
-const importInput = z
-    .object({
-    $positionals: z.array(z.string()).optional(),
-    idempotencyKey: z.string().optional(),
-    noWait: z.boolean().optional(),
-    reservation: z.string().optional(),
-    timeout: z.string().optional(),
-    wait: z.boolean().optional(),
-    yes: z.boolean().optional(),
-})
-    .strict();
-function externalBucketExecutor(context) {
-    const interaction = context.cli?.interaction;
-    if (!interaction?.externalBuckets) {
-        throw new Error("This capability must execute through the Ornn CLI external-bucket runtime.");
-    }
-    return interaction.externalBuckets.bind(interaction);
-}
-function externalBucketCapability({ acceptedReferences = [], automation, command, description, human, id, input, mutation, outcome, related = [], resumableStates = [], review, }) {
-    return defineCapability({
-        id,
-        domain: "storage",
-        roles: ["user"],
-        description,
-        mutation,
-        input,
-        cli: {
-            command,
-            vnext: {
-                arguments: "semantic",
-                audience: "customer",
-                category: "resource",
-                outcome,
-                human,
-                automation,
-                acceptedReferences,
-                related,
-                resumableStates,
-                ...(review ? { review } : {}),
-            },
-        },
-        mcp: false,
-        slack: false,
-        execute: async (context, commandInput) => externalBucketExecutor(context)(id, commandInput),
-    });
-}
-const gcsImportGuidance = "GCS requires bucket-level read access for Ornn's Storage Transfer service agent, granted with gcloud. CLI 1.x GCS imports are currently blocked by unavailable source verification. Setup and version-specific steps: https://docs.ornn.com/cli#gcs-imports-and-storage-transfer-service";
-export const externalBucketCapabilities = [
-    externalBucketCapability({
-        id: "storage.external-buckets.list",
-        command: ["external-buckets", "list"],
-        description: "List connected GCS, S3, and R2 buckets in one bounded page.",
-        mutation: "read",
-        input: pageInput,
-        outcome: "List external bucket connections without exposing stored credentials.",
-        human: "ornn external-buckets list [--limit <1-100>] [--cursor <cursor>]",
-        automation: "ornn external-buckets list --limit 50 --format json",
-        related: ["external-buckets show", "external-buckets connect"],
-    }),
-    externalBucketCapability({
-        id: "storage.external-buckets.show",
-        command: ["external-buckets", "show"],
-        description: "Inspect one connected external bucket by canonical ID or exact unique name.",
-        mutation: "read",
-        input: showInput,
-        outcome: "Inspect one credential-safe external bucket connection.",
-        human: "ornn external-buckets show <external-bucket>",
-        automation: "ornn external-buckets show <external-bucket-id> --format json",
-        acceptedReferences: ["canonical external bucket ID", "exact unique external bucket name"],
-        related: ["external-buckets verify", "external-buckets import"],
-    }),
-    externalBucketCapability({
-        id: "storage.external-buckets.connect",
-        command: ["external-buckets", "connect"],
-        description: "Connect a typed GCS, AWS S3, or Cloudflare R2 source without verifying it implicitly.",
-        mutation: "preview-confirm",
-        input: connectInput,
-        outcome: "Create or rediscover one external bucket connection with verification kept separate.",
-        human: "ornn external-buckets connect <gcs|s3|r2> --bucket <bucket> [--name <name>] [--prefix <prefix>] [--region <region>] [--account-id <id>|--endpoint-url <url>] [--access-key-id <id> --secret-access-key-file <path>] [--read-only|--read-write]",
-        automation: "ornn external-buckets connect <gcs|s3|r2> --bucket <bucket> <provider-inputs> --yes --idempotency-key <key> --format json",
-        review: `Review the exact source, access mode, and credential presence before connecting it. ${gcsImportGuidance}`,
-        related: ["external-buckets verify", "external-buckets import"],
-    }),
-    externalBucketCapability({
-        id: "storage.external-buckets.update-credentials",
-        command: ["external-buckets", "update-credentials"],
-        description: "Replace scoped S3 or R2 credentials without returning credential bytes.",
-        mutation: "preview-confirm",
-        input: credentialInput,
-        outcome: "Update one connection's credentials and require a separate verification.",
-        human: "ornn external-buckets update-credentials <external-bucket> --access-key-id <id> --secret-access-key-file <path>",
-        automation: "ornn external-buckets update-credentials <external-bucket-id> --access-key-id <id> --secret-access-key-file <path> --yes --idempotency-key <key> --format json",
-        acceptedReferences: ["canonical external bucket ID", "exact unique external bucket name"],
-        review: "Credential changes invalidate the prior verification and require renewed review.",
-        related: ["external-buckets verify"],
-    }),
-    externalBucketCapability({
-        id: "storage.external-buckets.verify",
-        command: ["external-buckets", "verify"],
-        description: "Verify current S3 or R2 source access as a separate operation.",
-        mutation: "preview-confirm",
-        input: verificationInput,
-        outcome: "Record current source-access verification without exposing credential material.",
-        human: "ornn external-buckets verify <external-bucket>",
-        automation: "ornn external-buckets verify <external-bucket-id> --idempotency-key <key> --format json",
-        acceptedReferences: ["canonical external bucket ID", "exact unique external bucket name"],
-        review: gcsImportGuidance,
-        related: ["external-buckets import", "external-buckets update-credentials"],
-    }),
-    externalBucketCapability({
-        id: "storage.external-buckets.import",
-        command: ["external-buckets", "import"],
-        description: "Import a verified GCS or S3 source into its isolated managed working volume.",
-        mutation: "preview-confirm",
-        input: importInput,
-        outcome: "Create or replay exactly one managed working copy with source writeback disabled.",
-        human: "ornn external-buckets import <gcs|s3|r2> <external-bucket> --reservation <canonical-reservation-id> [--no-wait] [--timeout <duration>]",
-        automation: "ornn external-buckets import <gcs|s3> <external-bucket-id> --reservation <canonical-reservation-id> --yes --idempotency-key <key> [--wait --timeout <duration>] --format json",
-        acceptedReferences: ["canonical external bucket ID", "exact unique external bucket name"],
-        review: `Review the isolated destination and explicit no-writeback guarantee before importing. ${gcsImportGuidance}`,
-        resumableStates: ["pending", "working", "partial", "failed", "interrupted"],
-        related: ["external-buckets show", "storage status", "volumes files list"],
-    }),
-    externalBucketCapability({
-        id: "storage.external-buckets.disconnect",
-        command: ["external-buckets", "disconnect"],
-        description: "Disconnect an external bucket record after its working volume is detached.",
-        mutation: "preview-confirm",
-        input: disconnectInput,
-        outcome: "Remove one external source connection without writing to its source bucket.",
-        human: "ornn external-buckets disconnect <external-bucket>",
-        automation: "ornn external-buckets disconnect <external-bucket-id> --yes --idempotency-key <key> --format json",
-        acceptedReferences: ["canonical external bucket ID", "exact unique external bucket name"],
-        review: "Disconnecting reduces access to the source and is blocked while mounts remain.",
-        related: ["storage detach", "external-buckets show"],
-    }),
-];

package/vendor/capabilities/capabilities/fleet.js

@@ -1,306 +0,0 @@
-import { listSupplierOrganizations, listSupplierOrganizationPage } from "../supplier-directory.js";
-import { z } from "zod";
-import { defineCapability, preview } from "../capability.js";
-function queryPath(path, params) {
-    const parts = [];
-    for (const [key, value] of Object.entries(params)) {
-        if (value?.trim())
-            parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(value.trim())}`);
-    }
-    return parts.length ? `${path}?${parts.join("&")}` : path;
-}
-const emptyInput = z.object({});
-const suppliersInput = z.object({
-    q: z.string().optional(),
-    offset: z.number().int().min(0).optional(),
-    limit: z.number().int().min(1).max(1000).optional(),
-});
-const facilitiesInput = z.object({
-    organization_id: z.string().optional(),
-    organizationId: z.string().optional(),
-    cursor: z.string().optional(),
-    limit: z.number().int().min(1).max(500).optional(),
-});
-const nodesInput = z.object({
-    organization_id: z.string().optional(),
-    organizationId: z.string().optional(),
-    facility_id: z.string().optional(),
-    facilityId: z.string().optional(),
-    status: z.string().optional(),
-    reservation_id: z.string().optional(),
-    reservationId: z.string().optional(),
-    cursor: z.string().optional(),
-    max: z.number().int().positive().max(5000).optional(),
-    limit: z.number().int().positive().max(5000).optional(),
-});
-const nodeLifecycleInput = z.object({
-    node_id: z.string().min(1),
-    nodeId: z.string().optional(),
-    reason: z.string().optional(),
-    force: z.boolean().optional(),
-});
-const nodeExecInput = z.object({
-    node_id: z.string().min(1),
-    nodeId: z.string().optional(),
-    command: z.string().min(1),
-    timeout_seconds: z.number().int().positive(),
-    timeoutSeconds: z.number().int().positive().optional(),
-    yes: z.boolean().optional(),
-});
-function nodeIdOf(input) {
-    return (input.node_id || input.nodeId || "").trim();
-}
-export const listSuppliersCapability = defineCapability({
-    id: "supplier.list",
-    domain: "fleet",
-    roles: ["admin"],
-    description: "List supplier organizations (id, name). Resolve supplier names to organization_id with this before nodes.list or facilities.list.",
-    mutation: "read",
-    http: { method: "GET", path: "/v1/organizations" },
-    slack: {
-        parameters: {
-            type: "object",
-            properties: {
-                q: { type: "string", description: "Search supplier names." },
-                offset: { type: "integer", description: "Use next_offset to fetch another page." },
-                limit: { type: "integer", description: "Page size (Slack maximum 10)." },
-            },
-        },
-    },
-    input: suppliersInput,
-    execute: async (ctx, input) => {
-        const parsed = suppliersInput.parse(input);
-        const paged = parsed.limit !== undefined || parsed.offset !== undefined || parsed.q !== undefined;
-        const limit = parsed.limit ?? 25;
-        const offset = parsed.offset ?? 0;
-        const rows = paged
-            ? await listSupplierOrganizationPage(ctx.fetch, { ...parsed, limit, offset })
-            : await listSupplierOrganizations(ctx.fetch);
-        return {
-            suppliers: rows.map((org) => ({ id: org.id, name: org.name })),
-            ...(paged && rows.length === limit ? { next_offset: offset + rows.length } : {}),
-        };
-    },
-});
-export const listFacilitiesCapability = defineCapability({
-    id: "facilities.list",
-    domain: "fleet",
-    roles: ["admin"],
-    description: "List facilities (id, display name, region, supplier organization id). Optional organization_id filter. Resolve facility names with this before nodes.list.",
-    mutation: "read",
-    http: { method: "GET", path: "/provisioning/facilities" },
-    slack: {
-        parameters: {
-            type: "object",
-            properties: {
-                organization_id: {
-                    type: "string",
-                    description: "Optional supplier organization UUID from supplier.list.",
-                },
-            },
-        },
-    },
-    input: facilitiesInput,
-    execute: async (ctx, input) => {
-        const parsed = facilitiesInput.parse(input);
-        return ctx.fetch(queryPath("/provisioning/facilities", {
-            organizationId: parsed.organization_id ?? parsed.organizationId,
-            cursor: parsed.cursor,
-            limit: parsed.limit === undefined ? undefined : String(parsed.limit),
-        }), { method: "GET" });
-    },
-});
-export const listNodesCapability = defineCapability({
-    id: "nodes.list",
-    domain: "fleet",
-    roles: ["user", "admin"],
-    description: "List nodes. Users see their own reserved machines. Admins see enrolled, ghost, and off-grid nodes. Call with no filters for the whole fleet. Optional reservation_id lists the nodes on one reservation (find a customer's reservations with reservation.list customerId). Optional organization_id (supplier), facility_id, and status (ghost, off-grid, bare-metal) narrow the same list. Paginate large fleets with cursor + max: pass the response's next_cursor back as cursor to fetch the next page; next_cursor is omitted once the page is not full. Never invent nodes. Never print private keys.",
-    mutation: "read",
-    http: { method: "GET", path: "/nodes" },
-    slack: {
-        parameters: {
-            type: "object",
-            properties: {
-                organization_id: {
-                    type: "string",
-                    description: "Optional supplier organization UUID from supplier.list.",
-                },
-                facility_id: {
-                    type: "string",
-                    description: "Optional commerce facility UUID from facilities.list.",
-                },
-                reservation_id: {
-                    type: "string",
-                    description: "Optional reservation UUID from reservation_list. Lists that reservation's nodes.",
-                },
-                status: {
-                    type: "string",
-                    enum: ["ghost", "off-grid", "bare-metal"],
-                    description: "Optional orchestrator status filter. Default is all statuses.",
-                },
-                cursor: {
-                    type: "string",
-                    description: "Optional. Pass the previous response's next_cursor to fetch the next page.",
-                },
-                max: {
-                    type: "integer",
-                    description: "Optional page size (1-5000). Orchestrator default is 500.",
-                },
-            },
-        },
-    },
-    input: nodesInput,
-    execute: async (ctx, input) => {
-        const parsed = nodesInput.parse(input);
-        const pagination = {
-            cursor: parsed.cursor,
-            limit: parsed.max != null || parsed.limit != null ? String(parsed.max ?? parsed.limit) : undefined,
-        };
-        if (ctx.role === "user") {
-            return ctx.fetch(queryPath("/nodes", pagination), { method: "GET" });
-        }
-        return ctx.fetch(queryPath("/nodes", {
-            organization_id: parsed.organization_id ?? parsed.organizationId,
-            facility_id: parsed.facility_id ?? parsed.facilityId,
-            status: parsed.status,
-            reservation_id: parsed.reservation_id ?? parsed.reservationId,
-            ...pagination,
-        }), { method: "GET" });
-    },
-});
-export const nodeOffGridCapability = defineCapability({
-    id: "node.off-grid",
-    domain: "fleet",
-    roles: ["admin"],
-    description: "Admin-only. Take a node off-grid (remove Ornn agent management, leave the host powered on). CLI asks y/N. Slack waits for a human confirm. MCP requires confirm: true.",
-    mutation: "preview-confirm",
-    http: { method: "POST", path: "/nodes/{id}/off-grid" },
-    slack: {
-        parameters: {
-            type: "object",
-            properties: {
-                node_id: { type: "string", description: "Node UUID from nodes.list." },
-                reason: { type: "string" },
-            },
-            required: ["node_id"],
-        },
-    },
-    input: nodeLifecycleInput,
-    execute: async (ctx, input) => {
-        const parsed = nodeLifecycleInput.parse(input);
-        const id = nodeIdOf(parsed);
-        const body = { ...(parsed.reason ? { reason: parsed.reason } : {}) };
-        if (!ctx.confirmed) {
-            return preview("node.off-grid", { node_id: id, ...body });
-        }
-        return ctx.fetch(`/nodes/${encodeURIComponent(id)}/off-grid`, {
-            method: "POST",
-            body,
-        });
-    },
-});
-export const nodeOnGridCapability = defineCapability({
-    id: "node.on-grid",
-    domain: "fleet",
-    roles: ["admin"],
-    description: "Admin-only. Re-enroll an off-grid node: orchestrator SSHs with the stored admin key and runs the installer with restore_node_id. No caller key. CLI asks y/N. Slack waits for a human confirm. MCP requires confirm: true.",
-    mutation: "preview-confirm",
-    http: { method: "POST", path: "/nodes/{id}/on-grid" },
-    slack: {
-        parameters: {
-            type: "object",
-            properties: {
-                node_id: { type: "string", description: "Off-grid node UUID from nodes.list." },
-            },
-            required: ["node_id"],
-        },
-    },
-    input: nodeLifecycleInput,
-    execute: async (ctx, input) => {
-        const parsed = nodeLifecycleInput.parse(input);
-        const id = nodeIdOf(parsed);
-        if (!ctx.confirmed) {
-            return preview("node.on-grid", { node_id: id });
-        }
-        return ctx.fetch(`/nodes/${encodeURIComponent(id)}/on-grid`, {
-            method: "POST",
-            body: {},
-        });
-    },
-});
-export const nodeExecCapability = defineCapability({
-    id: "node.exec",
-    domain: "fleet",
-    roles: ["admin"],
-    description: "Admin-only. Run one unrestricted command on an enrolled node over orchestrator SSH with the stored admin key. Always pass timeout_seconds. Not an interactive shell. On NVIDIA hosts use nvidia-smi; on AMD Instinct use amd-smi. Runs on the tool call — no confirm, no y/N.",
-    mutation: "read",
-    http: { method: "POST", path: "/remote" },
-    slack: {
-        parameters: {
-            type: "object",
-            properties: {
-                node_id: { type: "string", description: "Enrolled node UUID from nodes.list." },
-                command: { type: "string", description: "Exact shell command to run. No allowlist." },
-                timeout_seconds: {
-                    type: "integer",
-                    description: "Seconds to wait before killing the SSH command. Required. 1-900.",
-                },
-            },
-            required: ["node_id", "command", "timeout_seconds"],
-        },
-    },
-    input: nodeExecInput,
-    execute: async (ctx, input) => {
-        const parsed = nodeExecInput.parse(input);
-        const id = nodeIdOf(parsed);
-        const timeoutSeconds = parsed.timeout_seconds ?? parsed.timeoutSeconds;
-        return ctx.fetch("/remote", {
-            method: "POST",
-            body: { node_id: id, command: parsed.command, timeout_seconds: timeoutSeconds },
-        });
-    },
-});
-export const nodeTerminateCapability = defineCapability({
-    id: "node.terminate",
-    domain: "fleet",
-    roles: ["admin"],
-    description: "Admin-only. Terminate a node record (best-effort clean + delete). Off-grid nodes need force: true. There is no deenroll verb. CLI asks y/N. Slack waits for a human confirm. MCP requires confirm: true.",
-    mutation: "preview-confirm",
-    http: { method: "POST", path: "/nodes/{id}/terminate" },
-    slack: {
-        parameters: {
-            type: "object",
-            properties: {
-                node_id: { type: "string", description: "Node UUID from nodes.list." },
-                reason: { type: "string" },
-                force: { type: "boolean", description: "Required to delete an off-grid node." },
-            },
-            required: ["node_id"],
-        },
-    },
-    input: nodeLifecycleInput,
-    execute: async (ctx, input) => {
-        const parsed = nodeLifecycleInput.parse(input);
-        const id = nodeIdOf(parsed);
-        const body = {
-            ...(parsed.reason ? { reason: parsed.reason } : {}),
-            ...(parsed.force !== undefined ? { force: parsed.force } : {}),
-        };
-        if (!ctx.confirmed) {
-            return preview("node.terminate", { node_id: id, ...body });
-        }
-        return ctx.fetch(`/nodes/${encodeURIComponent(id)}/terminate`, {
-            method: "POST",
-            body,
-        });
-    },
-});
-export const fleetCapabilities = [
-    listSuppliersCapability,
-    listFacilitiesCapability,
-    listNodesCapability,
-    nodeOffGridCapability,
-    nodeOnGridCapability,
-    nodeExecCapability,
-    nodeTerminateCapability,
-];