@ornncompute/cli 1.0.72 → 1.0.97

package/vendor/capabilities/capabilities/compute.js

@@ -1,523 +0,0 @@
-import { z } from "zod";
-import { defineCapability, } from "../capability.js";
-const positionals = z.array(z.string()).default([]);
-export const launchInput = z
-    .object({
-    $positionals: positionals,
-    guided: z.boolean().optional(),
-    idempotencyKey: z.string().optional(),
-    key: z.string().optional(),
-    keyId: z.string().optional(),
-    label: z.string().optional(),
-    machine: z.string().optional(),
-    machines: z.string().optional(),
-    mode: z.string().optional(),
-    mountAccess: z.string().optional(),
-    network: z.string().optional(),
-    noWait: z.boolean().optional(),
-    nodes: z.union([z.string(), z.number()]).optional(),
-    publicKey: z.string().optional(),
-    publicKeyFile: z.string().optional(),
-    reservation: z.string().optional(),
-    resume: z.union([z.string().min(1), z.literal(true)]).optional(),
-    timeout: z.string().optional(),
-    username: z.string().optional(),
-    vms: z.string().optional(),
-    wait: z.boolean().optional(),
-    yes: z.boolean().optional(),
-    volume: z.string().optional(),
-})
-    .strict();
-const keyListInput = z
-    .object({
-    $positionals: positionals,
-    cursor: z.string().optional(),
-    limit: z.coerce.number().int().min(1).max(500).optional(),
-})
-    .strict();
-const keyMutationInput = z
-    .object({
-    $positionals: positionals,
-    idempotencyKey: z.string().optional(),
-    key: z.string().optional(),
-    keyId: z.string().optional(),
-    label: z.string().optional(),
-    publicKey: z.string().optional(),
-    publicKeyFile: z.string().optional(),
-    yes: z.boolean().optional(),
-})
-    .strict();
-const machineListInput = z
-    .object({
-    $positionals: positionals,
-    cursor: z.string().optional(),
-    limit: z.coerce.number().int().min(1).max(500).optional(),
-})
-    .strict();
-const machineShowInput = z
-    .object({
-    $positionals: positionals,
-    guided: z.boolean().optional(),
-})
-    .strict();
-const machineWaitInput = z
-    .object({
-    $positionals: positionals,
-    guided: z.boolean().optional(),
-    timeout: z.string().optional(),
-})
-    .strict();
-const machineSwitchInput = z
-    .object({
-    $positionals: positionals,
-    guided: z.boolean().optional(),
-    eraseLocalData: z.boolean().optional(),
-    idempotencyKey: z.string().optional(),
-    mode: z.string().optional(),
-    network: z.string().optional(),
-    noWait: z.boolean().optional(),
-    timeout: z.string().optional(),
-    wait: z.boolean().optional(),
-    yes: z.boolean().optional(),
-})
-    .strict();
-const machineMaintenanceInput = z
-    .object({
-    $positionals: positionals,
-    eraseLocalData: z.boolean().optional(),
-    guided: z.boolean().optional(),
-    idempotencyKey: z.string().optional(),
-    noWait: z.boolean().optional(),
-    timeout: z.string().optional(),
-    wait: z.boolean().optional(),
-    yes: z.boolean().optional(),
-})
-    .strict();
-function runtime(context) {
-    const interaction = context.cli?.interaction;
-    if (!interaction)
-        throw new Error("This capability must execute through the Ornn CLI runtime.");
-    return interaction;
-}
-async function executeLaunch(context, input) {
-    const interaction = runtime(context);
-    if (!interaction.launch)
-        throw new Error("No launch mode handlers are registered.");
-    return interaction.launch({ context, input, interaction });
-}
-function executeSshKeys(command) {
-    return async (context, input) => {
-        const interaction = runtime(context);
-        if (!interaction.sshKeys)
-            throw new Error("SSH-key commands are unavailable.");
-        return interaction.sshKeys(command, input, context);
-    };
-}
-function executeMachines(command) {
-    return async (context, input) => {
-        const interaction = runtime(context);
-        if (!interaction.machines)
-            throw new Error("Machine commands are unavailable.");
-        return interaction.machines(command, input, context);
-    };
-}
-function cliOnly(specification) {
-    return defineCapability({ ...specification, mcp: false, slack: false });
-}
-export const launchCapability = cliOnly({
-    id: "access.launch",
-    domain: "access",
-    roles: ["user"],
-    description: "Launch one explicitly selected access mode from active reserved capacity.",
-    mutation: "preview-confirm",
-    input: launchInput,
-    cli: {
-        command: ["launch"],
-        vnext: {
-            arguments: "semantic",
-            audience: "customer",
-            category: "journey",
-            order: 2,
-            outcome: "Launch one reviewed VM, Bare Metal machine, Kubernetes cluster, or Slurm cluster from active reserved capacity, including a declared durable Bare Metal workspace.",
-            human: "ornn launch [<capacity-reservation>] --mode vm|bare-metal|kubernetes|slurm [--key <ssh-key>]; Bare Metal may add --network shared --volume <managed-volume> --mount-access read-only|read-write; Kubernetes/Slurm prompt for missing --network public|private and --nodes <membership-count>, and may add running VMs with --vms <vm-ids>",
-            automation: "ornn launch <canonical-reservation-id> --mode vm|bare-metal|kubernetes|slurm --yes --idempotency-key <key> --format json; VM/Bare Metal/Slurm require --key <canonical-key-id>; Bare Metal may add --network shared --volume <canonical-volume-id> --mount-access read-only|read-write; Kubernetes/Slurm require --network public|private --nodes <membership-count> --machines <canonical-machine-ids>, and may add --vms <canonical-vm-ids> (with --nodes 0 for a cluster of VMs only)",
-            acceptedReferences: [
-                "canonical capacity-reservation ID",
-                "canonical eligible machine IDs",
-                "canonical running VM IDs for cluster membership",
-                "invocation-local eligible reservation and machine choices",
-                "exact SSH-key and managed-volume references; organization network shared",
-            ],
-            review: "organization, active capacity reservation, explicit access mode, native access, exact machine or cluster membership goal, declared SSH key, network and volume-mount relationships, allocation window and quantity, and wait behavior",
-            resumableStates: [
-                "partial durable workspace",
-                "accepted machine or cluster",
-                "native access ready",
-                "partial membership",
-            ],
-            related: [
-                "connect",
-                "machines list",
-                "clusters show",
-                "volume-mounts show",
-                "filesystems show",
-                "ssh-keys list",
-                "ssh-keys assignments status",
-            ],
-        },
-    },
-    execute: executeLaunch,
-});
-export const machineListCapability = cliOnly({
-    id: "access.machines.list",
-    domain: "access",
-    roles: ["user"],
-    description: "List direct VM and Bare Metal machines in one bounded page.",
-    mutation: "read",
-    input: machineListInput,
-    cli: {
-        command: ["machines", "list"],
-        vnext: {
-            arguments: "semantic",
-            audience: "customer",
-            category: "resource",
-            order: 460,
-            outcome: "List owned direct machines with lifecycle and SSH reachability kept separate.",
-            human: "ornn machines list [--limit <1-500>] [--cursor <opaque-cursor>]",
-            automation: "ornn machines list --limit 50 --format json",
-            acceptedReferences: ["opaque page cursor"],
-            related: ["machines show", "machines wait"],
-        },
-    },
-    execute: executeMachines("list"),
-});
-export const machineShowCapability = cliOnly({
-    id: "access.machines.show",
-    domain: "access",
-    roles: ["user"],
-    description: "Inspect one exact direct machine without changing it.",
-    mutation: "read",
-    input: machineShowInput,
-    cli: {
-        command: ["machines", "show"],
-        vnext: {
-            arguments: "semantic",
-            audience: "customer",
-            category: "resource",
-            order: 461,
-            outcome: "Show one exact VM or Bare Metal machine, its lifecycle, and independent SSH reachability.",
-            human: "ornn machines show <canonical-machine-id|exact-hostname>",
-            automation: "ornn machines show <canonical-machine-id> --format json",
-            acceptedReferences: [
-                "canonical machine ID",
-                "exact unique hostname",
-                "invocation-local guided choice",
-            ],
-            related: ["connect", "machines wait"],
-        },
-    },
-    execute: executeMachines("show"),
-});
-export const machineWaitCapability = cliOnly({
-    id: "access.machines.wait",
-    domain: "access",
-    roles: ["user"],
-    description: "Wait locally for one exact direct machine to become SSH-ready.",
-    mutation: "read",
-    input: machineWaitInput,
-    cli: {
-        command: ["machines", "wait"],
-        vnext: {
-            arguments: "semantic",
-            audience: "customer",
-            category: "resource",
-            order: 462,
-            outcome: "Wait for usable SSH without canceling remote work on timeout or interruption.",
-            human: "ornn machines wait <canonical-machine-id|exact-hostname> [--timeout <duration>]",
-            automation: "ornn machines wait <canonical-machine-id> --timeout <duration> --format json",
-            acceptedReferences: [
-                "canonical machine ID",
-                "exact unique hostname",
-                "invocation-local guided choice",
-            ],
-            resumableStates: ["provisioning", "SSH-key delivery pending", "SSH ready"],
-            related: ["machines show", "connect"],
-        },
-    },
-    execute: executeMachines("wait"),
-});
-export const machineSwitchCapability = cliOnly({
-    id: "access.machines.switch",
-    domain: "access",
-    roles: ["user"],
-    description: "Switch one direct-machine reservation's mode or network intent.",
-    mutation: "preview-confirm",
-    input: machineSwitchInput,
-    cli: {
-        command: ["machines", "switch"],
-        vnext: {
-            arguments: "semantic",
-            audience: "customer",
-            category: "resource",
-            order: 463,
-            outcome: "Change only the explicitly requested VM, Bare Metal, or network goal while retaining SSH-key intent.",
-            human: "ornn machines switch <canonical-reservation-id> [--mode vm|bare-metal] [--network public|private] [--erase-local-data]",
-            automation: "ornn machines switch <canonical-reservation-id> [--mode vm|bare-metal] [--network public|private] [--erase-local-data] --yes --idempotency-key <key> --format json",
-            acceptedReferences: ["canonical capacity-reservation ID"],
-            review: "exact reservation, current and requested access mode, network intent, retained SSH keys, access interruption, and permanent local-data erasure for cross-mode changes",
-            resumableStates: ["switch accepted", "SSH ready"],
-            related: ["machines wait", "connect"],
-        },
-    },
-    execute: executeMachines("switch"),
-});
-export const machineRebootCapability = cliOnly({
-    id: "access.machines.reboot",
-    domain: "access",
-    roles: ["user"],
-    description: "Reboot one exact direct machine after reviewing the access interruption.",
-    mutation: "preview-confirm",
-    input: machineMaintenanceInput,
-    cli: {
-        command: ["machines", "reboot"],
-        vnext: {
-            arguments: "semantic",
-            audience: "customer",
-            category: "resource",
-            order: 464,
-            outcome: "Reboot one exact machine and normally wait for restored SSH readiness.",
-            human: "ornn machines reboot <canonical-machine-id|exact-hostname> [--no-wait]",
-            automation: "ornn machines reboot <canonical-machine-id> --yes --idempotency-key <key> --format json",
-            acceptedReferences: [
-                "canonical machine ID",
-                "exact unique hostname",
-                "invocation-local guided choice",
-            ],
-            review: "temporary SSH interruption with SSH keys, network, mounted volume, and local data preserved",
-            resumableStates: ["reboot accepted", "SSH ready"],
-            related: ["machines wait", "connect"],
-        },
-    },
-    execute: executeMachines("reboot"),
-});
-export const machineResetCapability = cliOnly({
-    id: "access.machines.reset",
-    domain: "access",
-    roles: ["user"],
-    description: "Erase local machine data and hard reset one exact direct machine.",
-    mutation: "preview-confirm",
-    input: machineMaintenanceInput,
-    cli: {
-        command: ["machines", "reset"],
-        vnext: {
-            arguments: "semantic",
-            audience: "customer",
-            category: "resource",
-            order: 465,
-            outcome: "Hard reset one exact machine only with explicit local-data erasure scope and final consent.",
-            human: "ornn machines reset <canonical-machine-id|exact-hostname> --erase-local-data [--no-wait]",
-            automation: "ornn machines reset <canonical-machine-id> --erase-local-data --yes --idempotency-key <key> --format json",
-            acceptedReferences: [
-                "canonical machine ID",
-                "exact unique hostname",
-                "invocation-local guided choice",
-            ],
-            review: "permanent local-data erasure, temporary access interruption, restored SSH keys, and preserved external volume relationship",
-            resumableStates: ["reset accepted", "SSH ready"],
-            related: ["machines wait", "connect"],
-        },
-    },
-    execute: executeMachines("reset"),
-});
-export const sshKeyListCapability = cliOnly({
-    id: "access.ssh_keys.list",
-    domain: "access",
-    roles: ["user"],
-    mutation: "read",
-    input: keyListInput,
-    description: "List organization SSH keys in a bounded page.",
-    cli: {
-        command: ["ssh-keys", "list"],
-        vnext: {
-            arguments: "semantic",
-            audience: "customer",
-            category: "resource",
-            order: 450,
-            outcome: "List organization SSH keys without exposing key material.",
-            human: "ornn ssh-keys list [--limit <1-500>] [--cursor <cursor>]",
-            automation: "ornn ssh-keys list --format json [--limit <1-500>] [--cursor <cursor>]",
-            acceptedReferences: [],
-            related: ["ssh-keys add", "ssh-keys assignments list"],
-        },
-    },
-    execute: executeSshKeys("list"),
-});
-export const sshKeyAddCapability = cliOnly({
-    id: "access.ssh_keys.add",
-    domain: "access",
-    roles: ["user"],
-    mutation: "preview-confirm",
-    input: keyMutationInput,
-    description: "Add or replay one organization SSH public key.",
-    cli: {
-        command: ["ssh-keys", "add"],
-        vnext: {
-            arguments: "semantic",
-            audience: "customer",
-            category: "resource",
-            order: 451,
-            outcome: "Add one organization SSH public key by durable public-key identity.",
-            human: "ornn ssh-keys add --public-key-file <path> --label <label>",
-            automation: "ornn ssh-keys add --public-key <public-key> --label <label> --idempotency-key <key> --format json",
-            acceptedReferences: ["public key value", "public key file"],
-            resumableStates: ["ready"],
-            related: ["ssh-keys list", "ssh-keys assignments assign"],
-        },
-    },
-    execute: executeSshKeys("add"),
-});
-export const sshKeyDeleteCapability = cliOnly({
-    id: "access.ssh_keys.delete",
-    domain: "access",
-    roles: ["user"],
-    mutation: "preview-confirm",
-    input: keyMutationInput,
-    description: "Delete one exact organization SSH key after review.",
-    cli: {
-        command: ["ssh-keys", "delete"],
-        vnext: {
-            arguments: "semantic",
-            audience: "customer",
-            category: "resource",
-            order: 452,
-            outcome: "Delete one exact organization SSH key without implying machine delivery.",
-            human: "ornn ssh-keys delete <exact-key-id-or-label>",
-            automation: "ornn ssh-keys delete <canonical-key-id> --yes --idempotency-key <key> --format json",
-            acceptedReferences: [
-                "canonical SSH-key ID",
-                "exact unique key label in an eligible terminal",
-            ],
-            review: "key identity and loss of future access",
-            resumableStates: ["ended"],
-            related: ["ssh-keys list"],
-        },
-    },
-    execute: executeSshKeys("delete"),
-});
-export const sshKeyAssignmentListCapability = cliOnly({
-    id: "access.ssh_key_assignments.list",
-    domain: "access",
-    roles: ["user"],
-    mutation: "read",
-    input: keyListInput,
-    description: "List SSH keys assigned to one capacity reservation.",
-    cli: {
-        command: ["ssh-keys", "assignments", "list"],
-        vnext: {
-            arguments: "semantic",
-            audience: "customer",
-            category: "resource",
-            order: 453,
-            outcome: "List the SSH keys assigned to one exact capacity reservation.",
-            human: "ornn ssh-keys assignments list <canonical-reservation-id>",
-            automation: "ornn ssh-keys assignments list <canonical-reservation-id> --format json",
-            acceptedReferences: ["canonical capacity-reservation ID"],
-            related: ["ssh-keys assignments status"],
-        },
-    },
-    execute: executeSshKeys("assignments.list"),
-});
-export const sshKeyAssignmentAssignCapability = cliOnly({
-    id: "access.ssh_key_assignments.assign",
-    domain: "access",
-    roles: ["user"],
-    mutation: "preview-confirm",
-    input: keyMutationInput,
-    description: "Assign one existing organization SSH key to one capacity reservation.",
-    cli: {
-        command: ["ssh-keys", "assignments", "assign"],
-        vnext: {
-            arguments: "semantic",
-            audience: "customer",
-            category: "resource",
-            order: 454,
-            outcome: "Assign or replay one exact SSH-key relationship.",
-            human: "ornn ssh-keys assignments assign <canonical-reservation-id> --key <exact-key-id-or-label>",
-            automation: "ornn ssh-keys assignments assign <canonical-reservation-id> --key <canonical-key-id> --yes --idempotency-key <key> --format json",
-            acceptedReferences: [
-                "canonical capacity-reservation ID",
-                "canonical SSH-key ID",
-                "exact unique key label in an eligible terminal",
-            ],
-            review: "reservation and SSH-key relationship",
-            resumableStates: ["associated", "queued", "installed"],
-            related: ["ssh-keys assignments status"],
-        },
-    },
-    execute: executeSshKeys("assignments.assign"),
-});
-export const sshKeyAssignmentSyncCapability = cliOnly({
-    id: "access.ssh_key_assignments.sync",
-    domain: "access",
-    roles: ["user"],
-    mutation: "preview-confirm",
-    input: keyMutationInput,
-    description: "Synchronize assigned SSH keys to every active reservation machine.",
-    cli: {
-        command: ["ssh-keys", "assignments", "sync"],
-        vnext: {
-            arguments: "semantic",
-            audience: "customer",
-            category: "resource",
-            order: 455,
-            outcome: "Queue idempotent SSH-key synchronization and report delayed delivery honestly.",
-            human: "ornn ssh-keys assignments sync <canonical-reservation-id>",
-            automation: "ornn ssh-keys assignments sync <canonical-reservation-id> --yes --idempotency-key <key> --format json",
-            acceptedReferences: ["canonical capacity-reservation ID"],
-            review: "reservation, assigned keys, and target machines",
-            resumableStates: ["queued", "installed", "failed"],
-            related: ["ssh-keys assignments status"],
-        },
-    },
-    execute: executeSshKeys("assignments.sync"),
-});
-export const sshKeyAssignmentStatusCapability = cliOnly({
-    id: "access.ssh_key_assignments.status",
-    domain: "access",
-    roles: ["user"],
-    mutation: "read",
-    input: keyListInput,
-    description: "Show assigned, queued, installed, and failed SSH-key delivery per machine.",
-    cli: {
-        command: ["ssh-keys", "assignments", "status"],
-        vnext: {
-            arguments: "semantic",
-            audience: "customer",
-            category: "resource",
-            order: 456,
-            outcome: "Distinguish SSH-key assignment from delayed machine delivery.",
-            human: "ornn ssh-keys assignments status <canonical-reservation-id>",
-            automation: "ornn ssh-keys assignments status <canonical-reservation-id> --format json",
-            acceptedReferences: ["canonical capacity-reservation ID"],
-            resumableStates: ["associated", "queued", "installed", "failed"],
-            related: ["ssh-keys assignments sync", "connect"],
-        },
-    },
-    execute: executeSshKeys("assignments.status"),
-});
-export const computeCapabilities = [
-    launchCapability,
-    machineListCapability,
-    machineShowCapability,
-    machineWaitCapability,
-    machineSwitchCapability,
-    machineRebootCapability,
-    machineResetCapability,
-    sshKeyListCapability,
-    sshKeyAddCapability,
-    sshKeyDeleteCapability,
-    sshKeyAssignmentListCapability,
-    sshKeyAssignmentAssignCapability,
-    sshKeyAssignmentSyncCapability,
-    sshKeyAssignmentStatusCapability,
-];

package/vendor/capabilities/capabilities/credits.js

@@ -1,78 +0,0 @@
-import { z } from "zod";
-import { defineCapability, preview } from "../capability.js";
-export const creditGrantInput = z.object({
-    organizationId: z
-        .uuid()
-        .describe("Customer organization UUID. Resolve names or emails with organization_list; ask which organization if matches are ambiguous."),
-    adjustmentId: z
-        .uuid()
-        .describe("The credit-adjustment API's required grant UUID. Keep the same UUID when confirming this grant."),
-    amountCents: z
-        .number()
-        .int()
-        .min(1)
-        .max(100_000_000)
-        .describe("USD cents: 10000 grants $100.00."),
-    note: z
-        .string()
-        .trim()
-        .min(1)
-        .refine((value) => new TextEncoder().encode(value).length <= 500, "Keep the note under 500 UTF-8 bytes.")
-        .describe("Reason for the credit grant."),
-    confirm: z.boolean().optional(),
-});
-export const creditGrantCapability = defineCapability({
-    id: "credits.grant",
-    domain: "billing",
-    roles: ["admin"],
-    description: "Grant Ornn credits to a customer organization using the same operation as Internal Billing. " +
-        "Credits belong to the organization, not an individual person. Resolve the intended organization first. " +
-        "Preview first; confirm:true posts the same grant with its adjustmentId. The verified staff actor supplies audit identity.",
-    mutation: "preview-confirm",
-    http: { method: "POST", path: "/internal/v1/organizations/{organizationId}/credit-adjustments" },
-    cli: {
-        command: ["admin", "organizations", "grant-credit"],
-        vnext: {
-            audience: "admin",
-            category: "resource",
-            command: ["admin", "organizations", "grant-credit"],
-            outcome: "Grant Ornn credits to a customer organization.",
-            human: "ornn admin organizations grant-credit --organization UUID --amount-cents N --note TEXT --idempotency-key UUID [--yes]",
-            automation: "Requires an eligible human terminal.",
-            acceptedReferences: ["organization UUID from admin organizations list"],
-            review: "Review the organization, USD amount, note, and grant UUID before default-no consent.",
-            related: ["admin organizations list", "admin users list"],
-        },
-    },
-    slack: {
-        parameters: {
-            type: "object",
-            properties: {
-                organizationId: {
-                    type: "string",
-                    format: "uuid",
-                    description: "Exact customer organization UUID from organization_list.",
-                },
-                amountCents: {
-                    type: "integer",
-                    minimum: 1,
-                    maximum: 100_000_000,
-                    description: "USD cents: 10000 grants $100.00.",
-                },
-                note: {
-                    type: "string",
-                    description: "Reason for the credit grant, at most 500 UTF-8 bytes.",
-                },
-            },
-            required: ["organizationId", "amountCents", "note"],
-        },
-    },
-    input: creditGrantInput,
-    execute: async (ctx, input) => {
-        const { organizationId, confirm: _confirm, ...grant } = creditGrantInput.parse(input);
-        const body = { ...grant, direction: "credit" };
-        if (!ctx.confirmed)
-            return preview("credits.grant", { organizationId, ...body });
-        return ctx.fetch(`/internal/v1/organizations/${encodeURIComponent(organizationId)}/credit-adjustments`, { method: "POST", body });
-    },
-});