@ornncompute/cli 1.0.35 → 1.0.62

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);
 }
 

package/src/admin-shell.mjs

@@ -156,6 +156,24 @@ function positiveInteger(value, name, maximum) {
   return parsed;
 }
 
+function nonnegativeInteger(value, name) {
+  if (value === undefined) return undefined;
+  const parsed = Number(value);
+  if (!Number.isSafeInteger(parsed) || parsed < 0) {
+    throw new AdminUsageError(`--${name} must be a non-negative integer.`, {
+      field: name,
+    });
+  }
+  return parsed;
+}
+
+function booleanOption(value, name) {
+  if (value === undefined) return undefined;
+  if (value === "true") return true;
+  if (value === "false") return false;
+  throw new AdminUsageError(`--${name} must be true or false.`, { field: name });
+}
+
 function parseAdminInput(capability, argv) {
   const command = vnextCommand(capability).join(" ");
   const help = capability.cli.vnext;
@@ -167,22 +185,37 @@ function parseAdminInput(capability, argv) {
     throw new AdminUsageError(usage);
   }
 
-  const limit = positiveInteger(options.limit, "limit", MAX_PAGE_LIMIT) ?? DEFAULT_PAGE_LIMIT;
+  const offsetPagination = ["users.list", "organization.list"].includes(capability.id);
+  const reservationList = capability.id === "reservation.list";
+  const limit = positiveInteger(
+    options.limit,
+    "limit",
+    offsetPagination || reservationList ? 100 : MAX_PAGE_LIMIT
+  ) ?? (offsetPagination ? 25 : DEFAULT_PAGE_LIMIT);
   const input = {};
   if (nodeCommand) input.node_id = positionals[0];
   if (options.supplier) input.organization_id = options.supplier;
+  if (options.organization && ["users.list", "organization.invite"].includes(capability.id)) {
+    input.organization_id = options.organization;
+  }
   if (options.facility) input.facility_id = options.facility;
   if (options.status) input.status = options.status;
   if (options.email) input.email = options.email;
-  if (options.organization) input.organization = options.organization;
-  if (options.name) input.name = options.name;
+  if (options.reservation) input.reservation_id = options.reservation;
+  if (options.customer) input.customerId = options.customer;
+  if (options.listing) input.listingId = options.listing;
+  if (options["listing-term"]) input.listingTermId = options["listing-term"];
+  if (options.query) input.q = options.query;
+  if (options.role) input.role = options.role;
+  const approved = booleanOption(options.approved, "approved");
+  if (approved !== undefined) input.approved = approved;
+  if (options.ids) input.ids = options.ids.split(",");
   if (options.span) input.span = options.span;
   if (options.start) input.start = options.start;
   if (options.end) input.end = options.end;
   if (options.before) input.before = options.before;
   if (options.stream) input.stream = options.stream;
   if (options.cursor && command === "admin nodes logs") input.cursor = options.cursor;
-  if (command === "admin users search") input.max = 1000;
   const maxPoints = positiveInteger(options["max-points"], "max-points", 500);
   if (maxPoints !== undefined) input.max_points = maxPoints;
   const count = positiveInteger(options.count, "count", 500);
@@ -190,11 +223,23 @@ function parseAdminInput(capability, argv) {
 
   if (command === "admin nodes logs") return parseLogPage(input);
 
-  const ownerPagination = ["facilities.list", "nodes.list"].includes(capability.id);
+  const ownerPagination = ["facilities.list", "nodes.list", "reservation.list"].includes(
+    capability.id
+  );
+  const explicitOffset = nonnegativeInteger(options.offset, "offset");
   if (ownerPagination) {
     input.limit = limit;
     if (options.cursor) input.cursor = options.cursor;
   }
+  if (offsetPagination) {
+    if (explicitOffset !== undefined && options.cursor) {
+      throw new AdminUsageError("--offset and --cursor cannot be used together.", {
+        field: "offset",
+      });
+    }
+    input.limit = limit;
+    input.offset = explicitOffset ?? decodeCursor(command, options.cursor);
+  }
 
   return {
     input,
@@ -202,6 +247,8 @@ function parseAdminInput(capability, argv) {
       cursor: options.cursor,
       limit,
       ownerPagination,
+      ownerOffsetPagination: offsetPagination,
+      offset: input.offset,
     },
   };
 }
@@ -281,7 +328,16 @@ function collectionKey(capability) {
   if (root === "nodes" && leaf === "logs") return "logs";
   if (!["list", "search"].includes(leaf)) return null;
   if (root === "enrollment-tokens") return "enrollment_tokens";
-  return ["facilities", "nodes", "reservations", "suppliers", "users"].includes(root) ? root : null;
+  return [
+    "facilities",
+    "nodes",
+    "organizations",
+    "reservations",
+    "suppliers",
+    "users",
+  ].includes(root)
+    ? root
+    : null;
 }
 
 function isSensitiveAdminField(key) {
@@ -337,21 +393,36 @@ function encodeCursor(command, offset) {
 
 function decodeCursor(command, cursor) {
   if (!cursor) return 0;
+  let decoded;
   try {
-    const decoded = JSON.parse(Buffer.from(cursor, "base64url").toString("utf8"));
-    if (decoded.command === command && Number.isInteger(decoded.offset) && decoded.offset >= 0) {
-      return decoded.offset;
-    }
-    if (decoded.command !== undefined || decoded.offset !== undefined) {
-      throw new AdminUsageError("The pagination cursor belongs to a different admin command.", {
-        code: "invalid_cursor",
-        field: "cursor",
-      });
-    }
-  } catch (error) {
-    if (error instanceof AdminUsageError) throw error;
+    const bytes = Buffer.from(cursor, "base64url");
+    if (bytes.toString("base64url") !== cursor) throw new Error("invalid base64url");
+    decoded = JSON.parse(bytes.toString("utf8"));
+  } catch {
+    throw new AdminUsageError("The pagination cursor is invalid.", {
+      code: "invalid_cursor",
+      field: "cursor",
+    });
+  }
+  if (!decoded || typeof decoded !== "object" || Array.isArray(decoded)) {
+    throw new AdminUsageError("The pagination cursor is invalid.", {
+      code: "invalid_cursor",
+      field: "cursor",
+    });
+  }
+  if (decoded.command !== command) {
+    throw new AdminUsageError("The pagination cursor belongs to a different admin command.", {
+      code: "invalid_cursor",
+      field: "cursor",
+    });
+  }
+  if (!Number.isSafeInteger(decoded.offset) || decoded.offset < 0) {
+    throw new AdminUsageError("The pagination cursor has an invalid offset.", {
+      code: "invalid_cursor",
+      field: "cursor",
+    });
   }
-  return 0;
+  return decoded.offset;
 }
 
 export function finalizeAdminResult(capability, payload, pagination) {
@@ -362,18 +433,27 @@ export function finalizeAdminResult(capability, payload, pagination) {
   const rows = collectionRows(payload, key);
   const offset = pagination.ownerPagination
     ? 0
-    : pagination.logQuery
+    : pagination.logQuery || pagination.ownerOffsetPagination
       ? pagination.offset
       : decodeCursor(command, pagination.cursor);
   const selected = (
-    pagination.ownerPagination ? rows : rows.slice(offset, offset + pagination.limit)
+    pagination.ownerPagination || pagination.ownerOffsetPagination
+      ? rows
+      : rows.slice(offset, offset + pagination.limit)
   ).map(sanitizeAdminValue);
+  const ownerNextOffset =
+    pagination.ownerOffsetPagination && payload && !Array.isArray(payload)
+      ? payload.next_offset
+      : undefined;
   const ownerNextCursor =
     payload && !Array.isArray(payload)
       ? (payload.next_cursor ?? payload.nextCursor ?? payload.page?.next_cursor ?? null)
       : null;
-  let nextCursor =
-    !pagination.ownerPagination && offset + selected.length < rows.length
+  let nextCursor = pagination.ownerOffsetPagination
+    ? Number.isSafeInteger(ownerNextOffset) && ownerNextOffset > offset
+      ? encodeCursor(command, ownerNextOffset)
+      : null
+    : !pagination.ownerPagination && offset + selected.length < rows.length
       ? encodeCursor(command, offset + selected.length)
       : (ownerNextCursor ?? null);
   if (pagination.ownerPagination && nextCursor !== null && nextCursor === pagination.cursor) {
@@ -438,12 +518,18 @@ export function writeAdminResultHuman(stdout, command, result, input = {}) {
   if (result.page.next_cursor) {
     const target = command === "admin nodes logs" ? ` ${shellSingleQuote(input.node_id)}` : "";
     const filters = [
-      ["supplier", input.organization_id],
+      ["supplier", command === "admin users list" ? undefined : input.organization_id],
+      ["organization", command === "admin users list" ? input.organization_id : undefined],
       ["facility", input.facility_id],
       ["status", input.status],
-      ["email", input.email],
-      ["organization", input.organization],
-      ["name", input.name],
+      ["reservation", input.reservation_id],
+      ["customer", input.customerId],
+      ["listing", input.listingId],
+      ["listing-term", input.listingTermId],
+      ["query", input.q],
+      ["role", input.role],
+      ["approved", input.approved],
+      ["ids", Array.isArray(input.ids) ? input.ids.join(",") : undefined],
       ["limit", input.limit],
     ]
       .filter(([, value]) => value !== undefined)

package/src/catalog-shell.mjs

@@ -1,5 +1,3 @@
-import { HARDWARE_CATALOG_PATH } from "../vendor/capabilities/cli.js";
-
 import {
   CliApiError,
   cliRequest,
@@ -793,7 +791,7 @@ const CUSTOMER_FORBIDDEN_FIELDS = {
 };
 const SUPPLIER_OWNER_FIELDS = { organizationId: true, organization_id: true };
 
-// The caller's own organization on a listing it relisted is not supplier identity.
+// A listing owner may receive its own organization ID.
 function assertCustomerResultSafe(value, ownOrganizationId) {
   if (Array.isArray(value)) {
     for (const item of value) assertCustomerResultSafe(item, ownOrganizationId);
@@ -802,6 +800,7 @@ function assertCustomerResultSafe(value, ownOrganizationId) {
   if (!value || typeof value !== "object") return;
   const ownedBySupplier = supplierOwnedRecord(value);
   for (const [key, child] of Object.entries(value)) {
+    if (key === "supplierId" && value.capacityListingId && child === ownOrganizationId) continue;
     if (
       CUSTOMER_FORBIDDEN_FIELDS[key] === true ||
       (ownedBySupplier &&
@@ -835,11 +834,13 @@ function parseCapabilityInput(capability, rawInput) {
 
 // Commerce's market routes and Markets serve every caller on one path and
 // decide from the session what it may do; a staff session is an admin there.
-const ROLE_AWARE_PREFIXES = ["/commerce/listings", "/commerce/reservations", "/commerce/fees", "/v1/markets"];
+const ROLE_AWARE_PREFIXES = ["/commerce/v2/listings", "/commerce/reservations", "/v1/markets"];
 
 function isRoleAwarePath(path) {
   const pathname = String(path).split("?")[0];
-  return ROLE_AWARE_PREFIXES.some((prefix) => pathname === prefix || pathname.startsWith(`${prefix}/`));
+  return ROLE_AWARE_PREFIXES.some(
+    (prefix) => pathname === prefix || pathname.startsWith(`${prefix}/`)
+  );
 }
 
 function adminFetch(io, path, init = {}) {
@@ -852,7 +853,9 @@ function adminFetch(io, path, init = {}) {
     ...(init.headers !== undefined ? { headers: init.headers } : {}),
     ...((init.signal ?? io.signal) !== undefined ? { signal: init.signal ?? io.signal } : {}),
   };
-  return isRoleAwarePath(path) ? cliRequest(request) : operatorRequest(request);
+  return isRoleAwarePath(path) || (path === "/v1/staff/invites" && request.method === "POST")
+    ? cliRequest(request)
+    : operatorRequest(request);
 }
 
 async function customerCapabilityFetch(io, path, init = {}, sessionSnapshot) {
@@ -992,20 +995,6 @@ async function executeCapability(
         role,
         fetch: (path, init = {}) => {
           if (executionRuntime?.transport) return executionRuntime.transport(path, init);
-          if (
-            audience === "admin" &&
-            capability.id === "listings.create" &&
-            path === HARDWARE_CATALOG_PATH
-          ) {
-            return operatorRequest({
-              endpoint: "/catalog/hardware",
-              env: io.env,
-              fetchImpl: io.fetchImpl,
-              method: init.method ?? "GET",
-              ...(init.headers !== undefined ? { headers: init.headers } : {}),
-              ...(init.signal !== undefined ? { signal: init.signal } : {}),
-            });
-          }
           if (audience === "admin") {
             // Shared observability capabilities use their owner namespace;
             // the CLI reaches those same node-scoped routes through staff auth.
@@ -1173,9 +1162,12 @@ export async function runCatalogCli(argv, io, { version }) {
         eligibleHuman,
         machine,
       });
-      const role = await resolveAdminRole(io);
       const adminRequest = resolveAdminRequest(catalog, capabilities.ADMIN_CLI_ROOTS, request.argv);
       activeCommand = adminRequest.command;
+      if (adminRequest.kind === "command" && !adminRequest.handler) {
+        adminRequest.input = parseCapabilityInput(adminRequest.capability, adminRequest.input);
+      }
+      const role = await resolveAdminRole(io);
       if (adminRequest.kind === "root") {
         const data = adminRootData(catalog, capabilities.ADMIN_CLI_ROOTS, adminRequest.root);
         if (machine) writeMachine(stdout, format, resultEnvelope(adminRequest.command, data));

package/src/evidence-commands.mjs

@@ -1040,7 +1040,7 @@ function metricSummary(metrics) {
     .join(", ");
 }
 
-function evidenceLines(data) {
+function evidenceLines(data, printedLogs = new Map()) {
   const lines = [
     data.resource.kind === "machine"
       ? `Machine: ${data.resource.hostname ?? "selected machine"}`
@@ -1063,7 +1063,7 @@ function evidenceLines(data) {
   if (data.logs) {
     lines.push(`Logs (${data.logs.stream}): ${data.logs.state}`);
     for (const [index, source] of data.logs.sources.entries()) {
-      for (const entry of source.entries) {
+      for (const entry of unprintedLogLines(source, printedLogs.get(index)).fresh) {
         lines.push(
           `  ${evidenceSourceLabel(data, index)} · ${entry.observed_at} · ${entry.severity} · ${entry.message}`
         );
@@ -1131,7 +1131,21 @@ function liveState(data) {
   };
 }
 
-function writeHumanProgress(stdout, data) {
+// Follow re-reads the whole live window, so count each line's occurrences
+// rather than trusting timestamps: identical records still print once each,
+// and a late older line is still new.
+function unprintedLogLines(source, printed = new Map()) {
+  const counts = new Map();
+  const fresh = source.entries.filter((line) => {
+    const key = `${line.observed_at} ${line.severity} ${line.message}`;
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+    return counts.get(key) > (printed.get(key) ?? 0);
+  });
+  for (const [key, count] of counts) counts.set(key, Math.max(count, printed.get(key) ?? 0));
+  return { fresh, seen: counts };
+}
+
+function writeHumanProgress(stdout, data, printedLogs) {
   if (data.metrics) {
     for (const [index, source] of data.metrics.series.entries()) {
       const point = source.points.at(-1);
@@ -1144,7 +1158,9 @@ function writeHumanProgress(stdout, data) {
   }
   if (data.logs) {
     for (const [index, source] of data.logs.sources.entries()) {
-      for (const line of source.entries) {
+      const { fresh, seen } = unprintedLogLines(source, printedLogs.get(index));
+      printedLogs.set(index, seen);
+      for (const line of fresh) {
         stdout.write(
           `${evidenceSourceLabel(data, index)} ${line.observed_at} ${line.severity} ${line.message}\n`
         );
@@ -1153,14 +1169,14 @@ function writeHumanProgress(stdout, data) {
   }
 }
 
-function streamResult(interaction, data, progress, exitCode, outcome, errors = []) {
+function streamResult(interaction, data, progress, printedLogs, exitCode, outcome, errors = []) {
   return interaction.result({
     data,
     errors: publicErrors(errors),
     exitCode,
     outcome,
     progress,
-    presentation: { lines: evidenceLines(data) },
+    presentation: { lines: evidenceLines(data, printedLogs) },
   });
 }
 
@@ -1191,12 +1207,13 @@ async function follow(resource, requested, initialWindow, options, deps, interac
   const deadline = timeoutMs === null ? Number.POSITIVE_INFINITY : startedAt + timeoutMs;
   let current = resourceBase(resource);
   const progress = [];
+  const printedLogs = new Map();
   let iteration = 0;
   try {
     for (;;) {
       if (signal.aborted) {
         current = streamState(current, "interrupted");
-        return streamResult(interaction, current, progress, 130, {
+        return streamResult(interaction, current, progress, printedLogs, 130, {
           class: "ended",
           phase: "interrupted",
         });
@@ -1204,7 +1221,7 @@ async function follow(resource, requested, initialWindow, options, deps, interac
       const observedAt = nowMilliseconds(deps.now);
       if (observedAt >= deadline) {
         current = streamState(current, "ended");
-        return streamResult(interaction, current, progress, 124, {
+        return streamResult(interaction, current, progress, printedLogs, 124, {
           class: "ended",
           phase: "observation_timeout",
         });
@@ -1230,7 +1247,7 @@ async function follow(resource, requested, initialWindow, options, deps, interac
           { ...resourceBase(resource), metrics: collected.metrics, logs: collected.logs },
           "interrupted"
         );
-        return streamResult(interaction, current, progress, 130, {
+        return streamResult(interaction, current, progress, printedLogs, 130, {
           class: "ended",
           phase: "interrupted",
         });
@@ -1248,6 +1265,7 @@ async function follow(resource, requested, initialWindow, options, deps, interac
           interaction,
           current,
           progress,
+          printedLogs,
           status.exitCode,
           status.outcome,
           collected.errors
@@ -1261,11 +1279,11 @@ async function follow(resource, requested, initialWindow, options, deps, interac
         sequence: iteration,
       };
       if (interaction.machine) progress.push(progressEntry);
-      else writeHumanProgress(deps.stdout, current);
+      else writeHumanProgress(deps.stdout, current, printedLogs);
 
       if (count !== null && iteration >= count) {
         current = streamState(current, "ended");
-        return streamResult(interaction, current, progress, 0, {
+        return streamResult(interaction, current, progress, printedLogs, 0, {
           class: "ended",
           phase: "observation_complete",
         });
@@ -1275,7 +1293,7 @@ async function follow(resource, requested, initialWindow, options, deps, interac
       const continued = await sleepUntil(Math.min(intervalMs, remaining), deps, signal);
       if (!continued) {
         current = streamState(current, "interrupted");
-        return streamResult(interaction, current, progress, 130, {
+        return streamResult(interaction, current, progress, printedLogs, 130, {
           class: "ended",
           phase: "interrupted",
         });