@ornncompute/cli 1.0.72 → 1.0.97

package/vendor/capabilities/capabilities/admin-nodes-lifecycle.js

@@ -1,235 +0,0 @@
-import { z } from "zod";
-import { defineCapability } from "../capability.js";
-const nodeReference = z.string().trim().min(1);
-const optionalText = z.string().trim().min(1).optional();
-const commonInput = {
-    node_ref: nodeReference,
-    node_id: optionalText,
-    idempotency_key: optionalText,
-    reason: optionalText,
-    yes: z.boolean().optional(),
-    wait: z.boolean().optional(),
-    timeout_seconds: z.number().positive().optional(),
-};
-const rebootInput = z.object({
-    ...commonInput,
-    machine_id: optionalText,
-});
-const hardResetInput = rebootInput.extend({
-    erase_local_data: z.literal(true),
-});
-const terminationInput = z.object({
-    ...commonInput,
-    delete_node_record: z.literal(true),
-    skip_cleanup: z.boolean().optional(),
-});
-const assignmentInput = z.object({
-    ...commonInput,
-    reservation_id: z.string().trim().min(1),
-});
-const managementInput = z.object(commonInput);
-function adminLifecycleHelp(command, outcome, human, automation, review) {
-    return {
-        audience: "admin",
-        category: "resource",
-        command,
-        outcome,
-        human,
-        automation,
-        acceptedReferences: ["canonical node ID", "exact unique node hostname in an eligible terminal"],
-        review,
-        resumableStates: ["accepted", "pending", "timed out", "interrupted"],
-        related: ["admin nodes health", "admin nodes list"],
-    };
-}
-function nodeId(input) {
-    if (!input.node_id)
-        throw new Error("The lifecycle target must be resolved before execution.");
-    return input.node_id;
-}
-function requestHeaders(idempotencyKey) {
-    return idempotencyKey ? { "Idempotency-Key": idempotencyKey } : undefined;
-}
-function preview(action, payload) {
-    return { ok: true, action, payload };
-}
-async function reboot(ctx, input, mode) {
-    const parsed = mode === "hard_reset" ? hardResetInput.parse(input) : rebootInput.parse(input);
-    const payload = {
-        node_id: parsed.node_id,
-        machine_id: parsed.machine_id,
-        mode,
-        ...(mode === "hard_reset" ? { erase_local_data: true } : {}),
-    };
-    if (!ctx.confirmed)
-        return preview(`nodes.${mode}`, payload);
-    if (!parsed.machine_id)
-        throw new Error("The live machine target must be resolved before reboot.");
-    return ctx.fetch(`/nodes/${encodeURIComponent(parsed.machine_id)}/reboot`, {
-        method: "POST",
-        body: {
-            mode,
-            ...(parsed.idempotency_key ? { request_id: parsed.idempotency_key } : {}),
-        },
-        headers: requestHeaders(parsed.idempotency_key),
-    });
-}
-export const adminNodeRebootCapability = defineCapability({
-    id: "nodes.reboot",
-    domain: "fleet",
-    roles: ["admin"],
-    description: "Reboot the exact live machine backing one managed node after a normalized review.",
-    mutation: "preview-confirm",
-    http: { method: "POST", path: "/nodes/{id}/reboot" },
-    cli: {
-        command: ["admin", "nodes", "reboot"],
-        vnext: adminLifecycleHelp(["admin", "nodes", "reboot"], "Reboot one exact live machine while preserving local data and access configuration.", "ornn admin nodes reboot <node-ref> [--yes] [--no-wait] [--timeout SECONDS]", "Unsupported: reboot requires an eligible human terminal.", "Node and live-machine identities, supplier, facility, capacity assignment, and preserved access."),
-    },
-    mcp: false,
-    slack: false,
-    input: rebootInput,
-    execute: (ctx, input) => reboot(ctx, input, "reboot"),
-});
-export const adminNodeHardResetCapability = defineCapability({
-    id: "nodes.hard_reset",
-    domain: "fleet",
-    roles: ["admin"],
-    description: "Hard reset the exact live machine backing one node with explicit local-data erasure scope.",
-    mutation: "preview-confirm",
-    http: { method: "POST", path: "/nodes/{id}/reboot" },
-    cli: {
-        command: ["admin", "nodes", "hard-reset"],
-        vnext: adminLifecycleHelp(["admin", "nodes", "hard-reset"], "Erase local tenant data and hard reset one exact live machine.", "ornn admin nodes hard-reset <node-ref> --erase-local-data [--yes] [--no-wait] [--timeout SECONDS]", "Unsupported: hard reset requires an eligible human terminal.", "Node and live-machine identities, supplier, facility, capacity assignment, erased local data, and restored keys."),
-    },
-    mcp: false,
-    slack: false,
-    input: hardResetInput,
-    execute: (ctx, input) => reboot(ctx, input, "hard_reset"),
-});
-export const adminNodeSuspendManagementCapability = defineCapability({
-    id: "nodes.suspend_management",
-    domain: "fleet",
-    roles: ["admin"],
-    description: "Suspend Ornn management while leaving the exact host powered on.",
-    mutation: "preview-confirm",
-    http: { method: "POST", path: "/nodes/{id}/off-grid" },
-    cli: {
-        command: ["admin", "nodes", "suspend-management"],
-        vnext: adminLifecycleHelp(["admin", "nodes", "suspend-management"], "Remove Ornn management and managed access from one powered-on node.", "ornn admin nodes suspend-management <node-ref> [--reason TEXT] [--yes] [--no-wait]", "ornn admin nodes suspend-management <node-id> --yes --idempotency-key KEY --format json", "Node, supplier, facility, capacity assignment, management removal, and managed-access loss."),
-    },
-    mcp: false,
-    slack: false,
-    input: managementInput,
-    execute: async (ctx, input) => {
-        const parsed = managementInput.parse(input);
-        const id = nodeId(parsed);
-        const body = {
-            ...(parsed.idempotency_key ? { request_id: parsed.idempotency_key } : {}),
-            ...(parsed.reason ? { reason: parsed.reason } : {}),
-        };
-        if (!ctx.confirmed)
-            return preview("nodes.suspend_management", { node_id: id, ...body });
-        return ctx.fetch(`/nodes/${encodeURIComponent(id)}/off-grid`, {
-            method: "POST",
-            body,
-            headers: requestHeaders(parsed.idempotency_key),
-        });
-    },
-});
-export const adminNodeResumeManagementCapability = defineCapability({
-    id: "nodes.resume_management",
-    domain: "fleet",
-    roles: ["admin"],
-    description: "Resume Ornn management for one exact off-grid node.",
-    mutation: "preview-confirm",
-    http: { method: "POST", path: "/nodes/{id}/on-grid" },
-    cli: {
-        command: ["admin", "nodes", "resume-management"],
-        vnext: adminLifecycleHelp(["admin", "nodes", "resume-management"], "Restore Ornn management and managed access on one off-grid node.", "ornn admin nodes resume-management <node-ref> [--yes] [--no-wait]", "ornn admin nodes resume-management <node-id> --yes --idempotency-key KEY --format json", "Node, supplier, facility, capacity assignment, remote re-enrollment, and restored managed access."),
-    },
-    mcp: false,
-    slack: false,
-    input: managementInput,
-    execute: async (ctx, input) => {
-        const parsed = managementInput.parse(input);
-        const id = nodeId(parsed);
-        if (!ctx.confirmed)
-            return preview("nodes.resume_management", { node_id: id });
-        return ctx.fetch(`/nodes/${encodeURIComponent(id)}/on-grid`, {
-            method: "POST",
-            body: {
-                ...(parsed.idempotency_key ? { request_id: parsed.idempotency_key } : {}),
-            },
-            headers: requestHeaders(parsed.idempotency_key),
-        });
-    },
-});
-export const adminNodeTerminateCapability = defineCapability({
-    id: "nodes.terminate",
-    domain: "fleet",
-    roles: ["admin"],
-    description: "Delete one exact node record with explicit cleanup scope and consequence review.",
-    mutation: "preview-confirm",
-    http: { method: "POST", path: "/nodes/{id}/terminate" },
-    cli: {
-        command: ["admin", "nodes", "terminate"],
-        vnext: adminLifecycleHelp(["admin", "nodes", "terminate"], "End managed access and permanently delete one exact node record.", "ornn admin nodes terminate <node-ref> --delete-node-record [--skip-cleanup] [--reason TEXT] [--yes]", "ornn admin nodes terminate <node-id> --delete-node-record --yes --idempotency-key KEY --format json", "Node, supplier, facility, reservation/capacity, host cleanup, node-record deletion, and access loss."),
-    },
-    mcp: false,
-    slack: false,
-    input: terminationInput,
-    execute: async (ctx, input) => {
-        const parsed = terminationInput.parse(input);
-        const id = nodeId(parsed);
-        const body = {
-            force: parsed.skip_cleanup === true,
-            ...(parsed.idempotency_key ? { request_id: parsed.idempotency_key } : {}),
-            ...(parsed.reason ? { reason: parsed.reason } : {}),
-        };
-        if (!ctx.confirmed)
-            return preview("nodes.terminate", { node_id: id, ...body });
-        return ctx.fetch(`/nodes/${encodeURIComponent(id)}/terminate`, {
-            method: "POST",
-            body,
-            headers: requestHeaders(parsed.idempotency_key),
-        });
-    },
-});
-export const adminNodeAssignCapability = defineCapability({
-    id: "nodes.assign",
-    domain: "fleet",
-    roles: ["admin"],
-    description: "Assign one exact node to one exact capacity reservation after consequence review.",
-    mutation: "preview-confirm",
-    http: { method: "POST", path: "/nodes/{id}/assign" },
-    cli: {
-        command: ["admin", "nodes", "assign"],
-        vnext: adminLifecycleHelp(["admin", "nodes", "assign"], "Assign one exact node to one exact capacity reservation.", "ornn admin nodes assign <node-ref> --reservation <reservation-id> [--yes] [--no-wait]", "ornn admin nodes assign <node-id> --reservation <reservation-id> --yes --idempotency-key KEY --format json", "Node, supplier, facility, previous and requested capacity assignments, and tenant access change."),
-    },
-    mcp: false,
-    slack: false,
-    input: assignmentInput,
-    execute: async (ctx, input) => {
-        const parsed = assignmentInput.parse(input);
-        const id = nodeId(parsed);
-        const body = {
-            reservation_id: parsed.reservation_id,
-            ...(parsed.idempotency_key ? { request_id: parsed.idempotency_key } : {}),
-        };
-        if (!ctx.confirmed)
-            return preview("nodes.assign", { node_id: id, ...body });
-        return ctx.fetch(`/nodes/${encodeURIComponent(id)}/assign`, {
-            method: "POST",
-            body,
-            headers: requestHeaders(parsed.idempotency_key),
-        });
-    },
-});
-export const adminNodeLifecycleCapabilities = [
-    adminNodeRebootCapability,
-    adminNodeHardResetCapability,
-    adminNodeSuspendManagementCapability,
-    adminNodeResumeManagementCapability,
-    adminNodeTerminateCapability,
-    adminNodeAssignCapability,
-];

package/vendor/capabilities/capabilities/admin.js

@@ -1,91 +0,0 @@
-import { z } from "zod";
-import { defineCapability } from "../capability.js";
-import { listFacilitiesCapability, listNodesCapability, listSuppliersCapability } from "./fleet.js";
-import { logsLatestCapability, telemetryLatestCapability } from "./observability.js";
-import { tokensListCapability } from "./tokens.js";
-import { organizationListCapability, usersListCapability } from "./users.js";
-export const ADMIN_CLI_ROOTS = [
-    { name: "users" },
-    { name: "organizations" },
-    { name: "suppliers" },
-    { name: "facilities" },
-    { name: "nodes" },
-    { name: "enrollment-tokens" },
-    { name: "capacity-offers" },
-    { name: "reservations" },
-];
-function adminHelp(command, outcome, human, automation, acceptedReferences = []) {
-    return {
-        audience: "admin",
-        category: "resource",
-        command,
-        outcome,
-        human,
-        automation,
-        acceptedReferences,
-    };
-}
-function withAdminBinding(capability, help) {
-    if (!help.command)
-        throw new Error(`${capability.id} requires a canonical CLI command`);
-    return {
-        ...capability,
-        cli: {
-            command: [...help.command],
-            vnext: help,
-        },
-    };
-}
-export const adminUsersListCapability = withAdminBinding(usersListCapability, adminHelp(["admin", "users", "list"], "List users belonging to organizations in the Authorization directory.", "ornn admin users list [--query QUERY] [--organization UUID] [--limit 25] [--offset OFFSET] [--cursor CURSOR]", "ornn admin users list --query QUERY --limit 25 [--cursor CURSOR] --format json"));
-export const adminOrganizationsListCapability = withAdminBinding(organizationListCapability, adminHelp(["admin", "organizations", "list"], "List organizations in the Authorization directory.", "ornn admin organizations list [--query QUERY] [--role consumer|supplier] [--approved true|false] [--ids UUID,...] [--limit 25] [--offset OFFSET] [--cursor CURSOR]", "ornn admin organizations list --query QUERY --limit 25 [--cursor CURSOR] --format json"));
-export const adminSuppliersListCapability = withAdminBinding(listSuppliersCapability, adminHelp(["admin", "suppliers", "list"], "List supplier organizations visible to staff.", "ornn admin suppliers list [--limit 50] [--cursor CURSOR]", "ornn admin suppliers list --limit 50 --format json"));
-export const adminFacilitiesListCapability = withAdminBinding(listFacilitiesCapability, adminHelp(["admin", "facilities", "list"], "List facilities visible to staff.", "ornn admin facilities list [--supplier UUID] [--limit 50] [--cursor CURSOR]", "ornn admin facilities list --limit 50 --format json"));
-export const adminNodesListCapability = withAdminBinding(listNodesCapability, adminHelp(["admin", "nodes", "list"], "List enrolled, ghost, and off-grid nodes.", "ornn admin nodes list [--supplier UUID] [--facility FACILITY] [--status STATUS] [--reservation UUID] [--limit 50] [--cursor CURSOR]", "ornn admin nodes list --limit 50 [--cursor CURSOR] --format json"));
-const nodeInput = z.object({ node_id: z.string().min(1) });
-export const adminNodeHealthCapability = defineCapability({
-    id: "nodes.health",
-    domain: "fleet",
-    roles: ["admin"],
-    description: "Read lifecycle and readiness facts for one enrolled node.",
-    mutation: "read",
-    http: { method: "GET", path: "/nodes/{id}" },
-    cli: {
-        command: ["admin", "nodes", "health"],
-        vnext: adminHelp(["admin", "nodes", "health"], "Inspect lifecycle and readiness facts for one node.", "ornn admin nodes health <node-id>", "ornn admin nodes health <node-id> --format json", ["canonical node ID"]),
-    },
-    mcp: false,
-    slack: false,
-    input: nodeInput,
-    execute: async (ctx, input) => {
-        const parsed = nodeInput.parse(input);
-        return ctx.fetch(`/nodes/${encodeURIComponent(parsed.node_id)}`, { method: "GET" });
-    },
-});
-export const adminNodeMetricsCapability = withAdminBinding(telemetryLatestCapability, adminHelp(["admin", "nodes", "metrics"], "Read a bounded telemetry window for one node.", "ornn admin nodes metrics <node-id> [--span 15m] [--start TIME --end TIME] [--max-points 240]", "ornn admin nodes metrics <node-id> --span 15m [--start TIME --end TIME] --max-points 240 --format json", ["canonical node ID"]));
-export const adminNodeLogsCapability = withAdminBinding(logsLatestCapability, adminHelp(["admin", "nodes", "logs"], "Read one bounded node log page.", "ornn admin nodes logs <node-id> [--stream kernel|serial] [--count 200] [--before TIME] [--cursor CURSOR]", "ornn admin nodes logs <node-id> --stream kernel --count 200 [--before TIME] [--cursor CURSOR] --format json", ["canonical node ID"]));
-export const adminEnrollmentTokensListCapability = withAdminBinding(tokensListCapability, adminHelp(["admin", "enrollment-tokens", "list"], "List enrollment-token metadata without token bytes.", "ornn admin enrollment-tokens list [--limit 50] [--cursor CURSOR]", "ornn admin enrollment-tokens list --limit 50 --format json"));
-export const adminCapabilities = [
-    adminUsersListCapability,
-    adminOrganizationsListCapability,
-    adminSuppliersListCapability,
-    adminFacilitiesListCapability,
-    adminNodesListCapability,
-    adminNodeHealthCapability,
-    adminNodeMetricsCapability,
-    adminNodeLogsCapability,
-    adminEnrollmentTokensListCapability,
-];
-const replacements = {
-    "facilities.list": adminFacilitiesListCapability,
-    "logs.latest": adminNodeLogsCapability,
-    "nodes.list": adminNodesListCapability,
-    "supplier.list": adminSuppliersListCapability,
-    "telemetry.latest": adminNodeMetricsCapability,
-    "tokens.list": adminEnrollmentTokensListCapability,
-    "users.list": adminUsersListCapability,
-    "organization.list": adminOrganizationsListCapability,
-};
-/** Applies canonical admin CLI bindings without changing MCP or Slack identities. */
-export function bindAdminCapabilities(capabilities) {
-    return capabilities.map((capability) => replacements[capability.id] ?? capability);
-}

package/vendor/capabilities/capabilities/cli.js

@@ -1,156 +0,0 @@
-import { z } from "zod";
-import { defineCapability } from "../capability.js";
-export const CLI_MACHINE_SCHEMA = "ornn.cli/v1";
-const emptyInput = z.object({});
-function requireCliRuntime(context) {
-    if (!context.cli) {
-        throw new Error("This capability must execute through the Ornn CLI runtime.");
-    }
-    return context.cli;
-}
-const updateInput = z.object({
-    $positionals: z.array(z.string()).max(0).default([]),
-    major: z.boolean().optional(),
-});
-const completionInput = z
-    .object({
-    $positionals: z.tuple([z.enum(["bash", "fish", "zsh"])]),
-})
-    .transform(({ $positionals }) => ({ shell: $positionals[0] }));
-export const versionCapability = defineCapability({
-    id: "cli.version",
-    domain: "cli",
-    roles: ["user"],
-    description: "Show the CLI version and machine-output contract.",
-    mutation: "local",
-    input: emptyInput,
-    cli: {
-        command: ["version"],
-        vnext: {
-            audience: "customer",
-            category: "platform",
-            outcome: "Identify the installed CLI and its machine-output contract.",
-            human: "ornn version",
-            automation: "ornn version --format json",
-            related: ["status", "resources"],
-            order: 20,
-        },
-    },
-    mcp: false,
-    slack: false,
-    execute: async (context) => {
-        const runtime = requireCliRuntime(context);
-        return {
-            version: runtime.version,
-            machine_schema: runtime.machineSchema,
-            update_channel: runtime.updateChannel,
-        };
-    },
-});
-export const updateCapability = defineCapability({
-    id: "cli.update",
-    domain: "cli",
-    roles: ["user"],
-    description: "Update the installed CLI through its detected package manager.",
-    mutation: "local",
-    input: updateInput,
-    cli: {
-        command: ["update"],
-        vnext: {
-            arguments: "semantic",
-            audience: "customer",
-            category: "platform",
-            outcome: "Update the installed CLI with explicit acknowledgement for a major crossing.",
-            human: "ornn update [--major]",
-            automation: "ornn update --format human [--major]",
-            related: ["version"],
-            order: 25,
-        },
-    },
-    mcp: false,
-    slack: false,
-    execute: async (context, input) => {
-        const runtime = requireCliRuntime(context);
-        if (!runtime.update) {
-            throw new Error("This capability must execute through the Ornn CLI update runtime.");
-        }
-        return runtime.update(input);
-    },
-});
-export const completionCapability = defineCapability({
-    id: "cli.completion",
-    domain: "cli",
-    roles: ["user"],
-    description: "Generate shell completion from canonical catalog commands.",
-    mutation: "local",
-    input: completionInput,
-    cli: {
-        command: ["completion"],
-        vnext: {
-            arguments: "semantic",
-            audience: "customer",
-            category: "platform",
-            outcome: "Generate bash, fish, or zsh completion from the canonical command catalog.",
-            human: "ornn completion <bash|fish|zsh> --format human",
-            automation: "ornn completion <bash|fish|zsh> --format json",
-            related: ["resources"],
-            order: 27,
-        },
-    },
-    mcp: false,
-    slack: false,
-    execute: async (context, input) => {
-        const runtime = requireCliRuntime(context);
-        if (!runtime.completion) {
-            throw new Error("This capability must execute through the Ornn CLI completion runtime.");
-        }
-        return runtime.completion(input);
-    },
-});
-export const resourcesCapability = defineCapability({
-    id: "cli.resources",
-    domain: "cli",
-    roles: ["user"],
-    description: "List registered advanced customer resource commands.",
-    mutation: "local",
-    input: emptyInput,
-    cli: {
-        command: ["resources"],
-        vnext: {
-            audience: "customer",
-            category: "platform",
-            outcome: "Discover advanced customer resource commands without dispatching a generic request.",
-            human: "ornn resources",
-            automation: "ornn resources --format json",
-            related: ["status", "version"],
-            order: 30,
-        },
-    },
-    mcp: false,
-    slack: false,
-    execute: async (context) => {
-        const runtime = requireCliRuntime(context);
-        const resources = [];
-        for (const capability of runtime.catalog) {
-            const binding = capability.cli;
-            const help = binding?.vnext;
-            if (!binding || help?.audience !== "customer" || help.category !== "resource") {
-                continue;
-            }
-            resources.push({
-                command: binding.command.join(" "),
-                outcome: help.outcome,
-                human: help.human,
-                automation: help.automation,
-            });
-        }
-        resources.sort((left, right) => left.command.localeCompare(right.command));
-        return { resources };
-    },
-});
-export const cliShellCapabilities = [
-    versionCapability,
-    updateCapability,
-    completionCapability,
-    resourcesCapability,
-];