@ornncompute/cli 1.0.34 → 1.0.48

package/README.md

@@ -59,9 +59,8 @@ ornn resources
 Advanced customer resources are registered under one noun and one verb:
 
 ```text
-capacity-offers  list | show | relist | update | delist
+capacity-offers  list | show | terms | relist | delist
 reservations     list | show | invoices
-fees             show
 spot             books | book | trades | bid | orders | cancel
 schedules        list | show | buy
 offers           list | post | accept | cancel
@@ -82,12 +81,15 @@ filesystems      deploy | show | wait | delete
 `ssh-keys list` uses backend cursors; see [pagination](../../docs/cli.md#advanced-customer-resources).
 
 Market commands call one gateway route each and print that route's JSON.
-`capacity-offers` reads Commerce listings (`/commerce/listings`) and relists a
-schedule reservation you hold, or a primary listing you own, as a secondary
-listing with an asking price, its only price: buyers buy its windows at that
-price with no acceptance. `reservations` reads Commerce
+`capacity-offers list|show|terms` reads native Commerce capacity
+(`/commerce/v2/listings*`). List/show return parent fields with `capacityListingId`;
+pass it as `--listing-id`. `terms` separately returns advertised financial choices
+with `listingTermsId`, price, duration bounds, down payment and renewable flag.
+List accepts limits of 1–100 and the owner cursor unchanged. Relisting uses
+`POST /commerce/reservations/{id}/relist` with `nodeCount`, dates, optional node
+selection and a `terms` array. Delisting uses the native parent’s `/delist` POST. `reservations` reads Commerce
 reservations, schedule and spot alike. `spot`, `schedules`, and `offers` call
-Markets (`/v1/markets`): place 1-8 GPU spot bids (one node each), buy a
+Markets (`/v1/markets`): place 8-GPU spot bids (one full node each), buy a
 secondary window at its asking price (`schedules buy`), post offers on a
 primary listing's schedule, and accept or cancel offers on primaries you own.
 Prices are integer micro-USD per GPU-hour (`1000000` is $1.00). Every write
@@ -99,17 +101,30 @@ ownership.
 
 Only admins can create primary listings or reservations through
 `ornn admin capacity-offers create` and `ornn admin reservations create`.
-They post to the role-aware `POST /commerce/listings` and
+They post to the role-aware `POST /commerce/v2/listings` and
 `POST /commerce/reservations` with the admin's own session; Commerce enforces
 the admin role. Both commands retain explicit commercial-term validation and
-default-no human confirmation. A new primary listing reaches the market once
-staff attach its nodes.
+default-no human confirmation. Reservation creation takes `--customer UUID`,
+`--listing-term UUID`, `--nodes COUNT`, `--gpus COUNT`, `--starts-at TIME`, and
+`--transaction UUID`, plus optional `--ends-at TIME` and `--vm-disk UUID`.
+Prices and down payments come from the selected listing term. Omit `--ends-at`
+for hourly terms, and reuse the same transaction UUID and payload on retries.
+Creation requires an eligible human terminal. Native capacity creation takes
+`--gpu-slug`, `--capacity-node-count`, `--gpus-per-node`, `--facility-id`,
+`--provisioning-type`, `--state`, `--terms` (a JSON array) and `--idempotency-key`,
+plus optional `--organization-id`. Supply availability dates or `--days-to-rfs`.
+Reuse the key and the same body on retries. Prices are integer micro-USD inside
+terms, with explicit duration bounds, nullable deposit and renewable flag.
+`ornn admin capacity-offers update` edits a selected term using `--listing-id`,
+`--listing-terms-id`, the complete term fields and `--idempotency-key`. Financial
+editing remains staff-only. The old customer `capacity-offers update` is removed.
 
 All staff discovery and execution starts at `ornn admin`. A fresh staff preflight
-runs before the catalog is shown. The seven roots are:
+runs before the catalog is shown. The eight roots are:
 
 ```text
 ornn admin users
+ornn admin organizations
 ornn admin suppliers
 ornn admin facilities
 ornn admin nodes
@@ -119,6 +134,18 @@ ornn admin reservations
 ```
 
 Every `ornn admin` command, read or mutation, requires an admin session.
+`ornn admin users list` and `ornn admin organizations list` search the
+Authorization directory by person name, email, or company name, with bounded `--limit` and
+`--offset` pagination. Users can be restricted by `--organization`; organization
+results can be filtered by `--role`, `--approved`, or `--ids`.
+
+`ornn admin organizations invite --organization UUID --email EMAIL` emails an
+invitation immediately using the selected organization UUID from the directory.
+It shares its schema and execution with MCP and Slack and uses the staff session
+on `POST /v1/staff/invites`. The result includes the sign-in invitation path and
+`email_sent`. If delivery is uncertain, the invitation remains valid; check
+delivery or share the sign-in link before retrying. Use `--format json` for automation.
+
 `ornn admin nodes --help` lists the authorized node commands. Node health
 returns the node detail object; metrics preserve the owner `tier` and `windows`;
 logs return `data.logs` and an opaque continuation cursor in `page.next_cursor`.
@@ -254,7 +281,7 @@ vNext is a clean cutover. Retired forms are never aliases: each fails before I/O
 with one replacement and <https://docs.ornn.com/cli#migrating-to-vnext>.
 
 | Retired form                                                                                    | Replacement                                                   |
-| ----------------------------------------------------------------------------------------------- | ------------------------------------------------------------- |
+| ----------------------------------------------------------------------------------------- | ------------------------------------------------------------- |
 | `ornn account`, `ornn whoami`                                                                   | `ornn context`                                                |
 | `ornn catalog search`, `gpu-types`, `availability *`, `listing *`, `listings` read leaves       | matching `ornn capacity-offers` leaf                          |
 | `ornn listings create`                                                                          | `ornn admin capacity-offers create`                           |
@@ -338,15 +365,12 @@ npm run acceptance:packaged --workspace @ornncompute/cli -- \
   --evidence /tmp/ornn-vnext-packaged-gate.json
 ```
 
-The real gateway smoke and unassisted participant pass are separate release
-evidence; the deterministic fixture must never be presented as either one.
-The participant recorder installs the retained archive itself and owns the
-interactive shell used for the journey, with that installation first in
-`PATH`; it does not attest a session run in another terminal.
-Production and shared staging are refused by the smoke runner. See
-[`docs/packaged-vnext-release-gate.md`](docs/packaged-vnext-release-gate.md) for
-the non-production inputs, redacted evidence schemas, participant checklist,
-pass criteria, and exact commands.
+CI runs these packaged tests for each release and retains their result with
+the archive and npm metadata as workflow artifacts. No committed per-version
+evidence or waiver is required. Use real non-production smoke for substantial
+provisioning/access changes and an unassisted usability session for significant
+command UX changes. The smoke runner refuses production and shared staging.
+See [`docs/packaged-vnext-release-gate.md`](docs/packaged-vnext-release-gate.md).
 
 Private networks and VPN peers belong to the selected organization. There is no
 per-reservation network attachment step. Durable Bare Metal workspaces use

package/package.json

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

package/src/admin-capacity-reservations.mjs

@@ -1,17 +1,12 @@
 import { ADMIN_MUTATION_SAFETY, AdminMutationError, runAdminMutation } from "./admin-mutations.mjs";
-import { gpuLabeler } from "./gpu-catalog.mjs";
+import { parseSemanticArguments } from "./interaction-runtime.mjs";
 
 const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-const DECIMAL = /^\d+(?:\.\d{1,6})?$/;
 
 const USAGE = {
-  "listings.create":
-    "Usage: ornn admin capacity-offers create --gpu GPU --nodes COUNT --gpus-per-node COUNT --site SITE --starts-at TIME --ends-at TIME --price-per-gpu-hour USD [--supplier-price-per-gpu-hour USD] [--down-payment-cents CENTS] [--access-mode bare-metal|virtual-machine] [--yes]",
   "reservations.create":
-    "Usage: ornn admin reservations create --organization ID --capacity-offer ID --starts-at TIME --ends-at TIME --price-per-gpu-hour USD [--down-payment-cents CENTS] [--yes]",
+    "Usage: ornn admin reservations create --customer ID --listing-term ID --nodes COUNT --gpus COUNT --starts-at TIME --transaction ID [--ends-at TIME] [--vm-disk ID] [--yes]",
 };
-const ACCESS_MODES = new Set(["bare-metal", "virtual-machine"]);
-const STAFF_HARDWARE_CATALOG = "/catalog/hardware";
 
 function parseOptions(argv, { values, positionals }, usage) {
   const options = {};
@@ -81,88 +76,42 @@ function timestamp(options, name, usage) {
   return new Date(parsed).toISOString();
 }
 
-function price(options, usage, name = "price-per-gpu-hour") {
+// Preserve the microseconds Commerce uses to match a reservation to its accepted term.
+function reservationTimestamp(options, name, usage) {
   const value = required(options, name, usage);
-  if (!DECIMAL.test(value)) {
+  const match = value.match(
+    /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.(\d{1,6}))?(?:Z|[+-]\d{2}:\d{2})$/
+  );
+  if (!match) {
     throw new AdminMutationError(
-      `--${name} must be zero or a positive decimal with at most 6 decimal places.`,
+      `--${name} must be an ISO timestamp with a timezone and at most 6 fractional digits.`,
       { field: name }
     );
   }
-  return value;
+  const normalized = timestamp(options, name, usage);
+  return match[1]?.length > 3 ? `${normalized.slice(0, 19)}.${match[1]}Z` : normalized;
 }
 
-function optionalCents(options) {
-  const value = options["down-payment-cents"]?.trim();
-  if (value === undefined) return undefined;
-  const parsed = Number(value);
-  if (!Number.isSafeInteger(parsed) || parsed < 0) {
-    throw new AdminMutationError("--down-payment-cents must be a whole number of cents.", {
-      field: "down-payment-cents",
-    });
-  }
-  return parsed;
+function timestampMicroseconds(value) {
+  const fraction = value.match(/\.(\d+)Z$/)?.[1] ?? "";
+  return BigInt(Date.parse(value)) * 1000n + BigInt(fraction.padEnd(6, "0").slice(3));
 }
 
 function assertWindow(start, end) {
-  if (Date.parse(start) >= Date.parse(end)) {
+  if (timestampMicroseconds(start) >= timestampMicroseconds(end)) {
     throw new AdminMutationError("--ends-at must be later than --starts-at.", { field: "ends-at" });
   }
 }
 
 function parseCapacityOffer(argv) {
-  const usage = USAGE["listings.create"];
-  const { options } = parseOptions(
-    argv,
-    {
-      positionals: 0,
-      values: [
-        "gpu",
-        "nodes",
-        "gpus-per-node",
-        "site",
-        "starts-at",
-        "ends-at",
-        "price-per-gpu-hour",
-        "supplier-price-per-gpu-hour",
-        "down-payment-cents",
-        "access-mode",
-        "idempotency-key",
-      ],
-    },
-    usage
-  );
-  const startsAt = timestamp(options, "starts-at", usage);
-  const endsAt = timestamp(options, "ends-at", usage);
-  assertWindow(startsAt, endsAt);
-  const accessMode = options["access-mode"]?.trim();
-  if (accessMode !== undefined && !ACCESS_MODES.has(accessMode)) {
-    throw new AdminMutationError("--access-mode must be bare-metal or virtual-machine.", {
-      field: "access-mode",
-    });
-  }
-  const downPaymentCents = optionalCents(options);
+  const { $positionals, yes, ...input } = parseSemanticArguments(argv);
+  if ($positionals.length) throw new AdminMutationError("Use named options for listing writes.");
   return {
-    input: {
-      gpu_type: required(options, "gpu", usage),
-      node_count: positiveInteger(options, "nodes", usage),
-      gpus_per_node: positiveInteger(options, "gpus-per-node", usage),
-      site_nickname: required(options, "site", usage),
-      available_start_at: startsAt,
-      available_end_at: endsAt,
-      buy_now_price_per_gpu_hour: Number(price(options, usage)),
-      ...(options["supplier-price-per-gpu-hour"] !== undefined
-        ? {
-            cost_per_gpu_hour: Number(price(options, usage, "supplier-price-per-gpu-hour")),
-          }
-        : {}),
-      ...(downPaymentCents !== undefined ? { down_payment_cents: downPaymentCents } : {}),
-      ...(accessMode ? { access_mode: accessMode } : {}),
-    },
+    input,
     mutation: {
-      idempotencyKey: options["idempotency-key"],
+      idempotencyKey: input.idempotencyKey,
       safety: ADMIN_MUTATION_SAFETY.eligibleHumanOnly,
-      yes: options.yes === true,
+      yes: yes === true,
     },
   };
 }
@@ -174,29 +123,33 @@ function parseReservationCreate(argv) {
     {
       positionals: 0,
       values: [
-        "organization",
-        "capacity-offer",
+        "customer",
+        "listing-term",
+        "nodes",
+        "gpus",
         "starts-at",
         "ends-at",
-        "price-per-gpu-hour",
-        "down-payment-cents",
+        "transaction",
+        "vm-disk",
         "idempotency-key",
       ],
     },
     usage
   );
-  const startsAt = timestamp(options, "starts-at", usage);
-  const endsAt = timestamp(options, "ends-at", usage);
-  assertWindow(startsAt, endsAt);
-  const downPaymentCents = optionalCents(options);
+  const startsAt = reservationTimestamp(options, "starts-at", usage);
+  const endsAt =
+    options["ends-at"] === undefined ? null : reservationTimestamp(options, "ends-at", usage);
+  if (endsAt !== null) assertWindow(startsAt, endsAt);
   return {
     input: {
-      organization_id: uuid(options, "organization", usage),
-      listing_id: uuid(options, "capacity-offer", usage),
-      start_at: startsAt,
-      end_at: endsAt,
-      price_per_gpu_hour: price(options, usage),
-      ...(downPaymentCents !== undefined ? { down_payment_cents: downPaymentCents } : {}),
+      customerId: uuid(options, "customer", usage),
+      listingTermId: uuid(options, "listing-term", usage),
+      reservedNodeCount: positiveInteger(options, "nodes", usage),
+      reservedGpuCount: positiveInteger(options, "gpus", usage),
+      startsAt,
+      endsAt,
+      transactionId: uuid(options, "transaction", usage),
+      ...(options["vm-disk"] !== undefined ? { vmDiskId: uuid(options, "vm-disk", usage) } : {}),
     },
     mutation: {
       idempotencyKey: options["idempotency-key"],
@@ -206,46 +159,16 @@ function parseReservationCreate(argv) {
   };
 }
 
-function previewPayload(value) {
-  if (value?.ok === false) {
-    throw new AdminMutationError("The capacity offer contains an unknown hardware catalog term.", {
-      code: value.error ?? "unknown_catalog_term",
-    });
-  }
-  if (!value?.payload || typeof value.payload !== "object") {
-    throw new AdminMutationError("Capacity-offer normalization returned no effective terms.", {
-      code: "admin_review_incomplete",
-    });
-  }
-  return value.payload;
-}
-
-function usd(microUsd) {
-  return typeof microUsd === "number" ? (microUsd / 1_000_000).toFixed(6) : undefined;
-}
-
-function capacityOfferReview(payload, input, gpuLabel) {
-  const listing = payload.listing ?? {};
+function capacityOfferReview(body, editing) {
   return {
-    title: "Create capacity offer",
-    fields: [
-      { label: "GPU", value: gpuLabel(payload.gpu_type ?? listing.gpuSlug) },
-      { label: "Nodes to attach", value: payload.node_count ?? input.node_count },
-      { label: "GPUs per node", value: listing.gpusPerNode ?? input.gpus_per_node },
-      { label: "Site", value: payload.site_nickname ?? input.site_nickname },
-      { label: "Access mode", value: listing.accessMode },
-      { label: "Starts at", value: listing.startsAt ?? input.available_start_at },
-      { label: "Ends at", value: listing.endsAt ?? input.available_end_at },
-      { label: "Price per GPU-hour (USD)", value: input.buy_now_price_per_gpu_hour },
-      {
-        label: "Supplier price per GPU-hour (USD)",
-        value: usd(listing.supplierPricePerGpuHourMicroUsd),
-      },
-      { label: "Spread per GPU-hour (USD)", value: usd(listing.spreadPerGpuHourMicroUsd) },
-      { label: "Down payment (cents)", value: listing.downPaymentCents },
-    ],
-    consequence:
-      "Publishes a primary listing with these terms; attach its nodes before it reaches the market.",
+    title: editing ? "Edit listing term" : "Create capacity offer",
+    fields: Object.entries(body).map(([label, value]) => ({
+      label,
+      value: typeof value === "object" ? JSON.stringify(value) : value,
+    })),
+    consequence: editing
+      ? "Updates the selected advertised financial term."
+      : "Creates native capacity and its advertised financial terms.",
   };
 }
 
@@ -253,28 +176,29 @@ function reservationCreateReview(input) {
   return {
     title: "Create capacity reservation",
     fields: [
-      { label: "Organization", value: input.organization_id },
-      { label: "Capacity offer", value: input.listing_id },
-      { label: "Starts at", value: input.start_at },
-      { label: "Ends at", value: input.end_at },
-      { label: "Price per GPU-hour (USD)", value: input.price_per_gpu_hour },
-      ...(input.down_payment_cents !== undefined
-        ? [{ label: "Down payment (cents)", value: input.down_payment_cents }]
-        : []),
+      { label: "Customer", value: input.customerId },
+      { label: "Listing term", value: input.listingTermId },
+      { label: "Reserved nodes", value: input.reservedNodeCount },
+      { label: "Reserved GPUs", value: input.reservedGpuCount },
+      { label: "Starts at", value: input.startsAt },
+      { label: "Ends at", value: input.endsAt ?? "Open-ended" },
+      { label: "Transaction", value: input.transactionId },
+      ...(input.vmDiskId ? [{ label: "VM disk", value: input.vmDiskId }] : []),
     ],
-    consequence:
-      "Creates a schedule reservation on the listing's nodes with the reviewed dates and price.",
+    consequence: "Reserves the reviewed quantities and dates under the selected listing term.",
   };
 }
 
-async function runCapacityOffer({ execute, fetch, input, mutation, runtime }) {
+async function runCapacityOffer({ capability, execute, input, mutation, runtime }) {
   return runAdminMutation({
     ...runtime,
     ...mutation,
     prepare: async () => {
-      const payload = previewPayload(await execute(input));
-      const gpuLabel = await gpuLabeler(fetch, STAFF_HARDWARE_CATALOG);
-      return { review: capacityOfferReview(payload, input, gpuLabel), value: input };
+      const { payload } = await execute(input);
+      return {
+        review: capacityOfferReview(payload, capability.id === "listings.update"),
+        value: input,
+      };
     },
     execute: (value) => execute(value, { confirmed: true }),
   });
@@ -291,7 +215,13 @@ async function runReservationCreate({ execute, input, mutation, runtime }) {
 
 export const adminCapacityReservationHandlers = [
   {
-    capabilityId: "listings.create",
+    capabilityId: "listing.create",
+    parse: parseCapacityOffer,
+    run: runCapacityOffer,
+    safety: ADMIN_MUTATION_SAFETY.eligibleHumanOnly,
+  },
+  {
+    capabilityId: "listings.update",
     parse: parseCapacityOffer,
     run: runCapacityOffer,
     safety: ADMIN_MUTATION_SAFETY.eligibleHumanOnly,

package/src/admin-node-lifecycle.mjs

@@ -339,9 +339,7 @@ async function resolveLiveMachine(fetch, node) {
     })
   );
   const refs = new Set([id, text(node?.id), text(node?.k8s_node_name)].filter(Boolean));
-  const matches = rows.filter((machine) =>
-    refs.has(text(machine?.node_id))
-  );
+  const matches = rows.filter((machine) => refs.has(text(machine?.node_id)));
   if (matches.length > 1) {
     throw mutationError(`Multiple live machines resolve to node ${id}; no reboot was submitted.`, {
       code: "ambiguous_live_machine",
@@ -676,14 +674,39 @@ function goalSatisfied(command, node, input) {
   if (command === "suspend-management") return isOffGrid(node);
   if (command === "resume-management") return !isOffGrid(node);
   if (command === "assign") return reservationId(node) === input.reservation_id;
-  if (["pending", "rebooting"].includes(text(node?.cleanup_state).toLowerCase())) return false;
-  const readiness = node?.health_readiness;
-  return (
+  if (cleanupState(node) === "failed") return false;
+  return !restartInProgress(node);
+}
+
+function cleanupState(node) {
+  return text(node?.cleanup_state).toLowerCase();
+}
+
+function restartInProgress(node) {
+  if (["pending", "rebooting"].includes(cleanupState(node))) return true;
+  const readiness = node.health_readiness;
+  return !(
     readiness?.ready === true ||
     ["ready", "running"].includes(text(readiness?.status).toLowerCase())
   );
 }
 
+// Before the restart starts, a healthy node already looks "done", so reboot
+// and hard-reset only count as complete after the restart has been observed.
+function restartGoal(command, input) {
+  if (command !== "reboot" && command !== "hard-reset") {
+    return { isReady: (node) => goalSatisfied(command, node, input), isTerminal: () => false };
+  }
+  let restartSeen = false;
+  return {
+    isReady: (node) => {
+      if (node && restartInProgress(node)) restartSeen = true;
+      return restartSeen && goalSatisfied(command, node, input);
+    },
+    isTerminal: (node) => restartSeen && cleanupState(node) === "failed",
+  };
+}
+
 function waitResult(kind, command, id, accepted, lastState) {
   const timeout = kind === "timeout";
   return {
@@ -711,13 +734,15 @@ function waitResult(kind, command, id, accepted, lastState) {
 async function waitForGoal({ command, fetch, input, nodeId: id, runtime, accepted }) {
   let lastState = null;
   let outcome;
+  const { isReady, isTerminal } = restartGoal(command, input);
   try {
     outcome = await waitForReadGoal(
       {
         command: `ornn admin nodes ${command}`,
         initial: null,
         intervalMs: POLL_INTERVAL_MS,
-        isReady: (node) => goalSatisfied(command, node, input),
+        isReady,
+        isTerminal,
         message: () => `Waiting for node ${id} to reach the requested state.`,
         onObserve: (node) => {
           lastState = node;
@@ -790,6 +815,22 @@ async function waitForGoal({ command, fetch, input, nodeId: id, runtime, accepte
       errors: [],
     };
   }
+  if (outcome.kind === "terminal") {
+    return {
+      data: { ...accepted, node_id: id, state: safeNodeState(outcome.value) },
+      exitCode: 1,
+      outcome: { class: "failed", phase: "cleanup_failed" },
+      resume: resumeReference(id),
+      action: inspectionAction(id),
+      errors: [
+        {
+          code: "cleanup_failed",
+          message: "The node reported the operation as failed.",
+          retryable: false,
+        },
+      ],
+    };
+  }
   return waitResult(outcome.kind, command, id, accepted, outcome.value);
 }