@ornncompute/cli 1.0.72 → 1.0.97

package/src/admin-node-diagnostics.mjs

@@ -36,11 +36,6 @@ function parseOptions(argv, allowed, usage) {
     if (options[name] !== undefined) {
       throw usageError(`${usage}\n--${name} may be supplied only once.`, name);
     }
-    if (name === "yes") {
-      if (separator !== -1) throw usageError(`${usage}\n--yes does not take a value.`, "yes");
-      options.yes = true;
-      continue;
-    }
     const parsed = optionValue(argv, index, name, usage);
     options[name] = parsed.value;
     index += parsed.consumed;
@@ -64,18 +59,13 @@ function timeoutSeconds(value) {
 }
 
 export function parseAdminNodeDiagnoseArgs(argv) {
-  const { options, positionals } = parseOptions(
-    argv,
-    new Set(["yes", "idempotency-key"]),
-    DIAGNOSE_USAGE
-  );
+  const { options, positionals } = parseOptions(argv, new Set(["idempotency-key"]), DIAGNOSE_USAGE);
   if (positionals.length !== 1 || !positionals[0]) throw usageError(DIAGNOSE_USAGE, "node-id");
   return {
     input: { node_id: positionals[0] },
     mutation: {
       idempotencyKey: options["idempotency-key"],
       safety: ADMIN_MUTATION_SAFETY.eligibleHumanOnly,
-      yes: options.yes === true,
     },
   };
 }
@@ -83,7 +73,7 @@ export function parseAdminNodeDiagnoseArgs(argv) {
 export function parseAdminNodeExecArgs(argv) {
   const { options, positionals } = parseOptions(
     argv,
-    new Set(["command", "timeout", "yes", "idempotency-key"]),
+    new Set(["command", "timeout", "idempotency-key"]),
     EXEC_USAGE
   );
   if (positionals.length !== 1 || !positionals[0]) throw usageError(EXEC_USAGE, "node-id");
@@ -99,7 +89,6 @@ export function parseAdminNodeExecArgs(argv) {
     mutation: {
       idempotencyKey: options["idempotency-key"],
       safety: ADMIN_MUTATION_SAFETY.eligibleHumanOnly,
-      yes: options.yes === true,
     },
   };
 }
@@ -123,7 +112,6 @@ function nodeContext(payload, expectedNodeId) {
   }
   const explicitReachability =
     presentString(payload.reachability?.status) ??
-    presentString(payload.off_grid_reachability?.status) ??
     (typeof payload.reachable === "boolean"
       ? payload.reachable
         ? "reachable"
@@ -138,10 +126,7 @@ function nodeContext(payload, expectedNodeId) {
       presentString(payload.status) ??
       "unknown",
     reachability: explicitReachability ?? "unknown",
-    observed_at:
-      presentString(payload.observed_at) ??
-      presentString(payload.last_heartbeat_at) ??
-      presentString(payload.off_grid_reachability?.last_checked_at),
+    observed_at: presentString(payload.observed_at) ?? presentString(payload.last_heartbeat_at),
   };
 }
 
@@ -272,27 +257,6 @@ function executionResult(raw, input, target) {
   };
 }
 
-function declinedResult(input) {
-  return {
-    data: {
-      declined: true,
-      node: { node_id: input.node_id },
-      ...(input.command ? { request: requestCorrelation(input) } : {}),
-    },
-    exitCode: 1,
-    outcome: { class: "failed", phase: "consent_declined" },
-    action: null,
-    resume: null,
-    errors: [
-      {
-        code: "consent_declined",
-        message: "The action was declined; no mutation was submitted.",
-        retryable: false,
-      },
-    ],
-  };
-}
-
 function interruptedResult(input) {
   return {
     data: {
@@ -343,7 +307,6 @@ async function runDiagnosis({ input, mutation, runtime, execute, fetch }) {
       },
       execute: async () => execute({ node_id: input.node_id }, { confirmed: true }),
     });
-    if (result.status === "declined") return declinedResult(input);
     return diagnosisResult(result.data, target);
   } catch (error) {
     if (wasInterrupted(error, runtime)) return interruptedResult(input);
@@ -388,7 +351,6 @@ async function runExecution({ input, mutation, runtime, execute, fetch }) {
           { confirmed: true }
         ),
     });
-    if (result.status === "declined") return declinedResult(input);
     return executionResult(result.data, input, target);
   } catch (error) {
     if (wasInterrupted(error, runtime)) return interruptedResult(input);

package/src/admin-node-lifecycle.mjs

@@ -1,3 +1,4 @@
+import { getReservation } from "../vendor/api-client/commerce.js";
 import { ADMIN_MUTATION_SAFETY, AdminMutationError, runAdminMutation } from "./admin-mutations.mjs";
 import { isRecoverableWaitFailure } from "./interaction-runtime.mjs";
 import { waitForGoal as waitForReadGoal } from "./wait-runtime.mjs";
@@ -9,9 +10,7 @@ const POLL_INTERVAL_MS = 1_000;
 const COMMAND_BY_CAPABILITY = Object.freeze({
   "nodes.reboot": "reboot",
   "nodes.hard_reset": "hard-reset",
-  "nodes.suspend_management": "suspend-management",
-  "nodes.resume_management": "resume-management",
-  "nodes.terminate": "terminate",
+  "node.terminate": "terminate",
   "nodes.assign": "assign",
 });
 
@@ -22,35 +21,22 @@ const CAPABILITY_BY_COMMAND = Object.freeze(
 );
 
 const USAGE = Object.freeze({
-  reboot: "Usage: ornn admin nodes reboot <node-ref> [--yes] [--no-wait] [--timeout SECONDS]",
+  reboot: "Usage: ornn admin nodes reboot <node-ref> [--no-wait] [--timeout SECONDS]",
   "hard-reset":
-    "Usage: ornn admin nodes hard-reset <node-ref> --erase-local-data [--yes] [--no-wait] [--timeout SECONDS]",
-  "suspend-management":
-    "Usage: ornn admin nodes suspend-management <node-ref> [--reason TEXT] [--yes] [--idempotency-key KEY] [--wait|--no-wait] [--timeout SECONDS]",
-  "resume-management":
-    "Usage: ornn admin nodes resume-management <node-ref> [--yes] [--idempotency-key KEY] [--wait|--no-wait] [--timeout SECONDS]",
+    "Usage: ornn admin nodes hard-reset <node-ref> --erase-local-data [--no-wait] [--timeout SECONDS]",
   terminate:
-    "Usage: ornn admin nodes terminate <node-ref> --delete-node-record [--skip-cleanup] [--reason TEXT] [--yes] [--idempotency-key KEY]",
+    "Usage: ornn admin nodes terminate <node-ref> --delete-node-record [--reason TEXT] [--idempotency-key KEY]",
   assign:
-    "Usage: ornn admin nodes assign <node-ref> --reservation RESERVATION [--yes] [--idempotency-key KEY] [--wait|--no-wait] [--timeout SECONDS]",
+    "Usage: ornn admin nodes assign <node-ref> --reservation RESERVATION [--idempotency-key KEY] [--wait|--no-wait] [--timeout SECONDS]",
 });
 
-const BOOLEAN_OPTIONS = new Set([
-  "delete-node-record",
-  "erase-local-data",
-  "no-wait",
-  "skip-cleanup",
-  "wait",
-  "yes",
-]);
+const BOOLEAN_OPTIONS = new Set(["delete-node-record", "erase-local-data", "no-wait", "wait"]);
 const VALUE_OPTIONS = new Set(["idempotency-key", "reason", "reservation", "timeout"]);
 const ALLOWED_OPTIONS = Object.freeze({
-  reboot: new Set(["yes", "wait", "no-wait", "timeout"]),
-  "hard-reset": new Set(["erase-local-data", "yes", "wait", "no-wait", "timeout"]),
-  "suspend-management": new Set(["reason", "yes", "idempotency-key", "wait", "no-wait", "timeout"]),
-  "resume-management": new Set(["yes", "idempotency-key", "wait", "no-wait", "timeout"]),
-  terminate: new Set(["delete-node-record", "skip-cleanup", "reason", "yes", "idempotency-key"]),
-  assign: new Set(["reservation", "yes", "idempotency-key", "wait", "no-wait", "timeout"]),
+  reboot: new Set(["wait", "no-wait", "timeout"]),
+  "hard-reset": new Set(["erase-local-data", "wait", "no-wait", "timeout"]),
+  terminate: new Set(["delete-node-record", "reason", "idempotency-key"]),
+  assign: new Set(["reservation", "idempotency-key", "wait", "no-wait", "timeout"]),
 });
 
 function mutationError(message, { code = "usage_error", field } = {}) {
@@ -135,22 +121,16 @@ export function parseAdminNodeLifecycleInput(command, argv) {
     });
   }
   if (name === "hard-reset" && options["erase-local-data"] !== true) {
-    throw mutationError(
-      `${usage}\nHard reset requires --erase-local-data; --yes cannot imply data loss.`,
-      {
-        code: "erase_local_data_required",
-        field: "erase-local-data",
-      }
-    );
+    throw mutationError(`${usage}\nHard reset requires --erase-local-data.`, {
+      code: "erase_local_data_required",
+      field: "erase-local-data",
+    });
   }
   if (name === "terminate" && options["delete-node-record"] !== true) {
-    throw mutationError(
-      `${usage}\nTermination requires --delete-node-record; --yes cannot imply deletion.`,
-      {
-        code: "delete_node_record_required",
-        field: "delete-node-record",
-      }
-    );
+    throw mutationError(`${usage}\nTermination requires --delete-node-record.`, {
+      code: "delete_node_record_required",
+      field: "delete-node-record",
+    });
   }
   if (name === "assign" && !options.reservation) {
     throw mutationError(`${usage}\nAssignment requires --reservation.`, {
@@ -159,40 +139,29 @@ export function parseAdminNodeLifecycleInput(command, argv) {
     });
   }
   if (name !== "hard-reset" && options["erase-local-data"]) throw mutationError(usage);
-  if (name !== "terminate" && (options["delete-node-record"] || options["skip-cleanup"])) {
-    throw mutationError(usage);
-  }
+  if (name !== "terminate" && options["delete-node-record"]) throw mutationError(usage);
   if (name !== "assign" && options.reservation) throw mutationError(usage);
-  if (!name.includes("management") && name !== "terminate" && options.reason) {
-    throw mutationError(usage);
-  }
+  if (name !== "terminate" && options.reason) throw mutationError(usage);
 
   const idempotencyKey = options["idempotency-key"]?.trim();
   const safety =
     name === "reboot" || name === "hard-reset"
-      ? ADMIN_MUTATION_SAFETY.eligibleHumanOnly
+      ? ADMIN_MUTATION_SAFETY.direct
       : ADMIN_MUTATION_SAFETY.reconcile;
   return {
     input: {
       node_ref: nodeRef,
-      ...(options.yes ? { yes: true } : {}),
       ...(idempotencyKey ? { idempotency_key: idempotencyKey } : {}),
       ...(options.reason ? { reason: options.reason } : {}),
       ...(options.wait ? { wait: true } : options["no-wait"] ? { wait: false } : {}),
       ...(options.timeout ? { timeout_seconds: durationSeconds(options.timeout, usage) } : {}),
       ...(name === "hard-reset" ? { erase_local_data: true } : {}),
-      ...(name === "terminate"
-        ? {
-            delete_node_record: true,
-            ...(options["skip-cleanup"] ? { skip_cleanup: true } : {}),
-          }
-        : {}),
+      ...(name === "terminate" ? { delete_node_record: true } : {}),
       ...(name === "assign" ? { reservation_id: options.reservation } : {}),
     },
     mutation: {
       idempotencyKey,
       safety,
-      yes: options.yes === true,
     },
   };
 }
@@ -218,16 +187,7 @@ function nodeSnapshot(node) {
     organization_id: text(node?.organization_id),
     facility_id: text(node?.facility_id ?? node?.facilityId),
     reservation_id: reservationId(node),
-    off_grid: node?.off_grid === true,
     cleanup_state: text(node?.cleanup_state),
-    reachability:
-      node?.reachable === false || node?.health_readiness?.reachable === false
-        ? "unreachable"
-        : text(
-            node?.reachability?.status ??
-              node?.off_grid_reachability?.status ??
-              node?.health_readiness?.reachability
-          ),
   };
 }
 
@@ -235,18 +195,6 @@ function sameSnapshot(left, right) {
   return JSON.stringify(nodeSnapshot(left)) === JSON.stringify(nodeSnapshot(right));
 }
 
-function isOffGrid(node) {
-  const snapshot = nodeSnapshot(node);
-  return snapshot.off_grid || ["off-grid", "off_grid"].includes(snapshot.status.toLowerCase());
-}
-
-function isUnreachable(node) {
-  const snapshot = nodeSnapshot(node);
-  return (
-    isOffGrid(node) || ["unreachable", "offline"].includes(snapshot.reachability.toLowerCase())
-  );
-}
-
 function nodeRows(payload) {
   if (Array.isArray(payload)) return payload;
   return Array.isArray(payload?.nodes) ? payload.nodes : [];
@@ -357,20 +305,18 @@ async function resolveLiveMachine(fetch, node) {
 function reservationSnapshot(reservation, requestedId) {
   return {
     reservation_id: text(reservation?.reservationId) || requestedId,
-    organization_id: text(reservation?.organizationId),
+    organization_id: text(reservation?.customerId ?? reservation?.organizationId),
     listing_id: text(reservation?.listingId),
     kind: text(reservation?.kind),
     status: text(reservation?.status),
-    node_count: Number(reservation?.nodeCount ?? 0) || 0,
+    node_count: Number(reservation?.reservedNodeCount ?? 0) || 0,
     starts_at: text(reservation?.startsAt),
     ends_at: text(reservation?.endsAt),
   };
 }
 
 async function readReservation(fetch, id) {
-  const reservation = await fetch(`/commerce/reservations/${encodeURIComponent(id)}`, {
-    method: "GET",
-  });
+  const reservation = await getReservation(fetch, id);
   return reservationSnapshot(reservation, id);
 }
 
@@ -412,11 +358,9 @@ function safeOwnerResult(result) {
   const safe = {};
   for (const key of [
     "deleted",
-    "forced",
     "id",
     "mode",
     "node_id",
-    "off_grid",
     "packet_id",
     "request_id",
     "reservation_id",
@@ -484,47 +428,13 @@ async function prepareLifecycle({ command, fetch, input, machine }) {
     };
   }
 
-  if (command === "suspend-management") {
-    fields.push({ label: "Host power", value: "leave powered on" });
-    fields.push({ label: "Managed access", value: "remove agent management and managed SSH keys" });
-    if (input.reason) fields.push({ label: "Reason", value: input.reason });
-    return {
-      review: {
-        title: "Review management suspension",
-        fields,
-        consequence: "Ornn management and managed access end while the host remains powered on.",
-      },
-      value,
-    };
-  }
-
-  if (command === "resume-management") {
-    fields.push({ label: "Management", value: "remotely re-enroll the node" });
-    fields.push({ label: "Managed access", value: "restore after successful enrollment" });
-    return {
-      review: {
-        title: "Review management resumption",
-        fields,
-        consequence: "Ornn uses the stored admin access to reinstall management on this host.",
-      },
-      value,
-    };
-  }
-
   if (command === "terminate") {
-    if (input.skip_cleanup && !isUnreachable(node)) {
-      throw mutationError(
-        "--skip-cleanup is allowed only when the authoritative node read says the node is unreachable or off-grid.",
-        { code: "skip_cleanup_requires_unreachable", field: "skip-cleanup" }
-      );
-    }
     fields.push({
       label: "Host cleanup",
-      value: input.skip_cleanup
-        ? "SKIP; the node is authoritatively unreachable/off-grid"
-        : "not dispatched by termination; complete any required host wipe separately before reuse",
+      value:
+        "not dispatched by termination; complete any required host wipe separately before reuse",
     });
-    fields.push({ label: "Node record", value: "PERMANENTLY DELETE" });
+    fields.push({ label: "Node record", value: "MARK TERMINATED" });
     fields.push({
       label: "Reservation/capacity consequence",
       value: reservationId(node)
@@ -538,7 +448,7 @@ async function prepareLifecycle({ command, fetch, input, machine }) {
         title: "Review node termination",
         fields,
         consequence:
-          "The node record is permanently deleted; this does not cancel its capacity reservation.",
+          "The node record is marked terminated; this does not cancel its capacity reservation.",
       },
       value,
     };
@@ -582,11 +492,11 @@ async function reconcileLifecycle({ fetch, input, value }) {
         data: { node_id: id, status: "already_absent", deleted: false },
       };
     }
-    if (input.skip_cleanup && !isUnreachable(current)) {
+    // Terminate keeps the record, so a re-run finds it terminated, not gone.
+    if (isTerminated(current)) {
       return {
-        status: "conflict",
-        message:
-          "The node is no longer authoritatively unreachable/off-grid; renew review without --skip-cleanup.",
+        status: "satisfied",
+        data: { node_id: id, status: "terminated", deleted: true },
       };
     }
     if (!sameSnapshot(reviewedNode, current)) {
@@ -599,29 +509,6 @@ async function reconcileLifecycle({ fetch, input, value }) {
   }
   if (!current) return { status: "conflict", message: "The exact node no longer exists." };
 
-  if (command === "suspend-management") {
-    if (isOffGrid(current)) {
-      return { status: "satisfied", data: { node_id: id, status: "off-grid", off_grid: true } };
-    }
-    if (!sameSnapshot(reviewedNode, current)) {
-      return { status: "conflict", message: "The node's management goal changed after review." };
-    }
-    return { status: "apply" };
-  }
-
-  if (command === "resume-management") {
-    if (!isOffGrid(current)) {
-      return {
-        status: "satisfied",
-        data: { node_id: id, status: nodeSnapshot(current).status, off_grid: false },
-      };
-    }
-    if (!sameSnapshot(reviewedNode, current)) {
-      return { status: "conflict", message: "The node's management goal changed after review." };
-    }
-    return { status: "apply" };
-  }
-
   if (command === "assign") {
     const currentReservation = reservationId(current);
     if (currentReservation === input.reservation_id) {
@@ -669,15 +556,17 @@ async function reconcileLifecycle({ fetch, input, value }) {
 }
 
 function goalSatisfied(command, node, input) {
-  if (command === "terminate") return node === null;
+  if (command === "terminate") return node === null || isTerminated(node);
   if (!node) return false;
-  if (command === "suspend-management") return isOffGrid(node);
-  if (command === "resume-management") return !isOffGrid(node);
   if (command === "assign") return reservationId(node) === input.reservation_id;
   if (cleanupState(node) === "failed") return false;
   return !restartInProgress(node);
 }
 
+function isTerminated(node) {
+  return text(node?.status).toLowerCase() === "terminated";
+}
+
 function cleanupState(node) {
   return text(node?.cleanup_state).toLowerCase();
 }
@@ -900,15 +789,6 @@ export async function runAdminNodeLifecycle({
     },
   });
 
-  if (result.status === "declined") {
-    return {
-      ...result,
-      action: null,
-      resume: null,
-      errors: [],
-    };
-  }
-
   const accepted = {
     operation: command,
     reconciled: result.reconciled === true || lateReconciled,
@@ -939,7 +819,7 @@ export const adminNodeLifecycleHandlers = Object.keys(COMMAND_BY_CAPABILITY).map
     safety:
       COMMAND_BY_CAPABILITY[capabilityId] === "reboot" ||
       COMMAND_BY_CAPABILITY[capabilityId] === "hard-reset"
-        ? ADMIN_MUTATION_SAFETY.eligibleHumanOnly
+        ? ADMIN_MUTATION_SAFETY.direct
         : ADMIN_MUTATION_SAFETY.reconcile,
     run: runAdminNodeLifecycle,
   })