@ornncompute/cli 1.0.75 → 1.0.107

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 in the Authorization directory; pass next_offset as --offset to continue.", "ornn admin users list [--query QUERY] [--organization UUID] [--limit 25] [--offset OFFSET]", "ornn admin users list --query QUERY --limit 25 [--offset OFFSET] --format json"));
-export const adminOrganizationsListCapability = withAdminBinding(organizationListCapability, adminHelp(["admin", "organizations", "list"], "List organizations in the Authorization directory; pass next_offset as --offset to continue.", "ornn admin organizations list [--query QUERY] [--role consumer|supplier] [--approved true|false] [--ids UUID,...] [--limit 25] [--offset OFFSET]", "ornn admin organizations list --query QUERY --limit 25 [--offset OFFSET] --format json"));
-export const adminSuppliersListCapability = withAdminBinding(listSuppliersCapability, adminHelp(["admin", "suppliers", "list"], "List supplier organizations visible to staff; pass next_offset as --offset to continue.", "ornn admin suppliers list [--limit 50] [--offset OFFSET]", "ornn admin suppliers list --limit 50 --offset OFFSET --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,
-];

package/vendor/capabilities/capabilities/clusters.js

@@ -1,248 +0,0 @@
-import { z } from "zod";
-import { defineCapability, preview, } from "../capability.js";
-const reservationInput = z.object({
-    reservation_id: z.string().min(1),
-    reservationId: z.string().optional(),
-});
-const launchInput = reservationInput.extend({
-    network_mode: z.enum(["public", "private"]).optional(),
-    node_count: z.number().int().positive().optional(),
-    node_ids: z.array(z.string()).optional(),
-});
-const clusterCliInput = z
-    .object({
-    $positionals: z.array(z.string()).optional(),
-    cursor: z.string().optional(),
-    guided: z.boolean().optional(),
-    idempotencyKey: z.string().optional(),
-    limit: z.union([z.string(), z.number()]).optional(),
-    machine: z.string().optional(),
-    machines: z.string().optional(),
-    network: z.enum(["public", "private"]).optional(),
-    noWait: z.boolean().optional(),
-    nodes: z.union([z.string(), z.number()]).optional(),
-    output: z.string().optional(),
-    overwrite: z.boolean().optional(),
-    timeout: z.string().optional(),
-    wait: z.boolean().optional(),
-    yes: z.boolean().optional(),
-})
-    .strict();
-function reservationId(input) {
-    return (input.reservation_id || input.reservationId || "").trim();
-}
-function clusterPath(kind, id, suffix) {
-    return `/${kind}/reservations/${encodeURIComponent(id)}/${suffix}`;
-}
-function clusterExecutor(context) {
-    const runtime = context.cli?.interaction;
-    if (!runtime?.cluster) {
-        throw new Error("This capability must execute through the Ornn CLI cluster runtime.");
-    }
-    return runtime.cluster.bind(runtime);
-}
-function clusterCliCapability({ acceptedReferences = [], automation, command, description, human, id, mutation, outcome, related = [], review, }) {
-    return defineCapability({
-        id,
-        domain: "clusters",
-        roles: ["user"],
-        description,
-        mutation,
-        input: clusterCliInput,
-        cli: {
-            command,
-            vnext: {
-                arguments: "semantic",
-                audience: "customer",
-                category: "resource",
-                outcome,
-                human,
-                automation,
-                acceptedReferences,
-                ...(review ? { review } : {}),
-                resumableStates: ["working", "ready", "partial", "failed", "ended"],
-                related,
-            },
-        },
-        mcp: false,
-        slack: false,
-        execute: async (context, input) => clusterExecutor(context)(id, input),
-    });
-}
-function clusterPair(kind, domain) {
-    const label = kind === "slurm" ? "Slurm" : "Kubernetes";
-    return [
-        defineCapability({
-            id: `${kind}.eligible`,
-            domain,
-            roles: ["user"],
-            description: `${label} launch is blocked only when the reservation's nodes already belong to a different controller. Returns eligible=false with reason other_cluster in that case.`,
-            mutation: "read",
-            http: { method: "GET", path: `/${kind}/reservations/{id}/cluster/eligible` },
-            slack: false,
-            input: reservationInput,
-            execute: async (ctx, input) => {
-                const parsed = reservationInput.parse(input);
-                return ctx.fetch(clusterPath(kind, reservationId(parsed), "cluster/eligible"), {
-                    method: "GET",
-                });
-            },
-        }),
-        defineCapability({
-            id: `${kind}.launch`,
-            domain,
-            roles: ["user"],
-            description: `Launch a ${label} controller on a reservation. Blocked when ${kind}.eligible reports other_cluster.`,
-            mutation: "preview-confirm",
-            http: { method: "POST", path: `/${kind}/reservations/{id}/cluster/launch` },
-            slack: false,
-            input: launchInput,
-            execute: async (ctx, input) => {
-                const parsed = launchInput.parse(input);
-                const id = reservationId(parsed);
-                const eligibility = (await ctx.fetch(clusterPath(kind, id, "cluster/eligible"), {
-                    method: "GET",
-                }));
-                if (eligibility?.eligible === false && eligibility.reason === "other_cluster") {
-                    return { ok: false, error: "other_cluster", reason: "other_cluster" };
-                }
-                if (!ctx.confirmed) {
-                    return preview(`${kind}.launch`, { reservation_id: id });
-                }
-                return ctx.fetch(clusterPath(kind, id, "cluster/launch"), {
-                    method: "POST",
-                    body: {
-                        network_mode: parsed.network_mode ?? "public",
-                        ...(parsed.node_count != null ? { node_count: parsed.node_count } : {}),
-                        ...(parsed.node_ids?.length ? { node_ids: parsed.node_ids } : {}),
-                    },
-                });
-            },
-        }),
-        defineCapability({
-            id: `${kind}.teardown`,
-            domain,
-            roles: ["user"],
-            description: `Tear down the ${label} controller for a reservation.`,
-            mutation: "preview-confirm",
-            http: { method: "POST", path: `/${kind}/reservations/{id}/cluster/teardown` },
-            slack: false,
-            input: reservationInput,
-            execute: async (ctx, input) => {
-                const parsed = reservationInput.parse(input);
-                const id = reservationId(parsed);
-                if (!ctx.confirmed) {
-                    return preview(`${kind}.teardown`, { reservation_id: id });
-                }
-                return ctx.fetch(clusterPath(kind, id, "cluster/teardown"), { method: "POST" });
-            },
-        }),
-        defineCapability({
-            id: `${kind}.show`,
-            domain,
-            roles: ["user"],
-            description: `Show the ${label} controller for a reservation.`,
-            mutation: "read",
-            http: { method: "GET", path: `/${kind}/reservations/{id}/cluster` },
-            slack: false,
-            input: reservationInput,
-            execute: async (ctx, input) => {
-                const parsed = reservationInput.parse(input);
-                return ctx.fetch(clusterPath(kind, reservationId(parsed), "cluster"), { method: "GET" });
-            },
-        }),
-    ];
-}
-export const clusterCliCapabilities = [
-    clusterCliCapability({
-        id: "clusters.list",
-        command: ["clusters", "list"],
-        description: "List customer-safe Kubernetes and Slurm cluster facts in one bounded page.",
-        mutation: "read",
-        outcome: "List clusters without generated names, credentials, or controller details.",
-        human: "ornn clusters list [--limit <1-500>] [--cursor <cursor>]",
-        automation: "ornn clusters list --limit 50 --format json",
-        related: ["clusters show", "clusters wait"],
-    }),
-    clusterCliCapability({
-        id: "clusters.show",
-        command: ["clusters", "show"],
-        description: "Inspect one exact cluster through safe customer facts.",
-        mutation: "read",
-        outcome: "Show lifecycle and membership without exposing credentials or controller internals.",
-        human: "ornn clusters show [<cluster-id>] [--guided]",
-        automation: "ornn clusters show <cluster-id> --format json",
-        acceptedReferences: ["canonical cluster ID", "invocation-local guided choice"],
-        related: ["clusters wait", "connect"],
-    }),
-    clusterCliCapability({
-        id: "clusters.wait",
-        command: ["clusters", "wait"],
-        description: "Wait locally for one cluster to become usable without cancelling remote work.",
-        mutation: "read",
-        outcome: "Wait for usable native access with bounded timeout and interruption results.",
-        human: "ornn clusters wait [<cluster-id>] [--guided] [--timeout <duration>]",
-        automation: "ornn clusters wait <cluster-id> --timeout <duration> --format json",
-        acceptedReferences: ["canonical cluster ID", "invocation-local guided choice"],
-        related: ["clusters show", "connect"],
-    }),
-    clusterCliCapability({
-        id: "clusters.eligible_machines",
-        command: ["clusters", "eligible-machines"],
-        description: "Read the authoritative same-reservation eligible-machine projection.",
-        mutation: "read",
-        outcome: "List only canonical machine IDs and hostnames currently eligible for this cluster.",
-        human: "ornn clusters eligible-machines [<cluster-id>] [--guided] [--limit <1-500>] [--cursor <cursor>]",
-        automation: "ornn clusters eligible-machines <cluster-id> --limit 50 --format json",
-        acceptedReferences: ["canonical cluster ID", "invocation-local guided choice"],
-        related: ["clusters add-node", "clusters remove-node"],
-    }),
-    clusterCliCapability({
-        id: "clusters.add_node",
-        command: ["clusters", "add-node"],
-        description: "Reconcile one exact cluster membership-increase goal.",
-        mutation: "preview-confirm",
-        outcome: "Add one currently eligible machine, or rediscover that exact membership goal.",
-        human: "ornn clusters add-node [<cluster-id>] [<machine-id-or-hostname>] [--guided] [--no-wait]",
-        automation: "ornn clusters add-node <cluster-id> <machine-id>  --idempotency-key <key> --format json",
-        acceptedReferences: [
-            "canonical cluster ID",
-            "canonical machine ID",
-            "exact unique eligible hostname",
-            "invocation-local guided choice",
-        ],
-        review: "Review the exact cluster, selected machine, and resulting membership count.",
-        related: ["clusters eligible-machines", "clusters remove-node"],
-    }),
-    clusterCliCapability({
-        id: "clusters.remove_node",
-        command: ["clusters", "remove-node"],
-        description: "Reconcile one exact cluster membership-reduction goal.",
-        mutation: "preview-confirm",
-        outcome: "Remove one exact member, or rediscover that exact membership goal.",
-        human: "ornn clusters remove-node [<cluster-id>] [<machine-id-or-hostname>] [--guided] [--no-wait]",
-        automation: "ornn clusters remove-node <cluster-id> <machine-id>  --idempotency-key <key> --format json",
-        acceptedReferences: [
-            "canonical cluster ID",
-            "canonical machine ID",
-            "exact unique member hostname",
-            "invocation-local guided choice",
-        ],
-        review: "Review the exact cluster, removed machine, access reduction, and resulting membership count.",
-        related: ["clusters eligible-machines", "clusters add-node"],
-    }),
-    clusterCliCapability({
-        id: "clusters.teardown",
-        command: ["clusters", "teardown"],
-        description: "Tear down one cluster without surrendering its capacity reservation.",
-        mutation: "preview-confirm",
-        outcome: "End cluster lifecycle while reporting partial member failures and continuing reservation charges.",
-        human: "ornn clusters teardown [<cluster-id>] [--guided] [--no-wait]",
-        automation: "ornn clusters teardown <cluster-id>  --idempotency-key <key> --format json",
-        acceptedReferences: ["canonical cluster ID", "invocation-local guided choice"],
-        review: "The cluster and native access end; the capacity reservation and its charges remain.",
-        related: ["clusters show", "reservations show"],
-    }),
-];
-export const slurmCapabilities = clusterPair("slurm", "slurm");
-export const kubernetesCapabilities = clusterPair("kubernetes", "kubernetes");