@ornncompute/cli 1.0.25 → 1.0.34

package/vendor/capabilities/capabilities/markets.js

@@ -0,0 +1,449 @@
+import { z } from "zod";
+import { defineCapability } from "../capability.js";
+import { gpuDisplay, loadHardwareCatalog } from "../spec-catalog.js";
+import { consent, idempotencyHeaders, microUsdLabel, positionals, query, seg, } from "./market-shared.js";
+// Markets verbs: one capability per `/v1/markets` route. Spot order books are
+// per GPU slug; schedules are per listing. Prices are integer micro-USD per
+// GPU-hour, exactly as Markets reads and writes them.
+const BASE = "/v1/markets";
+function help(command, outcome, human, automation, related, order, acceptedReferences = []) {
+    return {
+        arguments: "semantic",
+        audience: "customer",
+        category: "resource",
+        command,
+        outcome,
+        human,
+        automation,
+        acceptedReferences,
+        related,
+        order,
+    };
+}
+const microUsd = z.coerce.number().int().positive();
+export const spotBooksInput = z.object({ $positionals: positionals });
+export const spotBooksCapability = defineCapability({
+    id: "spot.books",
+    domain: "markets",
+    roles: ["user"],
+    description: "List the spot order books, one per GPU type, with the best bid and ask in micro-USD per GPU-hour.",
+    mutation: "read",
+    http: { method: "GET", path: `${BASE}/spot/books` },
+    input: spotBooksInput,
+    cli: {
+        command: ["spot", "books"],
+        vnext: help(["spot", "books"], "List spot order books by GPU type with their best bid and ask.", "ornn spot books", "ornn spot books --format json", ["spot book", "spot bid"], 30),
+    },
+    slack: false,
+    execute: async (ctx) => ctx.fetch(`${BASE}/spot/books`, { method: "GET" }),
+});
+export const spotBookInput = z.object({
+    $positionals: positionals,
+    gpuSlug: z.string().min(1).describe("Catalog GPU slug, for example nvidia_h100_sxm."),
+});
+export const spotBookCapability = defineCapability({
+    id: "spot.book",
+    domain: "markets",
+    roles: ["user"],
+    description: "Show one spot order book's depth: GPUs and order counts at each bid and ask price level.",
+    mutation: "read",
+    http: { method: "GET", path: `${BASE}/spot/books/{gpuSlug}` },
+    input: spotBookInput,
+    cli: {
+        command: ["spot", "book"],
+        vnext: help(["spot", "book"], "Show bid and ask depth for one GPU type.", "ornn spot book --gpu-slug <slug>", "ornn spot book --gpu-slug <slug> --format json", ["spot books", "spot trades", "spot bid"], 31, ["catalog GPU slug"]),
+    },
+    slack: false,
+    execute: async (ctx, input) => {
+        const parsed = spotBookInput.parse(input);
+        return ctx.fetch(`${BASE}/spot/books/${seg(parsed.gpuSlug)}`, { method: "GET" });
+    },
+});
+export const spotTradesCapability = defineCapability({
+    id: "spot.trades",
+    domain: "markets",
+    roles: ["user"],
+    description: "List recent spot trades for one GPU type: price, GPUs and time, with no identities.",
+    mutation: "read",
+    http: { method: "GET", path: `${BASE}/spot/books/{gpuSlug}/trades` },
+    input: spotBookInput,
+    cli: {
+        command: ["spot", "trades"],
+        vnext: help(["spot", "trades"], "List recent spot fills for one GPU type.", "ornn spot trades --gpu-slug <slug>", "ornn spot trades --gpu-slug <slug> --format json", ["spot book"], 32, ["catalog GPU slug"]),
+    },
+    slack: false,
+    execute: async (ctx, input) => {
+        const parsed = spotBookInput.parse(input);
+        return ctx.fetch(`${BASE}/spot/books/${seg(parsed.gpuSlug)}/trades`, { method: "GET" });
+    },
+});
+export const spotBidInput = z
+    .object({
+    $positionals: positionals,
+    gpuSlug: z.string().min(1).describe("Catalog GPU slug, for example nvidia_h100_sxm."),
+    gpus: z.coerce
+        .number()
+        .int()
+        .min(1)
+        .max(8)
+        .describe("GPUs on one node, 1-8. To buy N whole nodes, place N bids of 8 GPUs."),
+    orderType: z
+        .enum(["limit", "market"])
+        .default("limit")
+        .describe("A limit bid rests until filled; a market bid fills now or is cancelled."),
+    pricePerGpuHourMicroUsd: microUsd
+        .optional()
+        .describe("Limit price in micro-USD per GPU-hour (1000000 = $1.00). Required for limit bids."),
+    idempotencyKey: z.string().min(1).max(200).optional(),
+    confirm: z.boolean().optional(),
+})
+    .refine((bid) => (bid.orderType === "limit") === (bid.pricePerGpuHourMicroUsd !== undefined), {
+    message: "A limit bid needs pricePerGpuHourMicroUsd; a market bid takes no price.",
+    path: ["pricePerGpuHourMicroUsd"],
+});
+export const spotBidCapability = defineCapability({
+    id: "spot.bid",
+    domain: "markets",
+    roles: ["user"],
+    description: "Place a spot bid for 1-8 GPUs on one node. A filled bid becomes a running spot reservation, " +
+        "prepaid hourly from Ornn credits first and then the saved card; the side that takes a resting order pays the transaction fee. Requires confirm: true.",
+    mutation: "preview-confirm",
+    http: { method: "POST", path: `${BASE}/spot/orders` },
+    input: spotBidInput,
+    cli: {
+        command: ["spot", "bid"],
+        vnext: help(["spot", "bid"], "Place one spot bid for 1-8 GPUs on a single node.", "ornn spot bid --gpu-slug <slug> --gpus <1-8> [--order-type limit|market] [--price-per-gpu-hour-micro-usd <n>]", "ornn spot bid --gpu-slug <slug> --gpus 8 --price-per-gpu-hour-micro-usd 2500000 --yes --format json", ["spot orders", "spot cancel"], 33, ["catalog GPU slug"]),
+    },
+    slack: false,
+    execute: async (ctx, input) => {
+        const parsed = spotBidInput.parse(input);
+        const body = {
+            gpuSlug: parsed.gpuSlug,
+            gpus: parsed.gpus,
+            orderType: parsed.orderType,
+            ...(parsed.pricePerGpuHourMicroUsd !== undefined
+                ? { pricePerGpuHourMicroUsd: parsed.pricePerGpuHourMicroUsd }
+                : {}),
+        };
+        // Only the CLI review renders terms; MCP and Slack preview the payload.
+        const hardware = ctx.cli?.interaction
+            ? await loadHardwareCatalog(ctx.fetch).catch(() => null)
+            : null;
+        const gate = await consent(ctx, "spot.bid", "Place spot bid", [
+            { label: "GPU type", value: gpuDisplay(hardware?.terms ?? [], parsed.gpuSlug) },
+            { label: "GPUs", value: String(parsed.gpus) },
+            { label: "Order", value: parsed.orderType },
+            { label: "Limit price", value: microUsdLabel(parsed.pricePerGpuHourMicroUsd) },
+        ], body);
+        if (gate)
+            return gate;
+        return ctx.fetch(`${BASE}/spot/orders`, {
+            method: "POST",
+            body,
+            headers: idempotencyHeaders(ctx, parsed.idempotencyKey),
+        });
+    },
+});
+export const spotOrdersInput = z.object({ $positionals: positionals });
+export const spotOrdersCapability = defineCapability({
+    id: "spot.orders",
+    domain: "markets",
+    roles: ["user"],
+    description: "List this organization's spot bids (resting, running and ended) and the asks its listings have on the books.",
+    mutation: "read",
+    http: { method: "GET", path: `${BASE}/spot/orders` },
+    input: spotOrdersInput,
+    cli: {
+        command: ["spot", "orders"],
+        vnext: help(["spot", "orders"], "List your organization's spot bids and listing asks.", "ornn spot orders", "ornn spot orders --format json", ["spot bid", "spot cancel"], 34),
+    },
+    slack: false,
+    execute: async (ctx) => ctx.fetch(`${BASE}/spot/orders`, { method: "GET" }),
+});
+export const spotCancelInput = z.object({
+    $positionals: positionals,
+    orderId: z
+        .string()
+        .uuid()
+        .describe("A spot bid ID; for a running bid this is also its reservation ID."),
+    confirm: z.boolean().optional(),
+});
+export const spotCancelCapability = defineCapability({
+    id: "spot.cancel",
+    domain: "markets",
+    roles: ["user"],
+    description: "Cancel a resting spot bid, or end a running spot reservation (the buyer or the seller may end it; the GPUs go back on the book). Requires confirm: true.",
+    mutation: "preview-confirm",
+    http: { method: "DELETE", path: `${BASE}/spot/orders/{orderId}` },
+    input: spotCancelInput,
+    cli: {
+        command: ["spot", "cancel"],
+        vnext: help(["spot", "cancel"], "Cancel a resting bid or end a running spot reservation.", "ornn spot cancel --order-id <id>", "ornn spot cancel --order-id <id> --yes --format json", ["spot orders"], 35, ["spot order ID", "spot reservation ID"]),
+    },
+    slack: false,
+    execute: async (ctx, input) => {
+        const parsed = spotCancelInput.parse(input);
+        const gate = await consent(ctx, "spot.cancel", "Cancel spot order", [
+            { label: "Order", value: parsed.orderId },
+            {
+                label: "Consequence",
+                value: "A resting bid is cancelled; a running spot reservation ends and its machine stops.",
+            },
+        ], { orderId: parsed.orderId });
+        if (gate)
+            return gate;
+        return ctx.fetch(`${BASE}/spot/orders/${seg(parsed.orderId)}`, { method: "DELETE" });
+    },
+});
+export const schedulesListInput = z.object({
+    $positionals: positionals,
+    listingKind: z.enum(["primary", "secondary"]).optional(),
+    gpuSlug: z.string().min(1).optional(),
+    from: z.string().min(1).optional().describe("RFC 3339 lower bound for the schedule window."),
+    to: z.string().min(1).optional().describe("RFC 3339 upper bound for the schedule window."),
+});
+export const schedulesListCapability = defineCapability({
+    id: "schedules.list",
+    domain: "markets",
+    roles: ["user"],
+    description: "List reservable schedules with their available windows (sold windows removed). Primary schedules are shown only to approved organizations; secondary (relisted) schedules are open to every signed-in organization.",
+    mutation: "read",
+    http: { method: "GET", path: `${BASE}/schedules` },
+    input: schedulesListInput,
+    cli: {
+        command: ["schedules", "list"],
+        vnext: help(["schedules", "list"], "List primary and secondary schedules with their open windows.", "ornn schedules list [--listing-kind primary|secondary] [--gpu-slug <slug>] [--from <time>] [--to <time>]", "ornn schedules list --listing-kind secondary --format json", ["schedules show", "schedules buy", "offers post"], 40),
+    },
+    slack: false,
+    execute: async (ctx, input) => {
+        const parsed = schedulesListInput.parse(input ?? {});
+        return ctx.fetch(`${BASE}/schedules${query({
+            listingKind: parsed.listingKind,
+            gpuSlug: parsed.gpuSlug,
+            from: parsed.from,
+            to: parsed.to,
+        })}`, { method: "GET" });
+    },
+});
+export const scheduleShowInput = z.object({
+    $positionals: positionals,
+    listingId: z.string().uuid(),
+});
+export const scheduleShowCapability = defineCapability({
+    id: "schedules.show",
+    domain: "markets",
+    roles: ["user"],
+    description: "Show one listing's schedule: a primary's price, down payment and open offer book, or a secondary's asking price, and its sold windows.",
+    mutation: "read",
+    http: { method: "GET", path: `${BASE}/schedules/{listingId}` },
+    input: scheduleShowInput,
+    cli: {
+        command: ["schedules", "show"],
+        vnext: help(["schedules", "show"], "Show one schedule with its sold windows and offers.", "ornn schedules show --listing-id <id>", "ornn schedules show --listing-id <id> --format json", ["schedules list", "schedules buy", "offers post", "offers accept"], 41, ["listing ID"]),
+    },
+    slack: false,
+    execute: async (ctx, input) => {
+        const parsed = scheduleShowInput.parse(input);
+        return ctx.fetch(`${BASE}/schedules/${seg(parsed.listingId)}`, { method: "GET" });
+    },
+});
+export const schedulePurchaseInput = z.object({
+    $positionals: positionals,
+    listingId: z.string().uuid().describe("A secondary (relisted) listing."),
+    startsAt: z
+        .string()
+        .min(1)
+        .describe("RFC 3339 start of the window: inside the listing, now or later, on the hour."),
+    endsAt: z
+        .string()
+        .min(1)
+        .describe("RFC 3339 end of the window, at least an hour after the start."),
+    askPricePerGpuHourMicroUsd: microUsd.describe("The listing's current asking price in micro-USD per GPU-hour, from schedules show. A changed price refuses the purchase."),
+    idempotencyKey: z.string().min(1).max(200).optional(),
+    confirm: z.boolean().optional(),
+});
+export const schedulePurchaseCapability = defineCapability({
+    id: "schedules.purchase",
+    domain: "markets",
+    roles: ["user"],
+    description: "Buy a window of a secondary (relisted) listing at its asking price, for every node on it. There is no offer: the window is yours once it is paid. You pay the asking price plus the Ornn trading fee up front, from Ornn credits and then your saved card; $10,000 or more is invoiced by wire. Requires confirm: true.",
+    mutation: "preview-confirm",
+    http: { method: "POST", path: `${BASE}/schedules/purchases` },
+    input: schedulePurchaseInput,
+    cli: {
+        command: ["schedules", "buy"],
+        vnext: help(["schedules", "buy"], "Buy a window of relisted capacity at its asking price.", "ornn schedules buy --listing-id <id> --starts-at <time> --ends-at <time> --ask-price-per-gpu-hour-micro-usd <n>", "ornn schedules buy --listing-id <id> --starts-at <time> --ends-at <time> --ask-price-per-gpu-hour-micro-usd 4000000 --yes --format json", ["schedules show", "reservations show"], 42, ["listing ID"]),
+    },
+    slack: false,
+    execute: async (ctx, input) => {
+        const parsed = schedulePurchaseInput.parse(input);
+        const body = {
+            legs: [
+                {
+                    listingId: parsed.listingId,
+                    startsAt: parsed.startsAt,
+                    endsAt: parsed.endsAt,
+                    askPricePerGpuHourMicroUsd: parsed.askPricePerGpuHourMicroUsd,
+                },
+            ],
+        };
+        const gate = await consent(ctx, "schedules.purchase", "Buy relisted window", [
+            { label: "Listing", value: parsed.listingId },
+            { label: "Window", value: `${parsed.startsAt} to ${parsed.endsAt}` },
+            { label: "Asking price", value: microUsdLabel(parsed.askPricePerGpuHourMicroUsd) },
+            {
+                label: "Payment",
+                value: "Up front, with the Ornn trading fee on top: Ornn credits, then your saved card.",
+            },
+        ], body);
+        if (gate)
+            return gate;
+        return ctx.fetch(`${BASE}/schedules/purchases`, {
+            method: "POST",
+            body,
+            headers: idempotencyHeaders(ctx, parsed.idempotencyKey),
+        });
+    },
+});
+export const offersListInput = z.object({ $positionals: positionals });
+export const offersListCapability = defineCapability({
+    id: "offers.list",
+    domain: "markets",
+    roles: ["user"],
+    description: "List the offers this organization has posted on schedules, with their status.",
+    mutation: "read",
+    http: { method: "GET", path: `${BASE}/offers` },
+    input: offersListInput,
+    cli: {
+        command: ["offers", "list"],
+        vnext: help(["offers", "list"], "List the offers your organization has posted.", "ornn offers list", "ornn offers list --format json", ["offers post", "offers cancel"], 42),
+    },
+    slack: false,
+    execute: async (ctx) => ctx.fetch(`${BASE}/offers`, { method: "GET" }),
+});
+export const offerPostInput = z.object({
+    $positionals: positionals,
+    listingId: z.string().uuid(),
+    pricePerGpuHourMicroUsd: microUsd.describe("Offer price in micro-USD per GPU-hour (1000000 = $1.00). Covers every node for the rest of the listing."),
+    downPaymentCents: z.coerce
+        .number()
+        .int()
+        .min(0)
+        .optional()
+        .describe("Primary listings only: the down payment you offer, in cents."),
+    idempotencyKey: z.string().min(1).max(200).optional(),
+    confirm: z.boolean().optional(),
+});
+export const offerPostCapability = defineCapability({
+    id: "offers.post",
+    domain: "markets",
+    roles: ["user"],
+    description: "Offer a price for a whole primary listing: every node, from the later of the listing's start and now to its end. The listing owner accepts it to create your reservation. Relisted (secondary) capacity takes no offers: buy it with schedules purchase. Requires confirm: true.",
+    mutation: "preview-confirm",
+    http: { method: "POST", path: `${BASE}/schedules/{listingId}/offers` },
+    input: offerPostInput,
+    cli: {
+        command: ["offers", "post"],
+        vnext: help(["offers", "post"], "Offer a price for a whole primary listing.", "ornn offers post --listing-id <id> --price-per-gpu-hour-micro-usd <n> [--down-payment-cents <n>]", "ornn offers post --listing-id <id> --price-per-gpu-hour-micro-usd 2500000 --yes --format json", ["schedules show", "offers list", "offers cancel"], 43, ["listing ID"]),
+    },
+    slack: false,
+    execute: async (ctx, input) => {
+        const parsed = offerPostInput.parse(input);
+        const body = {
+            pricePerGpuHourMicroUsd: parsed.pricePerGpuHourMicroUsd,
+            ...(parsed.downPaymentCents !== undefined
+                ? { downPaymentCents: parsed.downPaymentCents }
+                : {}),
+        };
+        const gate = await consent(ctx, "offers.post", "Post schedule offer", [
+            { label: "Listing", value: parsed.listingId },
+            { label: "Window", value: "The rest of the listing" },
+            { label: "Price", value: microUsdLabel(parsed.pricePerGpuHourMicroUsd) },
+            ...(parsed.downPaymentCents !== undefined
+                ? [{ label: "Down payment", value: `$${(parsed.downPaymentCents / 100).toFixed(2)}` }]
+                : []),
+        ], { listingId: parsed.listingId, ...body });
+        if (gate)
+            return gate;
+        return ctx.fetch(`${BASE}/schedules/${seg(parsed.listingId)}/offers`, {
+            method: "POST",
+            body,
+            headers: idempotencyHeaders(ctx, parsed.idempotencyKey),
+        });
+    },
+});
+export const offerDecisionInput = z.object({
+    $positionals: positionals,
+    listingId: z.string().uuid(),
+    offerId: z.string().uuid(),
+    confirm: z.boolean().optional(),
+});
+export const offerAcceptCapability = defineCapability({
+    id: "offers.accept",
+    domain: "markets",
+    roles: ["user"],
+    description: "Accept an offer on a primary listing you own. The accepted window becomes the buyer's reservation and overlapping offers and relists from the same holding are cancelled. Requires confirm: true.",
+    mutation: "preview-confirm",
+    http: { method: "POST", path: `${BASE}/schedules/{listingId}/offers/{offerId}/accept` },
+    input: offerDecisionInput,
+    cli: {
+        command: ["offers", "accept"],
+        vnext: help(["offers", "accept"], "Accept one offer on a listing you own.", "ornn offers accept --listing-id <id> --offer-id <id>", "ornn offers accept --listing-id <id> --offer-id <id> --yes --format json", ["schedules show"], 44, ["listing ID", "offer ID"]),
+    },
+    slack: false,
+    execute: async (ctx, input) => {
+        const parsed = offerDecisionInput.parse(input);
+        const gate = await consent(ctx, "offers.accept", "Accept schedule offer", [
+            { label: "Listing", value: parsed.listingId },
+            { label: "Offer", value: parsed.offerId },
+            {
+                label: "Consequence",
+                value: "The window is sold; overlapping open offers and conflicting relists from this holding are cancelled.",
+            },
+        ], { listingId: parsed.listingId, offerId: parsed.offerId });
+        if (gate)
+            return gate;
+        return ctx.fetch(`${BASE}/schedules/${seg(parsed.listingId)}/offers/${seg(parsed.offerId)}/accept`, { method: "POST", body: {} });
+    },
+});
+export const offerCancelCapability = defineCapability({
+    id: "offers.cancel",
+    domain: "markets",
+    roles: ["user"],
+    description: "Cancel an open offer you posted, or one on a listing you own. Requires confirm: true.",
+    mutation: "preview-confirm",
+    http: { method: "DELETE", path: `${BASE}/schedules/{listingId}/offers/{offerId}` },
+    input: offerDecisionInput,
+    cli: {
+        command: ["offers", "cancel"],
+        vnext: help(["offers", "cancel"], "Cancel one open offer.", "ornn offers cancel --listing-id <id> --offer-id <id>", "ornn offers cancel --listing-id <id> --offer-id <id> --yes --format json", ["offers list"], 45, ["listing ID", "offer ID"]),
+    },
+    slack: false,
+    execute: async (ctx, input) => {
+        const parsed = offerDecisionInput.parse(input);
+        const gate = await consent(ctx, "offers.cancel", "Cancel schedule offer", [
+            { label: "Listing", value: parsed.listingId },
+            { label: "Offer", value: parsed.offerId },
+        ], { listingId: parsed.listingId, offerId: parsed.offerId });
+        if (gate)
+            return gate;
+        return ctx.fetch(`${BASE}/schedules/${seg(parsed.listingId)}/offers/${seg(parsed.offerId)}`, {
+            method: "DELETE",
+        });
+    },
+});
+export const marketCapabilities = [
+    spotBooksCapability,
+    spotBookCapability,
+    spotTradesCapability,
+    spotBidCapability,
+    spotOrdersCapability,
+    spotCancelCapability,
+    schedulesListCapability,
+    scheduleShowCapability,
+    schedulePurchaseCapability,
+    offersListCapability,
+    offerPostCapability,
+    offerAcceptCapability,
+    offerCancelCapability,
+];

package/vendor/capabilities/capabilities/networks.js

@@ -904,6 +904,13 @@ async function connectPrivateTarget(context, input) {
             field: "machine",
         });
     }
+    // A UUID and an organization network do not prove that this target exists.
+    // Only a resolved native target may continue into private transport setup.
+    if (!resolved) {
+        runtime.error("No accessible machine, cluster, or capacity reservation matches this target.", {
+            code: "connect_target_not_found",
+        });
+    }
     const shared = record(await context.fetch(`${NETWORKS_PATH}/shared?overlay=true`));
     const privateNetwork = projectNetwork({
         ...record(shared.network),

package/vendor/capabilities/capabilities/tokens.js

@@ -2,8 +2,8 @@ import { z } from "zod";
 import { defineCapability, preview } from "../capability.js";
 const optionalText = z.string().nullish();
 const tokenCreateInput = z.object({
-    operator_id: z.string().min(1),
-    operatorId: optionalText,
+    organization_id: z.string().min(1),
+    organizationId: optionalText,
     facility_id: optionalText,
     facilityId: optionalText,
     expires_in_seconds: z.number().int().positive().nullish(),
@@ -51,7 +51,7 @@ export const tokensListCapability = defineCapability({
     id: "tokens.list",
     domain: "fleet",
     roles: ["admin"],
-    description: "List issued enrollment tokens (id, operator, status, expiry). Does not return plaintext secrets.",
+    description: "List issued enrollment tokens (id, supplier organization_id, status, expiry). Does not return plaintext secrets.",
     mutation: "read",
     http: { method: "GET", path: "/enrollment-tokens" },
     slack: { parameters: { type: "object", properties: {} } },
@@ -69,7 +69,10 @@ export const tokensCreateCapability = defineCapability({
         parameters: {
             type: "object",
             properties: {
-                operator_id: { type: "string", description: "Commerce operator UUID from operator.list." },
+                organization_id: {
+                    type: "string",
+                    description: "Supplier organization UUID from supplier.list.",
+                },
                 facility_id: { type: "string", description: "Optional facility UUID." },
                 expires_in_seconds: { type: "integer", description: "Token TTL in seconds." },
                 filter: {
@@ -90,20 +93,20 @@ export const tokensCreateCapability = defineCapability({
                     description: "PEM private key. Required to enroll over SSH.",
                 },
             },
-            required: ["operator_id"],
+            required: ["organization_id"],
         },
     },
     input: tokenCreateInput,
     execute: async (ctx, input) => {
         const parsed = tokenCreateInput.parse(input);
-        const operatorId = (parsed.operator_id || parsed.operatorId || "").trim();
+        const organizationId = (parsed.organization_id || parsed.organizationId || "").trim();
         const hosts = [
             ...(parsed.host?.trim() ? [parsed.host.trim()] : []),
             ...(parsed.hosts ?? []).map((host) => host.trim()).filter(Boolean),
         ];
         const privateKey = parsed.private_key?.trim() || parsed.privateKey?.trim() || "";
         const payload = {
-            operator_id: operatorId,
+            organization_id: organizationId,
             facility_id: parsed.facility_id ?? parsed.facilityId,
             expires_in_seconds: parsed.expires_in_seconds ?? parsed.expiresInSeconds,
             filter: parsed.filter,
@@ -119,7 +122,7 @@ export const tokensCreateCapability = defineCapability({
         const minted = (await ctx.fetch("/enrollment-tokens", {
             method: "POST",
             body: {
-                operator_id: operatorId,
+                organization_id: organizationId,
                 ...(payload.facility_id ? { facility_id: payload.facility_id } : {}),
                 ...(payload.expires_in_seconds ? { expires_in_seconds: payload.expires_in_seconds } : {}),
             },
@@ -153,7 +156,7 @@ export const tokensCreateCapability = defineCapability({
         }
         return {
             id: minted.id,
-            operator_id: minted.operator_id ?? operatorId,
+            organization_id: minted.organization_id ?? organizationId,
             expires_at: minted.expires_at,
             hosts: results,
         };

package/vendor/capabilities/capability.js

@@ -6,7 +6,7 @@ export const DOMAINS = [
     "fleet",
     "users",
     "reservations",
-    "bids",
+    "markets",
     "access",
     "clusters",
     "slurm",
@@ -15,6 +15,7 @@ export const DOMAINS = [
     "storage",
     "vpn",
     "billing",
+    "downtime",
     "observability",
     "gtm",
 ];

package/vendor/capabilities/cli-catalog.js

@@ -1,6 +1,7 @@
 import { adminCapabilities, bindAdminCapabilities } from "./capabilities/admin.js";
-import { capacityOfferCapabilities } from "./capabilities/capacity-offers.js";
 import { adminCapacityReservationCapabilities } from "./capabilities/admin-capacity-reservations.js";
+import { commerceMarketCapabilities } from "./capabilities/commerce-market.js";
+import { marketCapabilities } from "./capabilities/markets.js";
 import { adminEnrollmentCapabilities, bindAdminEnrollmentCapabilities, } from "./capabilities/admin-enrollment.js";
 import { adminNodeDiagnosticCapabilities } from "./capabilities/admin-node-diagnostics.js";
 import { adminNodeLifecycleCapabilities } from "./capabilities/admin-nodes-lifecycle.js";
@@ -41,7 +42,8 @@ export const catalog = [
             ...cliShellCapabilities,
             ...identityCapabilities,
             ...listingCapabilities,
-            ...capacityOfferCapabilities,
+            ...commerceMarketCapabilities,
+            ...marketCapabilities,
             ...computeCapabilities,
             ...fleetCapabilities.filter((capability) => capability.id !== "node.exec"),
             ...networkCapabilities,