@ornncompute/cli 1.0.75 → 1.0.97

package/vendor/capabilities/capabilities/fleet.js

@@ -1,386 +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(),
-    cursor: z.string().optional(),
-    limit: z.number().int().min(1).max(100).optional(),
-});
-const nodesInput = z.object({
-    organization_id: z.string().optional(),
-    facility_id: z.string().optional(),
-    status: z.string().optional(),
-    reservation_id: 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),
-    node_ref: z.string().optional(),
-    reason: z.string().optional(),
-    force: z.boolean().optional(),
-    skip_cleanup: z.boolean().optional(),
-    delete_node_record: z.literal(true).optional(),
-    idempotency_key: z.string().optional(),
-    yes: z.boolean().optional(),
-    wait: z.boolean().optional(),
-    timeout_seconds: z.number().positive().optional(),
-});
-const nodeExecInput = z.object({
-    node_id: z.string().min(1),
-    command: z.string().min(1),
-    timeout_seconds: z.number().int().positive(),
-    yes: z.boolean().optional(),
-});
-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. When next_offset is present, pass it back as offset for the next page.",
-    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. When nextCursor is present, pass it back as cursor for the next page. Use facilities.show to resolve one facility id.",
-    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.",
-                },
-                cursor: {
-                    type: "string",
-                    description: "Pass the previous response's nextCursor to fetch the next page.",
-                },
-                limit: {
-                    type: "integer",
-                    minimum: 1,
-                    maximum: 100,
-                    description: "Optional page size (maximum 100).",
-                },
-            },
-        },
-    },
-    input: facilitiesInput,
-    execute: async (ctx, input) => {
-        const parsed = facilitiesInput.parse(input);
-        return ctx.fetch(queryPath("/provisioning/facilities", {
-            organizationId: parsed.organization_id,
-            cursor: parsed.cursor,
-            limit: parsed.limit === undefined ? undefined : String(parsed.limit),
-        }), { method: "GET" });
-    },
-});
-export const facilityShowInput = z.object({ facilityId: z.uuid() });
-export const facilityShowCapability = defineCapability({
-    id: "facilities.show",
-    domain: "fleet",
-    roles: ["admin"],
-    description: "Resolve one facility id (e.g. a listing's facilityId) to its display name, region and status.",
-    mutation: "read",
-    http: { method: "GET", path: "/provisioning/facilities/{facilityId}" },
-    cli: false,
-    slack: {
-        parameters: {
-            type: "object",
-            properties: {
-                facilityId: { type: "string", format: "uuid" },
-            },
-            required: ["facilityId"],
-        },
-    },
-    input: facilityShowInput,
-    execute: async (ctx, input) => {
-        const parsed = facilityShowInput.parse(input);
-        return ctx.fetch(`/provisioning/facilities/${encodeURIComponent(parsed.facilityId)}`, {
-            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,
-            facility_id: parsed.facility_id,
-            status: parsed.status,
-            reservation_id: parsed.reservation_id,
-            ...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). Slack waits for a human confirm. ",
-    mutation: "preview-confirm",
-    http: { method: "POST", path: "/nodes/{id}/off-grid" },
-    cli: {
-        command: ["admin", "nodes", "suspend-management"],
-        vnext: {
-            audience: "admin",
-            category: "resource",
-            command: ["admin", "nodes", "suspend-management"],
-            outcome: "Remove Ornn management and managed access from one powered-on node.",
-            human: "ornn admin nodes suspend-management <node-ref> [--reason TEXT] [] [--no-wait]",
-            automation: "ornn admin nodes suspend-management <node-id>  --idempotency-key KEY --format json",
-            review: "Node, supplier, facility, capacity assignment, management removal, and managed-access loss.",
-        },
-    },
-    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 = parsed.node_id.trim();
-        const body = {
-            ...(parsed.idempotency_key ? { request_id: parsed.idempotency_key } : {}),
-            ...(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,
-            ...(parsed.idempotency_key ? { headers: { "Idempotency-Key": parsed.idempotency_key } } : {}),
-        });
-    },
-});
-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. Slack waits for a human confirm. ",
-    mutation: "preview-confirm",
-    http: { method: "POST", path: "/nodes/{id}/on-grid" },
-    cli: {
-        command: ["admin", "nodes", "resume-management"],
-        vnext: {
-            audience: "admin",
-            category: "resource",
-            command: ["admin", "nodes", "resume-management"],
-            outcome: "Restore Ornn management and managed access on one off-grid node.",
-            human: "ornn admin nodes resume-management <node-ref> [] [--no-wait]",
-            automation: "ornn admin nodes resume-management <node-id>  --idempotency-key KEY --format json",
-            review: "Node, supplier, facility, capacity assignment, remote re-enrollment, and restored managed access.",
-        },
-    },
-    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 = parsed.node_id.trim();
-        if (!ctx.confirmed) {
-            return preview("node.on-grid", { node_id: id });
-        }
-        return ctx.fetch(`/nodes/${encodeURIComponent(id)}/on-grid`, {
-            method: "POST",
-            body: {
-                ...(parsed.idempotency_key ? { request_id: parsed.idempotency_key } : {}),
-            },
-            ...(parsed.idempotency_key ? { headers: { "Idempotency-Key": parsed.idempotency_key } } : {}),
-        });
-    },
-});
-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: "immediate",
-    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 = parsed.node_id.trim();
-        const timeoutSeconds = parsed.timeout_seconds;
-        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. Slack waits for a human confirm. ",
-    mutation: "preview-confirm",
-    http: { method: "POST", path: "/nodes/{id}/terminate" },
-    cli: {
-        command: ["admin", "nodes", "terminate"],
-        vnext: {
-            audience: "admin",
-            category: "resource",
-            command: ["admin", "nodes", "terminate"],
-            outcome: "End managed access and permanently delete one exact node record.",
-            human: "ornn admin nodes terminate <node-ref> --delete-node-record [--skip-cleanup] [--reason TEXT] []",
-            automation: "ornn admin nodes terminate <node-id> --delete-node-record  --idempotency-key KEY --format json",
-            review: "Node, supplier, facility, reservation/capacity, host cleanup, node-record deletion, and access loss.",
-        },
-    },
-    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 = parsed.node_id.trim();
-        const force = parsed.force ?? parsed.skip_cleanup;
-        const body = {
-            ...(parsed.reason ? { reason: parsed.reason } : {}),
-            ...(force !== undefined ? { force } : {}),
-            ...(parsed.idempotency_key ? { request_id: parsed.idempotency_key } : {}),
-        };
-        if (!ctx.confirmed) {
-            return preview("node.terminate", { node_id: id, ...body });
-        }
-        return ctx.fetch(`/nodes/${encodeURIComponent(id)}/terminate`, {
-            method: "POST",
-            body,
-            ...(parsed.idempotency_key ? { headers: { "Idempotency-Key": parsed.idempotency_key } } : {}),
-        });
-    },
-});
-export const fleetCapabilities = [
-    listSuppliersCapability,
-    listFacilitiesCapability,
-    facilityShowCapability,
-    listNodesCapability,
-    nodeOffGridCapability,
-    nodeOnGridCapability,
-    nodeExecCapability,
-    nodeTerminateCapability,
-];

package/vendor/capabilities/capabilities/identity.js

@@ -1,129 +0,0 @@
-import { z } from "zod";
-import { defineCapability } from "../capability.js";
-const emptyInput = z.object({});
-const loginInput = z.object({
-    authBase: z.string().min(1).optional(),
-    noBrowser: z.boolean().optional(),
-    pollInterval: z.number().positive().optional(),
-    timeout: z.number().positive().optional(),
-});
-function executeSession(context, command, input) {
-    if (!context.cli?.session) {
-        throw new Error("This capability must execute through the Ornn CLI session runtime.");
-    }
-    return context.cli.session(command, input);
-}
-export const loginCapability = defineCapability({
-    id: "identity.login",
-    domain: "identity",
-    roles: ["user"],
-    description: "Authenticate the CLI with Ornn device authorization.",
-    mutation: "local",
-    http: { method: "POST", path: "/v1/cli/device/start" },
-    input: loginInput,
-    cli: {
-        command: ["login"],
-        vnext: {
-            audience: "customer",
-            category: "session",
-            arguments: "semantic",
-            outcome: "Authenticate in a browser and return to the terminal.",
-            human: "ornn login [--no-browser] [--timeout <seconds>]",
-            automation: "ornn login --format json",
-            resumableStates: ["browser authorization"],
-            related: ["context", "logout"],
-            order: 1,
-        },
-    },
-    mcp: false,
-    slack: false,
-    execute: async (context, input) => executeSession(context, "login", input),
-});
-export const contextCapability = defineCapability({
-    id: "identity.context",
-    domain: "identity",
-    roles: ["user"],
-    description: "Show the current server-verified organization context.",
-    mutation: "read",
-    http: { method: "GET", path: "/v1/cli/session" },
-    input: emptyInput,
-    cli: {
-        command: ["context"],
-        vnext: {
-            audience: "customer",
-            category: "session",
-            arguments: "semantic",
-            outcome: "Show the current user, selected organization, approval, and available organizations.",
-            human: "ornn context",
-            automation: "ornn context --format json",
-            related: ["login", "logout"],
-            order: 2,
-        },
-    },
-    mcp: false,
-    slack: false,
-    execute: async (context, input) => executeSession(context, "context", input),
-});
-export const logoutCapability = defineCapability({
-    id: "identity.logout",
-    domain: "identity",
-    roles: ["user"],
-    description: "Revoke the remote CLI session and clear its local bearer.",
-    mutation: "local",
-    http: { method: "DELETE", path: "/v1/cli/session" },
-    input: emptyInput,
-    cli: {
-        command: ["logout"],
-        vnext: {
-            audience: "customer",
-            category: "session",
-            outcome: "End the remote session and always remove the local bearer.",
-            human: "ornn logout",
-            automation: "ornn logout --format json",
-            related: ["login", "context"],
-            order: 3,
-        },
-    },
-    mcp: false,
-    slack: false,
-    execute: async (context, input) => executeSession(context, "logout", input),
-});
-export const whoamiCapability = defineCapability({
-    id: "identity.whoami",
-    domain: "identity",
-    roles: ["user", "admin"],
-    description: "Show the signed-in Ornn user and organization.",
-    mutation: "read",
-    http: { method: "GET", path: "/v1/cli/session" },
-    input: emptyInput,
-    execute: async (ctx) => ctx.fetch("/v1/cli/session", { method: "GET" }),
-});
-export const statusCapability = defineCapability({
-    id: "identity.status",
-    domain: "identity",
-    roles: ["user", "admin"],
-    description: "Show Ornn platform status.",
-    mutation: "read",
-    http: { method: "GET", path: "/v1/cli/status" },
-    input: emptyInput,
-    execute: async (ctx) => ctx.fetch("/v1/cli/status", { method: "GET" }),
-    cli: {
-        command: ["status"],
-        vnext: {
-            audience: "customer",
-            category: "platform",
-            outcome: "Check current Ornn platform availability.",
-            human: "ornn status",
-            automation: "ornn status --format json",
-            related: ["version", "resources"],
-            order: 10,
-        },
-    },
-});
-export const identityCapabilities = [
-    whoamiCapability,
-    loginCapability,
-    contextCapability,
-    logoutCapability,
-    statusCapability,
-];