@ornncompute/cli 1.0.34 → 1.0.48

package/vendor/capabilities/capabilities/listings.js

@@ -46,22 +46,16 @@ export const listingCreateInput = z.object({
         .describe("End of the availability window. YYYY-MM-DD or RFC3339."),
     available_from: z.string().optional().describe("Alias for available_start_at."),
     available_to: z.string().optional().describe("Alias for available_end_at."),
-    buy_now_price_per_gpu_hour: z
-        .number()
-        .optional()
-        .describe("Price buyers pay, USD per GPU-hour. The spread over cost_per_gpu_hour is Ornn's."),
-    cost_per_gpu_hour: z
-        .number()
-        .optional()
-        .describe("Supplier price, USD per GPU-hour. Defaults to the buy-now price (spread 0)."),
+    buy_now_price_per_gpu_hour: z.number().optional().describe("Price buyers pay, USD per GPU-hour."),
     deposit_percent: z.number().optional(),
     down_payment_cents: z.number().int().nonnegative().optional(),
     access_mode: z.enum(["bare-metal", "virtual-machine"]).optional(),
-    state: z.enum(["available", "internal"]).optional(),
+    state: z.enum(["available", "draft"]).optional(),
     price_omitted: z.boolean().optional(),
     announce: z.boolean().optional(),
     text: z.string().optional(),
     confirm: z.boolean().optional(),
+    idempotencyKey: z.string().min(1).max(200).optional(),
 });
 const catalogTermsInput = z.object({ kind: z.enum(["gpu", "cpu", "node", "link"]).optional() });
 const slackListingCreateParams = {
@@ -80,7 +74,6 @@ const slackListingCreateParams = {
         available_start_at: { type: "string" },
         available_end_at: { type: "string" },
         buy_now_price_per_gpu_hour: { type: "number" },
-        cost_per_gpu_hour: { type: "number" },
         deposit_percent: { type: "number" },
         price_omitted: { type: "boolean" },
         announce: { type: "boolean" },
@@ -166,6 +159,23 @@ export function primaryDownPaymentCents(terms) {
     const totalCents = (terms.pricePerGpuHourMicroUsd * terms.nodeCount * terms.gpusPerNode * hours) / 10_000;
     return Math.max(0, Math.round((totalCents * terms.percent) / 100));
 }
+/** Shared native creation body for Slack's preview and human-confirmed write. */
+export function primaryListingBody(input, pricePerGpuHourMicroUsd, downPaymentCents) {
+    return {
+        ...input,
+        kind: "primary",
+        terms: [
+            {
+                type: "reserved",
+                minDurationHours: 1 / 3600,
+                maxDurationHours: (Date.parse(input.availableUntil) - Date.parse(input.availableAt)) / 3600000,
+                renewable: false,
+                pricePerGpuHourMicroUsd,
+                downPaymentCents,
+            },
+        ],
+    };
+}
 /** Commerce parses listing windows as RFC3339 timestamps, not bare dates. */
 function rfc3339(value) {
     const trimmed = value.trim();
@@ -193,13 +203,13 @@ const LISTING_CREATE_INPUT_ONLY_KEYS = [
     "site",
     "kind",
     "confirm",
+    "idempotencyKey",
     "organizationId",
     "organization_id",
     "site_supplier",
     "facilityId",
     "facility_id",
     "buy_now_price_per_gpu_hour",
-    "cost_per_gpu_hour",
     "deposit_percent",
     "down_payment_cents",
     "access_mode",
@@ -208,12 +218,13 @@ const LISTING_CREATE_INPUT_ONLY_KEYS = [
 ];
 export const createListingCapability = defineCapability({
     id: "listings.create",
+    mcp: false,
     domain: "listings",
     roles: ["admin"],
     description: "Create a primary marketplace listing (admin). gpu_type, cpu, node_model, and fabric_type must exact-match an orchestrator catalog display name, canonical, or alias; gpu_type becomes the listing's GPU slug. " +
-        "cost_per_gpu_hour is the supplier price and buy_now_price_per_gpu_hour the price buyers pay; the difference is Ornn's spread. Nodes are attached afterwards. CLI asks y/N. Slack never POSTs until a human replies confirm. MCP creates on this tool call.",
+        "buy_now_price_per_gpu_hour is the customer price; deposit_percent is the upfront payment as a percentage of the full availability window. Nodes are attached afterwards. Slack never POSTs until a human replies confirm. MCP and CLI use native listing.create instead.",
     mutation: "preview-confirm",
-    http: { method: "POST", path: "/commerce/listings" },
+    http: { method: "POST", path: "/commerce/v2/listings" },
     slack: { parameters: slackListingCreateParams },
     input: listingCreateInput,
     execute: async (ctx, input) => {
@@ -244,14 +255,21 @@ export const createListingCapability = defineCapability({
             const seenCursors = new Set();
             let cursor;
             do {
-                const response = (await ctx.fetch(queryPath("/provisioning/facilities", { cursor }), { method: "GET" }));
+                const response = (await ctx.fetch(queryPath("/provisioning/facilities", { cursor }), {
+                    method: "GET",
+                }));
                 if (!Array.isArray(response.facilities))
                     throw new Error("invalid facility catalog");
-                matches.push(...response.facilities.filter((facility) => (!organizationId || (facility.organizationId ?? facility.organization_id) === organizationId) &&
+                matches.push(...response.facilities.filter((facility) => (!organizationId ||
+                    (facility.organizationId ?? facility.organization_id) === organizationId) &&
                     (facilityId
                         ? (facility.facilityId ?? facility.id) === facilityId
-                        : !facilityQuery || [facility.facilityId ?? facility.id, facility.slug, facility.displayName ?? facility.display_name]
-                            .some((value) => value?.toLowerCase() === facilityQuery))));
+                        : !facilityQuery ||
+                            [
+                                facility.facilityId ?? facility.id,
+                                facility.slug,
+                                facility.displayName ?? facility.display_name,
+                            ].some((value) => value?.toLowerCase() === facilityQuery))));
                 cursor = response.nextCursor ?? undefined;
                 if (cursor) {
                     if (seenCursors.has(cursor) || seenCursors.size >= 49) {
@@ -274,12 +292,12 @@ export const createListingCapability = defineCapability({
         const startsAt = rfc3339(parsed.available_start_at ??
             parsed.available_from ??
             parsed.starts_after ??
-            new Date().toISOString());
+            new Date(Math.floor(Date.now() / 1000) * 1000).toISOString());
         const endsAt = rfc3339(parsed.available_end_at ??
             parsed.available_to ??
             parsed.ends_before ??
             parsed.ends_after ??
-            new Date(Date.now() + 30 * 24 * 60 * 60 * 1000).toISOString());
+            new Date(Math.floor(Date.now() / 1000) * 1000 + 30 * 24 * 60 * 60 * 1000).toISOString());
         const nodeCount = parsed.node_count ?? parsed.min_nodes ?? 1;
         const gpusPerNode = parsed.gpus_per_node ?? 8;
         const boundPayload = bound.payload;
@@ -288,12 +306,7 @@ export const createListingCapability = defineCapability({
             ? resolveCatalogTerm(hardware.terms, "gpu", normalized.gpu_type).canonical
             : null;
         const buyerPrice = parsed.buy_now_price_per_gpu_hour;
-        const supplierPrice = parsed.cost_per_gpu_hour ?? buyerPrice;
-        const supplierMicro = supplierPrice != null ? microUsd(supplierPrice) : null;
-        const buyerMicro = buyerPrice != null ? microUsd(buyerPrice) : supplierMicro;
-        if (supplierMicro != null && buyerMicro != null && buyerMicro < supplierMicro) {
-            return { ok: false, error: "price_below_supplier_price" };
-        }
+        const buyerMicro = buyerPrice != null ? microUsd(buyerPrice) : null;
         const downPaymentCents = parsed.down_payment_cents ??
             (parsed.deposit_percent != null && buyerMicro != null
                 ? primaryDownPaymentCents({
@@ -305,26 +318,23 @@ export const createListingCapability = defineCapability({
                     percent: parsed.deposit_percent,
                 })
                 : 0);
-        const listing = organizationId && facilityId && gpuSlug && supplierMicro != null && buyerMicro != null
-            ? {
+        const listing = organizationId && facilityId && gpuSlug && buyerMicro != null
+            ? primaryListingBody({
                 organizationId,
                 facilityId,
                 gpuSlug,
                 gpusPerNode,
-                accessMode: parsed.access_mode ?? "virtual-machine",
-                startsAt,
-                endsAt,
+                provisioningType: parsed.access_mode ?? "virtual-machine",
+                availableAt: startsAt,
+                availableUntil: endsAt,
                 ...(typeof draft.cpu === "string" ? { cpu: draft.cpu } : {}),
                 ...(typeof draft.ram === "string" ? { ram: draft.ram } : {}),
                 ...(typeof draft.storage === "string" ? { storage: draft.storage } : {}),
                 ...(typeof draft.fabric_type === "string" ? { fabricType: draft.fabric_type } : {}),
                 ...(typeof draft.internet === "string" ? { internet: draft.internet } : {}),
-                ...(parsed.node_count ? { plannedNodeCount: parsed.node_count } : {}),
-                supplierPricePerGpuHourMicroUsd: supplierMicro,
-                spreadPerGpuHourMicroUsd: buyerMicro - supplierMicro,
-                downPaymentCents,
-                ...(parsed.state ? { state: parsed.state } : {}),
-            }
+                capacityNodeCount: nodeCount,
+                state: parsed.state ?? "available",
+            }, buyerMicro, downPaymentCents)
             : null;
         if (!ctx.confirmed) {
             return preview("create_listing", {
@@ -337,10 +347,20 @@ export const createListingCapability = defineCapability({
         if (!listing) {
             return {
                 ok: false,
-                error: !organizationId || !facilityId ? "facility_required" : gpuSlug ? "price_required" : "gpu_required",
+                error: !organizationId || !facilityId
+                    ? "facility_required"
+                    : gpuSlug
+                        ? "price_required"
+                        : "gpu_required",
             };
         }
-        return ctx.fetch("/commerce/listings", { method: "POST", body: listing });
+        if (!parsed.idempotencyKey)
+            return { ok: false, error: "idempotency_key_required" };
+        return ctx.fetch("/commerce/v2/listings", {
+            method: "POST",
+            body: listing,
+            headers: { "Idempotency-Key": parsed.idempotencyKey },
+        });
     },
 });
 export const listingCapabilities = [

package/vendor/capabilities/capabilities/markets.js

@@ -84,9 +84,9 @@ export const spotBidInput = z
     gpus: z.coerce
         .number()
         .int()
-        .min(1)
+        .min(8)
         .max(8)
-        .describe("GPUs on one node, 1-8. To buy N whole nodes, place N bids of 8 GPUs."),
+        .describe("Exactly 8 GPUs on one full node. To buy N nodes, place N bids."),
     orderType: z
         .enum(["limit", "market"])
         .default("limit")
@@ -105,14 +105,14 @@ 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.",
+    description: "Place a spot bid for a full node with 8 GPUs. A filled bid becomes a running spot reservation, " +
+        "prepaid hourly from Ornn credits first and then the saved card. Book prices are what you pay; a limit is the most you pay per GPU-hour. 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"]),
+        vnext: help(["spot", "bid"], "Place one spot bid for a full node with 8 GPUs.", "ornn spot bid --gpu-slug <slug> --gpus 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) => {
@@ -266,7 +266,7 @@ 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.",
+    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 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,
@@ -293,7 +293,7 @@ export const schedulePurchaseCapability = defineCapability({
             { 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.",
+                value: "Up front: Ornn credits, then your saved card.",
             },
         ], body);
         if (gate)

package/vendor/capabilities/capabilities/native-listing.js

@@ -0,0 +1,63 @@
+import { z } from "zod";
+import { flag } from "./market-shared.js";
+export const nativeTermFields = {
+    type: z.enum(["reserved", "spot", "on-demand"]).nullable().optional(),
+    minDurationHours: z.coerce.number().nonnegative(),
+    maxDurationHours: z.coerce.number().nonnegative(),
+    pricePerGpuHourMicroUsd: z.coerce.number().int().positive(),
+    downPaymentCents: z.coerce.number().int().nonnegative().nullable().optional(),
+    renewable: flag,
+};
+export const nativeTermInput = z.object(nativeTermFields).strict();
+export const nativeTermsInput = z.preprocess((value) => {
+    if (typeof value !== "string")
+        return value;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return value;
+    }
+}, z.array(nativeTermInput));
+export const listingWriteControls = {
+    confirm: z.boolean().optional(),
+    idempotencyKey: z.string().min(1).max(200),
+};
+export const nativeListingCreateInput = z
+    .object({
+    organizationId: z.string().uuid().nullable().optional(),
+    kind: z.enum(["primary", "secondary"]).default("primary"),
+    gpuSlug: z.string().min(1),
+    gpusPerNode: z.coerce.number().int().positive(),
+    capacityNodeCount: z.coerce.number().int().positive(),
+    facilityId: z.string().uuid(),
+    provisioningType: z.enum(["bare-metal", "virtual-machine"]),
+    state: z.enum(["draft", "available"]),
+    availableAt: z.iso.datetime({ offset: true }).nullable().optional(),
+    availableUntil: z.iso.datetime({ offset: true }).nullable().optional(),
+    daysToRfs: z.coerce.number().int().nonnegative().optional(),
+    cpu: z.string().optional(),
+    ram: z.string().optional(),
+    storage: z.string().optional(),
+    fabricType: z.string().optional(),
+    internet: z.string().optional(),
+    terms: nativeTermsInput,
+    ...listingWriteControls,
+})
+    .strict();
+export const nativeListingUpdateFields = {
+    state: z.enum(["draft", "available", "delisted"]).optional(),
+    nodeCount: z.coerce.number().int().positive().optional(),
+    gpuSlug: z.string().min(1).optional(),
+    gpusPerNode: z.coerce.number().int().positive().optional(),
+    facilityId: z.string().uuid().optional(),
+    provisioningType: z.enum(["bare-metal", "virtual-machine"]).optional(),
+    availableAt: z.iso.datetime({ offset: true }).optional(),
+    availableUntil: z.iso.datetime({ offset: true }).optional(),
+    daysToRfs: z.coerce.number().int().nonnegative().optional(),
+    cpu: z.string().optional(),
+    ram: z.string().optional(),
+    storage: z.string().optional(),
+    fabricType: z.string().optional(),
+    internet: z.string().optional(),
+};

package/vendor/capabilities/capabilities/organization-invites.js

@@ -0,0 +1,53 @@
+import { z } from "zod";
+import { defineCapability } from "../capability.js";
+export const organizationInviteInput = z.object({
+    organization_id: z.uuid(),
+    email: z.string().trim().toLowerCase().pipe(z.email()),
+});
+export const organizationInviteCapability = defineCapability({
+    id: "organization.invite",
+    domain: "users",
+    roles: ["admin"],
+    description: "Email an invitation to an existing organization. Resolve its UUID with organization_list first; ask the operator to choose if matches are ambiguous. The recipient may already belong to another organization. Send directly when the admin requests the invitation.",
+    mutation: "immediate",
+    http: { method: "POST", path: "/v1/staff/invites" },
+    cli: {
+        command: ["admin", "organizations", "invite"],
+        vnext: {
+            audience: "admin",
+            category: "resource",
+            command: ["admin", "organizations", "invite"],
+            outcome: "Email an invitation to an existing organization.",
+            human: "ornn admin organizations invite --organization UUID --email EMAIL",
+            automation: "ornn admin organizations invite --organization UUID --email EMAIL --format json",
+            acceptedReferences: ["organization UUID from admin organizations list"],
+            related: ["admin organizations list"],
+        },
+    },
+    slack: {
+        parameters: {
+            type: "object",
+            properties: {
+                organization_id: {
+                    type: "string",
+                    format: "uuid",
+                    description: "Exact organization UUID from organization_list.",
+                },
+                email: {
+                    type: "string",
+                    format: "email",
+                    description: "Address to receive the invitation.",
+                },
+            },
+            required: ["organization_id", "email"],
+        },
+    },
+    input: organizationInviteInput,
+    execute: async (ctx, input) => {
+        const parsed = organizationInviteInput.parse(input);
+        return ctx.fetch("/v1/staff/invites", {
+            method: "POST",
+            body: { ...parsed, send_email: true },
+        });
+    },
+});

package/vendor/capabilities/capabilities/users.js

@@ -1,49 +1,159 @@
 import { z } from "zod";
 import { defineCapability } from "../capability.js";
-function queryPath(path, params) {
-    const parts = [];
-    for (const [key, value] of Object.entries(params)) {
-        if (value?.trim())
-            parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(value.trim())}`);
+const directoryLimit = z.number().int().min(1).max(100).default(25);
+const directoryOffset = z.number().int().nonnegative().optional();
+export const organizationListInput = z.object({
+    q: z.string().trim().optional().describe("Company name, contact/member name, or email."),
+    role: z.enum(["consumer", "supplier"]).optional(),
+    approved: z.boolean().optional(),
+    ids: z.array(z.uuid()).min(1).max(100).optional(),
+    limit: directoryLimit,
+    offset: directoryOffset,
+});
+export const usersListInput = z.object({
+    q: z.string().trim().optional().describe("Person name, email, or company name."),
+    organization_id: z.uuid().optional(),
+    limit: directoryLimit,
+    offset: directoryOffset,
+});
+function directoryPath(input) {
+    const params = [
+        `limit=${input.limit}`,
+        `offset=${input.offset}`,
+        "sort=name",
+        "direction=asc",
+    ];
+    if (input.q)
+        params.push(`q=${encodeURIComponent(input.q)}`);
+    if (input.role)
+        params.push(`role=${encodeURIComponent(input.role)}`);
+    if (input.approved !== undefined) {
+        params.push(`approved=${input.approved}`);
     }
-    return parts.length ? `${path}?${parts.join("&")}` : path;
+    if (input.ids)
+        params.push(`ids=${encodeURIComponent(input.ids.join(","))}`);
+    return `/v1/organizations?${params.join("&")}`;
+}
+function directoryMembers(organization) {
+    return organization.members ?? [];
+}
+function organizationMatchesQuery(organization, query) {
+    return (organization.name.toLowerCase().includes(query) ||
+        organization.id.toLowerCase() === query ||
+        [
+            organization.company_profile?.company_name,
+            organization.company_profile?.contact_name,
+            organization.company_profile?.contact_email,
+            organization.company_profile?.work_email,
+        ].some((value) => value?.toLowerCase().includes(query)));
 }
-const usersQueryInput = z.object({
-    name: z.string().optional(),
-    email: z.string().optional(),
-    organization: z.string().optional(),
-    q: z.string().optional(),
-    max: z.number().int().positive().max(1000).optional(),
-    limit: z.number().int().positive().max(1000).optional(),
+export const organizationListCapability = defineCapability({
+    id: "organization.list",
+    domain: "users",
+    roles: ["admin"],
+    description: "List organizations from the Authorization directory. Search by company name, contact/member name, or email; filter by role, approval, or UUIDs. Use the organization id as organizationId when recording downtime, and ask the user to choose if matches are ambiguous.",
+    mutation: "read",
+    http: { method: "GET", path: "/v1/organizations" },
+    slack: {
+        parameters: {
+            type: "object",
+            properties: {
+                q: {
+                    type: "string",
+                    description: "Company name, contact/member name, or email.",
+                },
+                role: { type: "string", enum: ["consumer", "supplier"] },
+                approved: { type: "boolean" },
+                ids: {
+                    type: "array",
+                    items: { type: "string", format: "uuid" },
+                    minItems: 1,
+                    maxItems: 100,
+                },
+                limit: { type: "integer", minimum: 1, maximum: 100, default: 25 },
+                offset: { type: "integer", minimum: 0 },
+            },
+        },
+    },
+    input: organizationListInput,
+    execute: async (ctx, input) => {
+        const parsed = organizationListInput.parse(input);
+        const limit = parsed.limit;
+        const offset = parsed.offset ?? 0;
+        const rows = (await ctx.fetch(directoryPath({ ...parsed, limit, offset }), { method: "GET" }));
+        return {
+            organizations: rows.map((organization) => ({
+                id: organization.id,
+                name: organization.name,
+                role: organization.role,
+                approved: organization.approved,
+                members: directoryMembers(organization).map((member) => ({
+                    user_id: member.user_id,
+                    email: member.email,
+                    name: member.name ?? null,
+                })),
+            })),
+            ...(rows.length === limit ? { next_offset: offset + rows.length } : {}),
+        };
+    },
 });
-export const usersQueryCapability = defineCapability({
-    id: "users.query",
+export const usersListCapability = defineCapability({
+    id: "users.list",
     domain: "users",
     roles: ["admin"],
-    description: "Admin-only directory search. Filter by name, email, or organization. Optional max (default 100, cap 1000). Returns matching users and organizations.",
+    description: "List users who belong to an organization, from the Authorization directory. Search by person name, email, or company name; use organization_id to restrict results to one organization.",
     mutation: "read",
-    http: { method: "GET", path: "/internal/users" },
+    http: { method: "GET", path: "/v1/organizations" },
     slack: {
         parameters: {
             type: "object",
             properties: {
-                name: { type: "string" },
-                email: { type: "string" },
-                organization: { type: "string" },
-                max: { type: "integer", description: "Maximum rows to return (1-1000)." },
+                q: { type: "string", description: "Person name, email, or company name." },
+                organization_id: { type: "string", format: "uuid" },
+                limit: {
+                    type: "integer",
+                    minimum: 1,
+                    maximum: 100,
+                    default: 25,
+                    description: "Maximum number of organizations to search.",
+                },
+                offset: { type: "integer", minimum: 0 },
             },
         },
     },
-    input: usersQueryInput,
+    input: usersListInput,
     execute: async (ctx, input) => {
-        const parsed = usersQueryInput.parse(input);
-        const q = [parsed.q, parsed.name, parsed.email, parsed.organization].find((value) => value?.trim());
-        return ctx.fetch(queryPath("/internal/users", {
-            q,
-            email: parsed.email,
-            organization: parsed.organization,
-            limit: String(parsed.max ?? parsed.limit ?? 100),
-        }), { method: "GET" });
+        const parsed = usersListInput.parse(input);
+        const limit = parsed.limit;
+        const offset = parsed.offset ?? 0;
+        const rows = (await ctx.fetch(directoryPath({
+            limit,
+            offset,
+            q: parsed.q,
+            ids: parsed.organization_id ? [parsed.organization_id] : undefined,
+        }), { method: "GET" }));
+        const q = parsed.q?.toLowerCase();
+        const users = rows.flatMap((organization) => {
+            const members = directoryMembers(organization);
+            const matchesOrganization = q ? organizationMatchesQuery(organization, q) : false;
+            return members
+                .filter((member) => !q ||
+                matchesOrganization ||
+                (member.name ?? "").toLowerCase().includes(q) || member.email.toLowerCase().includes(q))
+                .map((member) => ({
+                user_id: member.user_id,
+                email: member.email,
+                name: member.name ?? null,
+                organization_id: organization.id,
+                organization_name: organization.name,
+                organization_role: organization.role,
+                approved: organization.approved,
+            }));
+        });
+        return {
+            users,
+            ...(rows.length === limit ? { next_offset: offset + rows.length } : {}),
+        };
     },
 });
-export const userCapabilities = [usersQueryCapability];
+export const userCapabilities = [organizationListCapability, usersListCapability];

package/vendor/capabilities/cli-catalog.js

@@ -16,6 +16,7 @@ import { mountCapabilities } from "./capabilities/mounts.js";
 import { identityCapabilities } from "./capabilities/identity.js";
 import { listingCapabilities } from "./capabilities/listings.js";
 import { observabilityCapabilities } from "./capabilities/observability.js";
+import { organizationInviteCapability } from "./capabilities/organization-invites.js";
 import { networkCapabilities } from "./capabilities/networks.js";
 import { volumeCapabilities } from "./capabilities/volumes.js";
 import { userCapabilities } from "./capabilities/users.js";
@@ -41,7 +42,7 @@ export const catalog = [
         ...bindAdminEnrollmentCapabilities(bindAdminCapabilities([
             ...cliShellCapabilities,
             ...identityCapabilities,
-            ...listingCapabilities,
+            ...listingCapabilities.filter((capability) => capability.id !== "listings.create"),
             ...commerceMarketCapabilities,
             ...marketCapabilities,
             ...computeCapabilities,
@@ -60,8 +61,9 @@ export const catalog = [
             ...adminNodeLifecycleCapabilities,
         ])),
         ...adminCapabilities.filter((capability) => capability.id === "nodes.health"),
-        ...adminCapacityReservationCapabilities.filter((capability) => capability.id !== "listings.create"),
+        ...adminCapacityReservationCapabilities,
         ...adminNodeDiagnosticCapabilities,
         ...adminEnrollmentCapabilities,
+        organizationInviteCapability,
     ]),
 ];

package/vendor/capabilities/cli-migrations.js

@@ -231,7 +231,6 @@ export const LEGACY_CLI_MIGRATIONS = [
     { legacy: ["tokens", "list"], replacement: "ornn admin enrollment-tokens list" },
     { legacy: ["tokens", "create"], replacement: "ornn admin enrollment-tokens create" },
     { legacy: ["tokens", "revoke"], replacement: "ornn admin enrollment-tokens revoke" },
-    { legacy: ["users", "query"], replacement: "ornn admin users search" },
     { legacy: ["node", "enroll"], replacement: "ornn admin nodes enroll" },
     { legacy: ["node", "list"], replacement: "ornn admin nodes list" },
     { legacy: ["node", "health"], replacement: "ornn admin nodes health" },
@@ -247,7 +246,7 @@ export const LEGACY_CLI_MIGRATIONS = [
     { legacy: ["operators"], replacement: "ornn admin suppliers list" },
     { legacy: ["facilities"], replacement: "ornn admin facilities list" },
     { legacy: ["tokens"], replacement: "ornn admin enrollment-tokens list" },
-    { legacy: ["users"], replacement: "ornn admin users search" },
+    { legacy: ["users"], replacement: "ornn admin users list" },
     { legacy: ["node"], replacement: "ornn admin nodes list" },
     { legacy: ["cache", "purge"], replacement: "ornn resources" },
     { legacy: ["api"], replacement: "ornn resources" },