@ornncompute/cli 0.2.23 → 1.0.25

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

@@ -1,689 +0,0 @@
-import { z } from "zod";
-import { defineStaffMcpCapability, preview } from "../capability.js";
-import { errorTextOf, mapBody, requireUuid, resolveVersion, seg, statusOf } 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(),
-    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. 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 confirmReservedTransfer.",
-    mutation: "preview-confirm",
-    http: { method: "POST", path: "/internal/reservations/{reservationId}/transfer" },
-    input: reservationTransferInput,
-    execute: async (ctx, input) => {
-        const parsed = reservationTransferInput.parse(input);
-        // camelCase: commerce's transferReservationRequest has no snake aliases,
-        // so the previous all-snake body bound nothing but `notes` and every
-        // transfer failed with "targetOrganizationId is required".
-        const body = {
-            targetOrganizationId: requireUuid(parsed.targetTenantId, "targetTenantId"),
-            reservedStrategy: parsed.reservedStrategy,
-            confirmReservedTransfer: parsed.confirmReservedTransfer ?? false,
-            ...mapBody(parsed, { notes: "notes" }),
-        };
-        if (!ctx.confirmed)
-            return preview("reservation.transfer", body);
-        try {
-            return await ctx.fetch(`/internal/reservations/${seg(parsed.reservationId)}/transfer`, {
-                method: "POST",
-                body,
-            });
-        }
-        catch (error) {
-            throw inTenantVocabulary(error);
-        }
-    },
-});
-/**
- * Commerce names the transfer target `targetOrganizationId`; this tool's
- * parameter is `targetTenantId`. Passing the wire name through tells the
- * caller to go fix a parameter that does not exist, so translate it back.
- */
-function inTenantVocabulary(error) {
-    const text = errorTextOf(error);
-    if (!text.includes("targetOrganizationId"))
-        return error;
-    return new Error(text.replaceAll("targetOrganizationId", "targetTenantId"));
-}
-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(),
-    tenantId: z.string(),
-    userId: z.string(),
-    sshKeyId: z.string().optional(),
-    keyId: z.string().optional(),
-    publicKey: z.string().min(1).optional(),
-    label: z.string().optional(),
-    confirm: z.boolean().optional(),
-});
-export const reservationSshKeyAddCapability = defineStaffMcpCapability({
-    id: "reservation.ssh-key.add",
-    domain: "reservations",
-    roles: ["admin"],
-    description: "Internal staff only: attach an SSH key to a reservation for a tenant user. " +
-        "Pass sshKeyId to attach a key the organization already has, or publicKey (with label) to register a new " +
-        "organization key and attach it. Attaching does not itself push the key to live machines; use ssh_key_push for that. " +
-        "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 keyId = parsed.sshKeyId ?? parsed.keyId;
-        if (!keyId && !parsed.publicKey) {
-            throw new Error("Pass sshKeyId to attach an existing organization key, or publicKey to register a new one.");
-        }
-        if (!ctx.confirmed) {
-            return preview("reservation.ssh-key.add", {
-                reservationId: parsed.reservationId,
-                userId: parsed.userId,
-                ...(keyId ? { sshKeyId: keyId } : { publicKey: parsed.publicKey, label: parsed.label }),
-            });
-        }
-        // Commerce attaches an existing authorization key by id; it reads only
-        // sshKeyId/userId. The old body also sent public_key, label and node_id,
-        // which bound nothing, so a publicKey-only call always failed.
-        let sshKeyId = keyId;
-        if (!sshKeyId) {
-            const registered = (await ctx.fetch(`/v1/organizations/${seg(parsed.tenantId)}/ssh-keys`, {
-                method: "POST",
-                body: { public_key: parsed.publicKey, ...mapBody(parsed, { label: "label" }) },
-            }));
-            if (!registered.id) {
-                throw new Error("Authorization did not return an SSH key id.");
-            }
-            sshKeyId = registered.id;
-        }
-        return ctx.fetch(`/internal/v1/reservations/${seg(parsed.reservationId)}/ssh-keys`, {
-            method: "POST",
-            body: { sshKeyId, userId: parsed.userId },
-        });
-    },
-});
-export const reservationSshKeyRemoveInput = z.object({
-    reservationId: z.string(),
-    keyId: z.string(),
-    userId: z.string(),
-    confirm: z.boolean().optional(),
-});
-export const reservationSshKeyRemoveCapability = defineStaffMcpCapability({
-    id: "reservation.ssh-key.remove",
-    domain: "reservations",
-    roles: ["admin"],
-    description: "Internal staff only: detach an SSH key from a reservation for a tenant user. " +
-        "Detaching does not itself remove the key from live machines; use ssh_key_push to resync them. 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);
-        if (!ctx.confirmed) {
-            return preview("reservation.ssh-key.remove", {
-                reservationId: parsed.reservationId,
-                keyId: parsed.keyId,
-                userId: parsed.userId,
-            });
-        }
-        // The handler reads userId from the query string, not the body. Sent as a
-        // body it was dropped and the detach ran unscoped across every user.
-        const result = await ctx.fetch(`/internal/v1/reservations/${seg(parsed.reservationId)}/ssh-keys/${seg(parsed.keyId)}?userId=${seg(parsed.userId)}`, { method: "DELETE" });
-        return (result ?? {
-            removed: true,
-            reservationId: parsed.reservationId,
-            keyId: parsed.keyId,
-            userId: parsed.userId,
-        });
-    },
-});
-export const reservationPublishInput = z.object({
-    reservationId: z.string().optional(),
-    reservation_id: z.string().optional(),
-    version: z.number().int().positive().optional(),
-    awaitDownPayment: z.boolean().optional(),
-    await_down_payment: z.boolean().optional(),
-    confirm: z.boolean().optional(),
-});
-export const reservationPublishCapability = defineStaffMcpCapability({
-    id: "reservation.publish",
-    domain: "reservations",
-    roles: ["admin"],
-    description: "Internal staff only: publish a commerce draft or uncommitted bid reservation 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);
-        const reservationId = parsed.reservationId || parsed.reservation_id;
-        if (!reservationId) {
-            throw new Error("reservationId is required");
-        }
-        const version = await resolveVersion(ctx, `/internal/reservations/${seg(reservationId)}`, parsed.version);
-        const awaitDownPayment = parsed.awaitDownPayment ?? parsed.await_down_payment;
-        const body = {
-            ...(version !== undefined ? { version } : {}),
-            ...(awaitDownPayment !== undefined ? { awaitDownPayment, await_down_payment: awaitDownPayment } : {}),
-        };
-        if (!ctx.confirmed) {
-            return preview("reservation.publish", { reservationId, ...body });
-        }
-        return ctx.fetch(`/internal/reservations/${seg(reservationId)}/publish`, {
-            method: "POST",
-            ...(Object.keys(body).length > 0 ? { body } : {}),
-        });
-    },
-});
-export const reservationShowInput = z.object({ reservationId: z.string() });
-// Accepting a bid inserts its fill reservation as 'uncommitted' (commerce's
-// InsertBidFillReservation): it holds no capacity and carries no invoice until
-// it is published, and buyer-facing reads deliberately filter it out. Staff had
-// no read of their own, so the reservationId that bid.accept returns could not
-// be looked up anywhere at all. These two verbs are the admin-side read, which
-// does surface uncommitted rows.
-export const reservationShowCapability = defineStaffMcpCapability({
-    id: "reservation.show",
-    domain: "reservations",
-    roles: ["reviewer", "admin"],
-    description: "Internal staff only: show one commerce reservation, including draft and uncommitted rows that " +
-        "customer-facing reads hide (an accepted bid's fill reservation is uncommitted until it is published).",
-    mutation: "read",
-    http: { method: "GET", path: "/internal/reservations/{reservationId}" },
-    input: reservationShowInput,
-    execute: async (ctx, input) => {
-        const parsed = reservationShowInput.parse(input);
-        return ctx.fetch(`/internal/reservations/${seg(parsed.reservationId)}`, { method: "GET" });
-    },
-});
-export const reservationListInput = z.object({
-    organizationId: z.string().optional(),
-    status: z.string().optional(),
-    cursor: z.string().optional(),
-    limit: z.number().int().min(1).max(500).optional(),
-});
-export const reservationListCapability = defineStaffMcpCapability({
-    id: "reservation.list",
-    domain: "reservations",
-    roles: ["reviewer", "admin"],
-    description: "Internal staff only: list commerce reservations, optionally filtered by tenant and status. " +
-        "Includes draft and uncommitted rows that customer-facing reads hide.",
-    mutation: "read",
-    http: { method: "GET", path: "/internal/reservations" },
-    input: reservationListInput,
-    execute: async (ctx, input) => {
-        const parsed = reservationListInput.parse(input ?? {});
-        const parts = [];
-        if (parsed.organizationId) {
-            parts.push(`organizationId=${encodeURIComponent(parsed.organizationId)}`);
-        }
-        if (parsed.status)
-            parts.push(`status=${encodeURIComponent(parsed.status)}`);
-        if (parsed.cursor)
-            parts.push(`cursor=${encodeURIComponent(parsed.cursor)}`);
-        if (parsed.limit)
-            parts.push(`limit=${encodeURIComponent(String(parsed.limit))}`);
-        const qs = parts.length > 0 ? `?${parts.join("&")}` : "";
-        return ctx.fetch(`/internal/reservations${qs}`, { method: "GET" });
-    },
-});
-// Kept a plain object because tool registration reads `schema.shape`; the
-// required-ness is enforced in execute below.
-export const bidAcceptInput = z.object({
-    bidId: z.string().optional(),
-    bid_id: z.string().optional(),
-    acceptedGpuCount: z.number().int().min(1).optional(),
-    accepted_gpu_count: z.number().int().min(1).optional(),
-    fillNodeCount: z.number().int().min(1).optional(),
-    fill_node_count: 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. acceptedGpuCount (alias fillNodeCount) is required - commerce " +
-        "has no default; pass the bid's full nodeCount to fill it completely, or a smaller number for a partial " +
-        "fill. Mirrors the internal dashboard's Accept action. Automatically publishes the resulting reservation " +
-        "so it holds capacity and is immediately visible to customer reads.",
-    mutation: "preview-confirm",
-    http: { method: "POST", path: "/internal/bids/{bidId}/accept" },
-    input: bidAcceptInput,
-    execute: async (ctx, input) => {
-        const parsed = bidAcceptInput.parse(input);
-        const bidId = parsed.bidId || parsed.bid_id;
-        if (!bidId) {
-            throw new Error("bidId is required");
-        }
-        const count = parsed.acceptedGpuCount ?? parsed.accepted_gpu_count ?? parsed.fillNodeCount ?? parsed.fill_node_count;
-        // commerce's acceptBidRequest.Validate rejects a missing count outright
-        // (services/commerce/internal/api/admin/bid_types.go), so refuse here
-        // rather than sending a call that always 400s.
-        if (count === undefined) {
-            throw new Error("acceptedGpuCount (or fillNodeCount) is required; commerce has no default fill count. Pass the bid's nodeCount to fill it completely.");
-        }
-        const body = { accepted_gpu_count: count };
-        if (!ctx.confirmed)
-            return preview("bid.accept", { bidId, ...body });
-        const accepted = (await ctx.fetch(`/internal/bids/${seg(bidId)}/accept`, { method: "POST", body }));
-        const reservationId = (accepted?.reservationId ?? accepted?.reservation_id);
-        if (reservationId) {
-            try {
-                await ctx.fetch(`/internal/reservations/${seg(reservationId)}/publish`, {
-                    method: "POST",
-                    body: {},
-                });
-            }
-            catch (publishErr) {
-                return {
-                    ...accepted,
-                    publishWarning: `Bid accepted successfully, but automatic reservation publish failed: ${publishErr instanceof Error ? publishErr.message : String(publishErr)}. Use admin_reservation_publish to retry.`,
-                };
-            }
-        }
-        return accepted;
-    },
-});
-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 bidShowInput = z.object({
-    bidId: z.string().optional(),
-    bid_id: z.string().optional(),
-});
-export const bidShowCapability = defineStaffMcpCapability({
-    id: "bid.show",
-    domain: "bids",
-    roles: ["reviewer", "admin"],
-    description: "Internal staff only: fetch a single buyer bid by ID.",
-    mutation: "read",
-    http: { method: "GET", path: "/internal/bids/{bidId}" },
-    input: bidShowInput,
-    execute: async (ctx, input) => {
-        const parsed = bidShowInput.parse(input);
-        const bidId = parsed.bidId || parsed.bid_id;
-        if (!bidId) {
-            throw new Error("bidId is required");
-        }
-        return ctx.fetch(`/internal/bids/${seg(bidId)}`, { method: "GET" });
-    },
-});
-/** Commerce parses listing windows as RFC3339 timestamps, not bare dates. */
-function rfc3339(value) {
-    const trimmed = value.trim();
-    if (!trimmed.includes("T"))
-        return `${trimmed}T00:00:00Z`;
-    return trimmed.endsWith("Z") || /[+-]\d{2}:\d{2}$/.test(trimmed) ? trimmed : `${trimmed}Z`;
-}
-export const inventoryUpdateInput = z.object({
-    inventoryId: z.string(),
-    version: z
-        .number()
-        .int()
-        .positive()
-        .optional()
-        .describe("Optimistic-concurrency version. Read from the listing when omitted."),
-    operatorId: z.string().min(1).optional(),
-    facilityId: 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().optional(),
-    availableTo: z.string().optional(),
-    availableStartAt: z.string().optional(),
-    availableEndAt: z.string().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(),
-    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. " +
-        "operatorId/facilityId take UUIDs. Site nickname and network hardware are not patchable on a listing.",
-    mutation: "preview-confirm",
-    http: { method: "PATCH", path: "/inventory/{inventoryId}" },
-    input: inventoryUpdateInput,
-    execute: async (ctx, input) => {
-        const parsed = inventoryUpdateInput.parse(input);
-        const body = mapBody(parsed, {
-            operatorId: "operatorId",
-            facilityId: "facilityId",
-            gpuType: "gpuType",
-            nodeCount: "capacityNodes",
-            gpusPerNode: "gpusPerNode",
-            cpu: "cpu",
-            ram: "ram",
-            fabricType: "fabricType",
-            storage: "storage",
-            internet: "internet",
-        });
-        const startAt = parsed.availableStartAt ?? parsed.availableFrom;
-        if (startAt !== undefined)
-            body.startAt = rfc3339(startAt);
-        const endAt = parsed.availableEndAt ?? parsed.availableTo;
-        if (endAt !== undefined)
-            body.endAt = rfc3339(endAt);
-        // The rate is a decimal string on the wire; null clears the buy-now price.
-        if (parsed.buyNowPricePerGpuHour !== undefined) {
-            body.buyNowRatePerGpuHour =
-                parsed.buyNowPricePerGpuHour === null ? null : String(parsed.buyNowPricePerGpuHour);
-        }
-        // commerce's patchListingRequest.Validate refuses version <= 0, and the
-        // schema never carried one, so every update 400'd with "missing version".
-        // Resolve it the way inventory.delist does.
-        body.version = await resolveVersion(ctx, `/inventory/${seg(parsed.inventoryId)}`, parsed.version);
-        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);
-        try {
-            return await ctx.fetch(`/internal/organizations/${seg(parsed.tenantId)}`, { method: "GET" });
-        }
-        catch (error) {
-            // Commerce holds a projection, not the roster: an organization only
-            // appears there once authorization has pushed it across, so this read
-            // returned ORGANIZATION_NOT_FOUND for live tenants that had never
-            // transacted. Authorization owns the record, so fall back to it and say
-            // plainly that no commerce credit profile exists yet.
-            if (statusOf(error) !== 404)
-                throw error;
-            const organization = await ctx.fetch(`/v1/organizations/${seg(parsed.tenantId)}`, {
-                method: "GET",
-            });
-            return { organization, creditProfile: null, creditProfileSource: "authorization" };
-        }
-    },
-});
-export const reservationDraftCreateInput = z.object({
-    organizationId: z.string(),
-    nodeCount: z.number().int().positive(),
-    startAt: z.string(),
-    endAt: z.string(),
-    billingMode: z.string().default("reserved"),
-    pricePerGpuHr: z.string(),
-    listingId: z.string().optional(),
-    accessMode: z.string().optional(),
-    notes: z.string().optional(),
-    confirm: z.boolean().optional(),
-});
-export const reservationDraftCreateCapability = defineStaffMcpCapability({
-    id: "reservation.draft-create",
-    domain: "reservations",
-    roles: ["admin"],
-    description: "Internal staff only: create a draft reservation in Commerce. Requires confirm: true.",
-    mutation: "preview-confirm",
-    http: { method: "POST", path: "/internal/reservations" },
-    input: reservationDraftCreateInput,
-    execute: async (ctx, input) => {
-        const parsed = reservationDraftCreateInput.parse(input);
-        const body = {
-            organizationId: parsed.organizationId,
-            nodeCount: parsed.nodeCount,
-            startAt: parsed.startAt,
-            endAt: parsed.endAt,
-            billingMode: parsed.billingMode,
-            pricePerGpuHr: parsed.pricePerGpuHr,
-            draft: true,
-            ...mapBody(parsed, {
-                listingId: "listingId",
-                accessMode: "accessMode",
-                notes: "notes",
-            }),
-        };
-        if (!ctx.confirmed)
-            return preview("reservation.draft-create", body);
-        return ctx.fetch("/internal/reservations", { method: "POST", body });
-    },
-});
-export const reservationUpdateInput = z.object({
-    reservationId: z.string(),
-    startAt: z.string().optional(),
-    endAt: z.string().optional(),
-    nodeCount: z.number().int().positive().optional(),
-    notes: z.string().nullable().optional(),
-    expectedStatus: z.string().optional(),
-    confirm: z.boolean().optional(),
-});
-export const reservationUpdateCapability = defineStaffMcpCapability({
-    id: "reservation.update",
-    domain: "reservations",
-    roles: ["admin"],
-    description: "Internal staff only: update an existing reservation's dates, node count, notes, or draft status. Requires confirm: true.",
-    mutation: "preview-confirm",
-    http: { method: "PATCH", path: "/internal/reservations/{reservationId}" },
-    input: reservationUpdateInput,
-    execute: async (ctx, input) => {
-        const parsed = reservationUpdateInput.parse(input);
-        const body = mapBody(parsed, {
-            startAt: "startAt",
-            endAt: "endAt",
-            nodeCount: "nodeCount",
-            notes: "notes",
-            expectedStatus: "expectedStatus",
-        });
-        if (!ctx.confirmed) {
-            return preview("reservation.update", { reservationId: parsed.reservationId, ...body });
-        }
-        return ctx.fetch(`/internal/reservations/${seg(parsed.reservationId)}`, {
-            method: "PATCH",
-            body,
-        });
-    },
-});
-export const reservationActivateInput = z.object({
-    reservationId: z.string(),
-    version: z.number().int().optional(),
-    confirm: z.boolean().optional(),
-});
-export const reservationActivateCapability = defineStaffMcpCapability({
-    id: "reservation.activate",
-    domain: "reservations",
-    roles: ["admin"],
-    description: "Internal staff only: activate a confirmed reservation. Requires confirm: true.",
-    mutation: "preview-confirm",
-    http: { method: "POST", path: "/internal/reservations/{reservationId}/activate" },
-    input: reservationActivateInput,
-    execute: async (ctx, input) => {
-        const parsed = reservationActivateInput.parse(input);
-        const body = {
-            version: await resolveVersion(ctx, `/internal/reservations/${seg(parsed.reservationId)}`, parsed.version),
-        };
-        if (!ctx.confirmed)
-            return preview("reservation.activate", { reservationId: parsed.reservationId, ...body });
-        return ctx.fetch(`/internal/reservations/${seg(parsed.reservationId)}/activate`, {
-            method: "POST",
-            body,
-        });
-    },
-});
-export const reservationCompleteInput = z.object({
-    reservationId: z.string(),
-    version: z.number().int().optional(),
-    confirm: z.boolean().optional(),
-});
-export const reservationCompleteCapability = defineStaffMcpCapability({
-    id: "reservation.complete",
-    domain: "reservations",
-    roles: ["admin"],
-    description: "Internal staff only: complete an active reservation. Requires confirm: true.",
-    mutation: "preview-confirm",
-    http: { method: "POST", path: "/internal/reservations/{reservationId}/complete" },
-    input: reservationCompleteInput,
-    execute: async (ctx, input) => {
-        const parsed = reservationCompleteInput.parse(input);
-        const body = {
-            version: await resolveVersion(ctx, `/internal/reservations/${seg(parsed.reservationId)}`, parsed.version),
-        };
-        if (!ctx.confirmed)
-            return preview("reservation.complete", { reservationId: parsed.reservationId, ...body });
-        return ctx.fetch(`/internal/reservations/${seg(parsed.reservationId)}/complete`, {
-            method: "POST",
-            body,
-        });
-    },
-});
-export const inventoryDelistInput = z.object({
-    inventoryId: z.string(),
-    version: z.number().int().positive().optional(),
-    confirm: z.boolean().optional(),
-});
-export const inventoryDelistCapability = defineStaffMcpCapability({
-    id: "inventory.delist",
-    domain: "listings",
-    roles: ["admin"],
-    description: "Internal staff only: delist an inventory listing. Sets its state to delisted. Requires confirm: true.",
-    mutation: "preview-confirm",
-    http: { method: "PATCH", path: "/inventory/{inventoryId}" },
-    input: inventoryDelistInput,
-    execute: async (ctx, input) => {
-        const parsed = inventoryDelistInput.parse(input);
-        const body = {
-            state: "delisted",
-            version: await resolveVersion(ctx, `/inventory/${seg(parsed.inventoryId)}`, parsed.version),
-        };
-        if (!ctx.confirmed)
-            return preview("inventory.delist", { inventoryId: parsed.inventoryId, ...body });
-        return ctx.fetch(`/inventory/${seg(parsed.inventoryId)}`, {
-            method: "PATCH",
-            body,
-        });
-    },
-});
-export const billingInvoicesListInput = z.object({
-    status: z
-        .enum(["due", "open", "paid", "draft", "void", "uncollectible"])
-        .default("due")
-        .optional(),
-    cursor: z.string().optional(),
-    limit: z.number().int().positive().max(100).optional(),
-});
-export const billingInvoicesListCapability = defineStaffMcpCapability({
-    id: "billing.invoices-list",
-    domain: "billing",
-    roles: ["reviewer", "admin"],
-    description: "Internal staff only: list commerce invoices with an optional status filter (defaults to due).",
-    mutation: "read",
-    http: { method: "GET", path: "/internal/invoices" },
-    input: billingInvoicesListInput,
-    execute: async (ctx, input) => {
-        const parsed = billingInvoicesListInput.parse(input ?? {});
-        const parts = [];
-        if (parsed.status)
-            parts.push(`status=${encodeURIComponent(parsed.status)}`);
-        if (parsed.cursor)
-            parts.push(`cursor=${encodeURIComponent(parsed.cursor)}`);
-        if (parsed.limit)
-            parts.push(`limit=${encodeURIComponent(String(parsed.limit))}`);
-        const qs = parts.length > 0 ? `?${parts.join("&")}` : "";
-        return ctx.fetch(`/internal/invoices${qs}`, { method: "GET" });
-    },
-});
-export const staffCommerceCapabilities = [
-    reservationShowCapability,
-    reservationListCapability,
-    reservationCancelCapability,
-    reservationTransferCapability,
-    reservationMachinesListCapability,
-    reservationSshKeyAddCapability,
-    reservationSshKeyRemoveCapability,
-    reservationPublishCapability,
-    reservationDraftCreateCapability,
-    reservationUpdateCapability,
-    reservationActivateCapability,
-    reservationCompleteCapability,
-    bidShowCapability,
-    bidAcceptCapability,
-    bidRejectCapability,
-    inventoryUpdateCapability,
-    inventoryDelistCapability,
-    tenantCreditProfileShowCapability,
-    billingInvoicesListCapability,
-];