@ornncompute/cli 0.2.6 → 0.2.8

package/vendor/capabilities/capabilities/staff-commerce.js

@@ -0,0 +1,290 @@
+import { z } from "zod";
+import { defineStaffMcpCapability, preview } from "../capability.js";
+import { mapBody, seg } from "./staff-shared.js";
+// Staff commerce verbs: reservations, bids, forward inventory, and the tenant
+// credit profile. MCP-only — see `defineStaffMcpCapability`.
+export const reservationCancelInput = z.object({
+    reservationId: z.string(),
+    confirm: z.boolean().optional(),
+});
+export const reservationCancelCapability = defineStaffMcpCapability({
+    id: "reservation.cancel",
+    domain: "reservations",
+    roles: ["admin"],
+    description: "Internal staff only: cancel a reservation. Mirrors the internal dashboard's Cancel/Reject action.",
+    mutation: "preview-confirm",
+    http: { method: "POST", path: "/internal/reservations/{reservationId}/cancel" },
+    input: reservationCancelInput,
+    execute: async (ctx, input) => {
+        const parsed = reservationCancelInput.parse(input);
+        if (!ctx.confirmed) {
+            return preview("reservation.cancel", { reservationId: parsed.reservationId });
+        }
+        return ctx.fetch(`/internal/reservations/${seg(parsed.reservationId)}/cancel`, {
+            method: "POST",
+        });
+    },
+});
+export const reservationTransferInput = z.object({
+    reservationId: z.string(),
+    targetTenantId: z.string(),
+    targetAuthUserId: z.string().optional(),
+    nodeId: z.string().optional(),
+    reservedStrategy: z.enum(["reject", "park"]),
+    confirmReservedTransfer: z.boolean().optional(),
+    notes: z.string().max(2000).optional(),
+    confirm: z.boolean().optional(),
+});
+export const reservationTransferCapability = defineStaffMcpCapability({
+    id: "reservation.transfer",
+    domain: "reservations",
+    roles: ["admin"],
+    description: "Internal staff only: transfer a reservation to a different tenant/node. Mirrors the internal node-overlay transfer action. " +
+        "reservedStrategy has no default and must be chosen explicitly: \"reject\" (transfer only if the reservation isn't " +
+        "currently provisioned/assigned) or \"park\" (clean up old access and park it for the target tenant, for a live handoff). " +
+        "The dashboard always computes this from the reservation's live state before sending it rather than relying on the " +
+        "backend's own default of \"reject\", because a silent \"reject\" default on a reservation the backend doesn't detect as " +
+        "actively provisioned/assigned would transfer it without ever asking for confirm_reserved_transfer.",
+    mutation: "preview-confirm",
+    http: { method: "POST", path: "/internal/reservations/{reservationId}/transfer" },
+    input: reservationTransferInput,
+    execute: async (ctx, input) => {
+        const parsed = reservationTransferInput.parse(input);
+        const body = {
+            target_tenant_id: parsed.targetTenantId,
+            reserved_strategy: parsed.reservedStrategy,
+            confirm_reserved_transfer: parsed.confirmReservedTransfer ?? false,
+            ...mapBody(parsed, {
+                targetAuthUserId: "target_auth_user_id",
+                nodeId: "node_id",
+                notes: "notes",
+            }),
+        };
+        if (!ctx.confirmed)
+            return preview("reservation.transfer", body);
+        return ctx.fetch(`/internal/reservations/${seg(parsed.reservationId)}/transfer`, {
+            method: "POST",
+            body,
+        });
+    },
+});
+export const reservationMachinesListInput = z.object({ reservationId: z.string() });
+export const reservationMachinesListCapability = defineStaffMcpCapability({
+    id: "reservation.machines.list",
+    domain: "reservations",
+    roles: ["reviewer", "admin"],
+    description: "Internal staff only: list machines for a reservation.",
+    mutation: "read",
+    http: { method: "GET", path: "/internal/nodes" },
+    input: reservationMachinesListInput,
+    execute: async (ctx, input) => {
+        const parsed = reservationMachinesListInput.parse(input);
+        return ctx.fetch(`/internal/nodes?reservation_id=${seg(parsed.reservationId)}`, {
+            method: "GET",
+        });
+    },
+});
+export const reservationSshKeyAddInput = z.object({
+    reservationId: z.string(),
+    userId: z.string(),
+    publicKey: z.string().min(1),
+    label: z.string().optional(),
+    nodeId: z.string().optional(),
+    confirm: z.boolean().optional(),
+});
+export const reservationSshKeyAddCapability = defineStaffMcpCapability({
+    id: "reservation.ssh-key.add",
+    domain: "reservations",
+    roles: ["admin"],
+    description: "Internal staff only: add an SSH key to a reservation and queue sync to its machines. Requires confirm: true.",
+    mutation: "preview-confirm",
+    http: { method: "POST", path: "/internal/v1/reservations/{reservationId}/ssh-keys" },
+    input: reservationSshKeyAddInput,
+    execute: async (ctx, input) => {
+        const parsed = reservationSshKeyAddInput.parse(input);
+        const body = {
+            user_id: parsed.userId,
+            public_key: parsed.publicKey,
+            ...mapBody(parsed, { label: "label", nodeId: "node_id" }),
+        };
+        if (!ctx.confirmed)
+            return preview("reservation.ssh-key.add", body);
+        return ctx.fetch(`/internal/v1/reservations/${seg(parsed.reservationId)}/ssh-keys`, {
+            method: "POST",
+            body,
+        });
+    },
+});
+export const reservationSshKeyRemoveInput = z.object({
+    reservationId: z.string(),
+    keyId: z.string(),
+    userId: z.string(),
+    nodeId: z.string().optional(),
+    confirm: z.boolean().optional(),
+});
+export const reservationSshKeyRemoveCapability = defineStaffMcpCapability({
+    id: "reservation.ssh-key.remove",
+    domain: "reservations",
+    roles: ["admin"],
+    description: "Internal staff only: remove an SSH key from a reservation and queue cleanup on its machines. Requires confirm: true.",
+    mutation: "preview-confirm",
+    http: { method: "DELETE", path: "/internal/v1/reservations/{reservationId}/ssh-keys/{keyId}" },
+    input: reservationSshKeyRemoveInput,
+    execute: async (ctx, input) => {
+        const parsed = reservationSshKeyRemoveInput.parse(input);
+        const body = {
+            user_id: parsed.userId,
+            ...mapBody(parsed, { nodeId: "node_id" }),
+        };
+        if (!ctx.confirmed)
+            return preview("reservation.ssh-key.remove", body);
+        return ctx.fetch(`/internal/v1/reservations/${seg(parsed.reservationId)}/ssh-keys/${seg(parsed.keyId)}`, { method: "DELETE", body });
+    },
+});
+export const reservationPublishInput = z.object({
+    reservationId: z.string(),
+    confirm: z.boolean().optional(),
+});
+export const reservationPublishCapability = defineStaffMcpCapability({
+    id: "reservation.publish",
+    domain: "reservations",
+    roles: ["admin"],
+    description: "Internal staff only: publish a commerce draft into a live Commerce reservation. Requires confirm: true.",
+    mutation: "preview-confirm",
+    http: { method: "POST", path: "/internal/reservations/{reservationId}/publish" },
+    input: reservationPublishInput,
+    execute: async (ctx, input) => {
+        const parsed = reservationPublishInput.parse(input);
+        if (!ctx.confirmed) {
+            return preview("reservation.publish", { reservationId: parsed.reservationId });
+        }
+        return ctx.fetch(`/internal/reservations/${seg(parsed.reservationId)}/publish`, {
+            method: "POST",
+        });
+    },
+});
+export const bidAcceptInput = z.object({
+    bidId: z.string(),
+    acceptedGpuCount: z.number().int().min(1).optional(),
+    confirm: z.boolean().optional(),
+});
+export const bidAcceptCapability = defineStaffMcpCapability({
+    id: "bid.accept",
+    domain: "bids",
+    roles: ["admin"],
+    description: "Internal staff only: accept an active bid. Optionally set acceptedGpuCount (defaults to the bid's full gpu_count). Mirrors the internal dashboard's Accept action.",
+    mutation: "preview-confirm",
+    http: { method: "POST", path: "/internal/bids/{bidId}/accept" },
+    input: bidAcceptInput,
+    execute: async (ctx, input) => {
+        const parsed = bidAcceptInput.parse(input);
+        const body = mapBody(parsed, { acceptedGpuCount: "accepted_gpu_count" });
+        if (!ctx.confirmed)
+            return preview("bid.accept", { bidId: parsed.bidId, ...body });
+        return ctx.fetch(`/internal/bids/${seg(parsed.bidId)}/accept`, { method: "POST", body });
+    },
+});
+export const bidRejectInput = z.object({
+    bidId: z.string(),
+    confirm: z.boolean().optional(),
+});
+export const bidRejectCapability = defineStaffMcpCapability({
+    id: "bid.reject",
+    domain: "bids",
+    roles: ["admin"],
+    description: "Internal staff only: reject an active bid. Mirrors the internal dashboard's Reject action.",
+    mutation: "preview-confirm",
+    http: { method: "POST", path: "/internal/bids/{bidId}/reject" },
+    input: bidRejectInput,
+    execute: async (ctx, input) => {
+        const parsed = bidRejectInput.parse(input);
+        if (!ctx.confirmed)
+            return preview("bid.reject", { bidId: parsed.bidId });
+        return ctx.fetch(`/internal/bids/${seg(parsed.bidId)}/reject`, { method: "POST" });
+    },
+});
+export const inventoryUpdateInput = z.object({
+    inventoryId: z.string(),
+    siteOperator: z.string().min(1).optional(),
+    siteNickname: z.string().min(1).optional(),
+    gpuType: z.string().min(1).optional(),
+    nodeCount: z
+        .number()
+        .int()
+        .positive()
+        .optional()
+        .describe("Total nodes (listing capacity), not total GPUs."),
+    gpusPerNode: z.number().int().min(1).max(32).optional(),
+    availableFrom: z.string().nullable().optional(),
+    availableTo: z.string().nullable().optional(),
+    availableStartAt: z.string().nullable().optional(),
+    availableEndAt: z.string().nullable().optional(),
+    cpu: z.string().nullable().optional(),
+    ram: z.string().nullable().optional(),
+    fabricType: z.string().nullable().optional(),
+    storage: z.string().nullable().optional(),
+    internet: z.string().nullable().optional(),
+    networkHardware: z.string().nullable().optional(),
+    buyNowPricePerGpuHour: z.number().positive().nullable().optional(),
+    confirm: z.boolean().optional(),
+});
+export const inventoryUpdateCapability = defineStaffMcpCapability({
+    id: "inventory.update",
+    domain: "listings",
+    roles: ["admin"],
+    description: "Internal staff only: patch editable fields on a forward inventory listing. Requires confirm: true. " +
+        "At least one editable field is required. buyNowPricePerGpuHour may be null to clear the price.",
+    mutation: "preview-confirm",
+    http: { method: "PATCH", path: "/inventory/{inventoryId}" },
+    input: inventoryUpdateInput,
+    execute: async (ctx, input) => {
+        const parsed = inventoryUpdateInput.parse(input);
+        const body = mapBody(parsed, {
+            siteOperator: "site_operator",
+            siteNickname: "site_nickname",
+            gpuType: "gpu_type",
+            nodeCount: "node_count",
+            gpusPerNode: "gpus_per_node",
+            availableFrom: "available_from",
+            availableTo: "available_to",
+            availableStartAt: "available_start_at",
+            availableEndAt: "available_end_at",
+            cpu: "cpu",
+            ram: "ram",
+            fabricType: "fabric_type",
+            storage: "storage",
+            internet: "internet",
+            networkHardware: "network_hardware",
+            buyNowPricePerGpuHour: "buy_now_price_per_gpu_hour",
+        });
+        if (!ctx.confirmed)
+            return preview("inventory.update", body);
+        return ctx.fetch(`/inventory/${seg(parsed.inventoryId)}`, { method: "PATCH", body });
+    },
+});
+export const tenantCreditProfileShowInput = z.object({ tenantId: z.string() });
+export const tenantCreditProfileShowCapability = defineStaffMcpCapability({
+    id: "tenant.credit-profile.show",
+    domain: "users",
+    roles: ["reviewer", "admin"],
+    description: "Internal staff only: show a tenant's credit profile, approval status, and onboarding details. Read-only — does not approve or disapprove.",
+    mutation: "read",
+    http: { method: "GET", path: "/internal/organizations/{tenantId}" },
+    input: tenantCreditProfileShowInput,
+    execute: async (ctx, input) => {
+        const parsed = tenantCreditProfileShowInput.parse(input);
+        return ctx.fetch(`/internal/organizations/${seg(parsed.tenantId)}`, { method: "GET" });
+    },
+});
+export const staffCommerceCapabilities = [
+    reservationCancelCapability,
+    reservationTransferCapability,
+    reservationMachinesListCapability,
+    reservationSshKeyAddCapability,
+    reservationSshKeyRemoveCapability,
+    reservationPublishCapability,
+    bidAcceptCapability,
+    bidRejectCapability,
+    inventoryUpdateCapability,
+    tenantCreditProfileShowCapability,
+];

package/vendor/capabilities/capabilities/staff-fleet.d.ts

@@ -0,0 +1,141 @@
+import { z } from "zod";
+export declare const enrollmentTokenRevokeInput: z.ZodObject<{
+    tokenId: z.ZodString;
+    confirm: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const enrollmentTokenRevokeCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const operatorCreateInput: z.ZodObject<{
+    slug: z.ZodString;
+    displayName: z.ZodString;
+    mode: z.ZodOptional<z.ZodEnum<{
+        managed: "managed";
+        federated: "federated";
+    }>>;
+    status: z.ZodOptional<z.ZodEnum<{
+        active: "active";
+        unavailable: "unavailable";
+        revoked: "revoked";
+    }>>;
+    confirm: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const operatorCreateCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const operatorUpdateInput: z.ZodObject<{
+    operatorId: z.ZodString;
+    displayName: z.ZodOptional<z.ZodString>;
+    slug: z.ZodOptional<z.ZodString>;
+    mode: z.ZodOptional<z.ZodEnum<{
+        managed: "managed";
+        federated: "federated";
+    }>>;
+    status: z.ZodOptional<z.ZodEnum<{
+        active: "active";
+        unavailable: "unavailable";
+        revoked: "revoked";
+    }>>;
+    confirm: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const operatorUpdateCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const operatorDeleteInput: z.ZodObject<{
+    operatorId: z.ZodString;
+    confirm: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const operatorDeleteCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const facilityCreateInput: z.ZodObject<{
+    operatorId: z.ZodString;
+    slug: z.ZodString;
+    displayName: z.ZodString;
+    region: z.ZodString;
+    zone: z.ZodOptional<z.ZodString>;
+    confirm: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const facilityCreateCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const facilityUpdateInput: z.ZodObject<{
+    facilityId: z.ZodString;
+    displayName: z.ZodOptional<z.ZodString>;
+    region: z.ZodOptional<z.ZodString>;
+    zone: z.ZodOptional<z.ZodString>;
+    confirm: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const facilityUpdateCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const nodeShowInput: z.ZodObject<{
+    nodeId: z.ZodString;
+}, z.core.$strip>;
+export declare const nodeShowCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const nodeDetailsUpdateInput: z.ZodObject<{
+    nodeId: z.ZodString;
+    hostname: z.ZodOptional<z.ZodString>;
+    publicLocation: z.ZodOptional<z.ZodString>;
+    facilityId: z.ZodOptional<z.ZodString>;
+    gpuType: z.ZodOptional<z.ZodString>;
+    gpuCount: z.ZodOptional<z.ZodNumber>;
+    ornnMode: z.ZodOptional<z.ZodString>;
+    cpu: z.ZodOptional<z.ZodString>;
+    ram: z.ZodOptional<z.ZodString>;
+    storage: z.ZodOptional<z.ZodString>;
+    fabricType: z.ZodOptional<z.ZodString>;
+    internet: z.ZodOptional<z.ZodString>;
+    networkHardware: z.ZodOptional<z.ZodString>;
+    buyNowPricePerGpuHour: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    confirm: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const nodeDetailsUpdateCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const nodeReserveListingInput: z.ZodObject<{
+    nodeId: z.ZodString;
+    availableFrom: z.ZodOptional<z.ZodString>;
+    availableTo: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    confirm: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const nodeReserveListingCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const nodeTestTriggerInput: z.ZodObject<{
+    nodeId: z.ZodString;
+    burnTimeMinutes: z.ZodOptional<z.ZodNumber>;
+    constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    source: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    confirm: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const nodeTestTriggerCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const nodeTestResultInput: z.ZodObject<{
+    nodeId: z.ZodOptional<z.ZodString>;
+    jobId: z.ZodString;
+    packetId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const nodeTestResultCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const nodeBenchmarkInput: z.ZodObject<{
+    nodeId: z.ZodString;
+}, z.core.$strip>;
+export declare const nodeBenchmarkCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const nodeDeployInput: z.ZodObject<{
+    nodeId: z.ZodString;
+    targetTenantId: z.ZodString;
+    targetAuthUserId: z.ZodOptional<z.ZodString>;
+    networkMode: z.ZodOptional<z.ZodEnum<{
+        public: "public";
+        private: "private";
+    }>>;
+    notes: z.ZodOptional<z.ZodString>;
+    confirm: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const nodeDeployCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const nodeUpdateInput: z.ZodObject<{
+    nodeId: z.ZodString;
+    targetVersion: z.ZodOptional<z.ZodString>;
+    confirm: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const nodeUpdateCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const nodeRebootInput: z.ZodObject<{
+    instanceId: z.ZodString;
+    confirm: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const nodeHardResetInput: z.ZodObject<{
+    instanceId: z.ZodString;
+    confirm: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const nodeRebootCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const nodeHardResetCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const nodeAdminKeyInput: z.ZodObject<{
+    nodeId: z.ZodString;
+    generate: z.ZodOptional<z.ZodBoolean>;
+    confirm: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const nodeAdminKeyCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const staffFleetCapabilities: import("../capability.ts").Capability<unknown, unknown>[];