@ornncompute/cli 0.2.7 → 0.2.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ornncompute/cli",
-  "version": "0.2.7",
+  "version": "0.2.8",
   "description": "Command-line interface for Ornn compute access workflows.",
   "type": "module",
   "bin": {

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

@@ -0,0 +1,27 @@
+import { z } from "zod";
+export declare const sshKeyPushInput: z.ZodObject<{
+    instanceId: z.ZodString;
+    reservationId: z.ZodString;
+    tenantId: z.ZodString;
+    authUserId: z.ZodString;
+    sshKeyIds: z.ZodArray<z.ZodString>;
+    requestId: z.ZodOptional<z.ZodString>;
+    confirm: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const sshKeyPushCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const sshKeyAddInput: z.ZodObject<{
+    reservationId: z.ZodString;
+    tenantId: z.ZodString;
+    authUserId: z.ZodString;
+    publicKey: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    confirm: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const sshKeyAddCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const sshKeyRevokeInput: z.ZodObject<{
+    tenantId: z.ZodString;
+    keyId: z.ZodString;
+    confirm: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const sshKeyRevokeCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const staffAccessCapabilities: import("../capability.ts").Capability<unknown, unknown>[];

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

@@ -0,0 +1,192 @@
+import { z } from "zod";
+import { defineStaffMcpCapability, preview } from "../capability.js";
+import { mapBody, seg, statusOf } from "./staff-shared.js";
+// Staff SSH-access verbs. MCP-only — see `defineStaffMcpCapability`.
+//
+// Field contracts from the internal SSH-key routes:
+// - push: PATCH /internal/nodes/{instanceId}/keys (or /internal/pods/... for a VM)
+//   body { ssh_authorized_keys, request_id? }
+// - add: POST /internal/v1/reservations/{reservationId}/ssh-keys
+//   body { public_key, label? }, after authorization owns the public key
+// - revoke: DELETE /v1/organizations/{tenantId}/ssh-keys/{keyId}
+//
+// The routes never forward tenantId/authUserId to the orchestrator as-is — they use them to
+// verify the reservation actually belongs to that organization, and that authUserId is a member
+// of it (commerce GET /internal/v1/reservations/{id} + authorization GET
+// /internal/organizations/{id}/members). Those two checks live in
+// `assertReservationOwnedByTenantUser` below so every surface runs them.
+/** Acts as the caller for a write the tenant's own user is nominally making. */
+const AUTH_USER_HEADER = "X-Auth-User-Id";
+async function assertReservationOwnedByTenantUser(ctx, options) {
+    let reservation;
+    try {
+        reservation = (await ctx.fetch(`/internal/v1/reservations/${seg(options.reservationId)}`, {
+            method: "GET",
+        }));
+    }
+    catch (error) {
+        if (statusOf(error) === 404) {
+            throw new Error("Reservation not found.");
+        }
+        throw error;
+    }
+    if (!reservation?.reservationId) {
+        throw new Error("Reservation not found.");
+    }
+    const organizationId = reservation.organizationId ?? reservation.tenantId;
+    if (organizationId !== options.tenantId) {
+        throw new Error("Reservation does not belong to that tenant.");
+    }
+    const members = (await ctx.fetch(`/internal/organizations/${seg(options.tenantId)}/members`, {
+        method: "GET",
+    }));
+    if (!members.some((member) => member.user_id === options.authUserId)) {
+        throw new Error("Selected SSH key owner is not a member of this tenant.");
+    }
+}
+async function assertMachineBelongsToReservation(ctx, options) {
+    const listed = (await ctx.fetch(`/internal/nodes?reservation_id=${seg(options.reservationId)}`, {
+        method: "GET",
+    }));
+    if (!(listed.nodes ?? []).some((node) => node.node_id === options.instanceId || node.id === options.instanceId)) {
+        throw new Error("Machine does not belong to that reservation.");
+    }
+}
+export const sshKeyPushInput = z.object({
+    instanceId: z.string(),
+    reservationId: z.string(),
+    tenantId: z.string(),
+    authUserId: z.string(),
+    sshKeyIds: z.array(z.string()).min(1),
+    requestId: z.string().optional(),
+    confirm: z.boolean().optional(),
+});
+export const sshKeyPushCapability = defineStaffMcpCapability({
+    id: "ssh-key.push",
+    domain: "access",
+    roles: ["admin"],
+    description: "Internal staff only: push selected reservation SSH keys onto a live machine. " +
+        "This grants remote access to a live machine. Requires confirm: true.",
+    mutation: "preview-confirm",
+    http: { method: "PATCH", path: "/internal/nodes/{instanceId}/keys" },
+    input: sshKeyPushInput,
+    execute: async (ctx, input) => {
+        const parsed = sshKeyPushInput.parse(input);
+        if (!ctx.confirmed) {
+            return preview("ssh-key.push", {
+                instanceId: parsed.instanceId,
+                reservationId: parsed.reservationId,
+                sshKeyIds: parsed.sshKeyIds,
+            });
+        }
+        // Sequential, not Promise.all: this is a fail-fast authorization gate, not an independent
+        // read pair. If the reservation doesn't belong to this tenant/user, there's no reason to
+        // spend a second round trip checking machine membership.
+        await assertReservationOwnedByTenantUser(ctx, {
+            reservationId: parsed.reservationId,
+            tenantId: parsed.tenantId,
+            authUserId: parsed.authUserId,
+        });
+        await assertMachineBelongsToReservation(ctx, {
+            reservationId: parsed.reservationId,
+            instanceId: parsed.instanceId,
+        });
+        const listed = (await ctx.fetch(`/v1/organizations/${seg(parsed.tenantId)}/ssh-keys`, {
+            method: "GET",
+        }));
+        const wanted = new Set(parsed.sshKeyIds);
+        const sshAuthorizedKeys = (listed.ssh_keys ?? [])
+            .filter((key) => key.id &&
+            wanted.has(key.id) &&
+            key.status === "active" &&
+            !key.revoked_at &&
+            Boolean(key.public_key?.trim()))
+            .map((key) => key.public_key.trim());
+        const body = {
+            ssh_authorized_keys: sshAuthorizedKeys,
+            ...mapBody(parsed, { requestId: "request_id" }),
+        };
+        let keysPath = `/internal/nodes/${seg(parsed.instanceId)}/keys`;
+        try {
+            const pod = (await ctx.fetch(`/internal/pods/${seg(parsed.instanceId)}`, {
+                method: "GET",
+            }));
+            if (pod.kind === "virtual-machine") {
+                keysPath = `/internal/pods/${seg(parsed.instanceId)}/keys`;
+            }
+        }
+        catch {
+            // instanceId is a host node
+        }
+        return ctx.fetch(keysPath, {
+            method: "PATCH",
+            body,
+            headers: { [AUTH_USER_HEADER]: parsed.authUserId },
+        });
+    },
+});
+export const sshKeyAddInput = z.object({
+    reservationId: z.string(),
+    tenantId: z.string(),
+    authUserId: z.string(),
+    publicKey: z.string().min(1),
+    label: z.string().optional(),
+    confirm: z.boolean().optional(),
+});
+export const sshKeyAddCapability = defineStaffMcpCapability({
+    id: "ssh-key.add",
+    domain: "access",
+    roles: ["admin"],
+    description: "Internal staff only: register an SSH public key on a reservation for a tenant user. Requires confirm: true.",
+    mutation: "preview-confirm",
+    http: { method: "POST", path: "/internal/v1/reservations/{reservationId}/ssh-keys" },
+    input: sshKeyAddInput,
+    execute: async (ctx, input) => {
+        const parsed = sshKeyAddInput.parse(input);
+        const body = {
+            public_key: parsed.publicKey,
+            ...mapBody(parsed, { label: "label" }),
+        };
+        if (!ctx.confirmed) {
+            return preview("ssh-key.add", { reservationId: parsed.reservationId, ...body });
+        }
+        await assertReservationOwnedByTenantUser(ctx, {
+            reservationId: parsed.reservationId,
+            tenantId: parsed.tenantId,
+            authUserId: parsed.authUserId,
+        });
+        return ctx.fetch(`/internal/v1/reservations/${seg(parsed.reservationId)}/ssh-keys`, {
+            method: "POST",
+            body,
+            headers: { [AUTH_USER_HEADER]: parsed.authUserId },
+        });
+    },
+});
+export const sshKeyRevokeInput = z.object({
+    tenantId: z.string(),
+    keyId: z.string(),
+    confirm: z.boolean().optional(),
+});
+export const sshKeyRevokeCapability = defineStaffMcpCapability({
+    id: "ssh-key.revoke",
+    domain: "access",
+    roles: ["admin"],
+    description: "Internal staff only: revoke (delete) a tenant-scoped SSH key. Requires confirm: true.",
+    mutation: "preview-confirm",
+    http: { method: "DELETE", path: "/v1/organizations/{tenantId}/ssh-keys/{keyId}" },
+    input: sshKeyRevokeInput,
+    execute: async (ctx, input) => {
+        const parsed = sshKeyRevokeInput.parse(input);
+        if (!ctx.confirmed) {
+            return preview("ssh-key.revoke", { tenantId: parsed.tenantId, keyId: parsed.keyId });
+        }
+        return ctx.fetch(`/v1/organizations/${seg(parsed.tenantId)}/ssh-keys/${seg(parsed.keyId)}`, {
+            method: "DELETE",
+        });
+    },
+});
+export const staffAccessCapabilities = [
+    sshKeyPushCapability,
+    sshKeyAddCapability,
+    sshKeyRevokeCapability,
+];

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

@@ -0,0 +1,83 @@
+import { z } from "zod";
+export declare const reservationCancelInput: z.ZodObject<{
+    reservationId: z.ZodString;
+    confirm: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const reservationCancelCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const reservationTransferInput: z.ZodObject<{
+    reservationId: z.ZodString;
+    targetTenantId: z.ZodString;
+    targetAuthUserId: z.ZodOptional<z.ZodString>;
+    nodeId: z.ZodOptional<z.ZodString>;
+    reservedStrategy: z.ZodEnum<{
+        reject: "reject";
+        park: "park";
+    }>;
+    confirmReservedTransfer: z.ZodOptional<z.ZodBoolean>;
+    notes: z.ZodOptional<z.ZodString>;
+    confirm: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const reservationTransferCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const reservationMachinesListInput: z.ZodObject<{
+    reservationId: z.ZodString;
+}, z.core.$strip>;
+export declare const reservationMachinesListCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const reservationSshKeyAddInput: z.ZodObject<{
+    reservationId: z.ZodString;
+    userId: z.ZodString;
+    publicKey: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    nodeId: z.ZodOptional<z.ZodString>;
+    confirm: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const reservationSshKeyAddCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const reservationSshKeyRemoveInput: z.ZodObject<{
+    reservationId: z.ZodString;
+    keyId: z.ZodString;
+    userId: z.ZodString;
+    nodeId: z.ZodOptional<z.ZodString>;
+    confirm: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const reservationSshKeyRemoveCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const reservationPublishInput: z.ZodObject<{
+    reservationId: z.ZodString;
+    confirm: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const reservationPublishCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const bidAcceptInput: z.ZodObject<{
+    bidId: z.ZodString;
+    acceptedGpuCount: z.ZodOptional<z.ZodNumber>;
+    confirm: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const bidAcceptCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const bidRejectInput: z.ZodObject<{
+    bidId: z.ZodString;
+    confirm: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const bidRejectCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const inventoryUpdateInput: z.ZodObject<{
+    inventoryId: z.ZodString;
+    siteOperator: z.ZodOptional<z.ZodString>;
+    siteNickname: z.ZodOptional<z.ZodString>;
+    gpuType: z.ZodOptional<z.ZodString>;
+    nodeCount: z.ZodOptional<z.ZodNumber>;
+    gpusPerNode: z.ZodOptional<z.ZodNumber>;
+    availableFrom: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    availableTo: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    availableStartAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    availableEndAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    cpu: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    ram: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    fabricType: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    storage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    internet: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    networkHardware: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    buyNowPricePerGpuHour: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    confirm: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const inventoryUpdateCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const tenantCreditProfileShowInput: z.ZodObject<{
+    tenantId: z.ZodString;
+}, z.core.$strip>;
+export declare const tenantCreditProfileShowCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const staffCommerceCapabilities: import("../capability.ts").Capability<unknown, unknown>[];

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,
+];