@ornncompute/cli 0.2.23 → 1.0.25

package/src/slurm-commands.mjs

@@ -0,0 +1,263 @@
+import { spawn as spawnProcessDefault } from "node:child_process";
+import { homedir } from "node:os";
+
+import {
+  clusterModeConnectCandidates,
+  launchClusterMode,
+  readClusterModeConnectContext,
+  resolveClusterModeConnectTarget,
+} from "./kubernetes-commands.mjs";
+
+const SAFE_HOST = /^[A-Za-z0-9][A-Za-z0-9.:-]*$/;
+const SAFE_USER = /^[A-Za-z_][A-Za-z0-9_.-]*[$]?$/;
+const connectCache = new WeakMap();
+
+function text(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+
+function expandHome(path) {
+  if (path === "~") return homedir();
+  return path.startsWith("~/") ? `${homedir()}${path.slice(1)}` : path;
+}
+
+function shellQuote(value) {
+  const rendered = String(value);
+  return /^[A-Za-z0-9_./:@%+=,-]+$/.test(rendered)
+    ? rendered
+    : `'${rendered.replaceAll("'", `'\\''`)}'`;
+}
+
+function commandText(invocation) {
+  return [invocation.command, ...invocation.args].map(shellQuote).join(" ");
+}
+
+function safeLogin(runtime, credentials, input) {
+  const credentialType = text(credentials.credential_type);
+  if (credentialType && credentialType !== "login-ssh") {
+    runtime.error("The gateway returned a non-Slurm native-access credential.", {
+      code: "invalid_slurm_access",
+    });
+  }
+  const host = text(credentials.login_host);
+  if (!host) return null;
+  if (!SAFE_HOST.test(host)) {
+    runtime.error("The gateway returned an unsafe Slurm SSH host.", {
+      code: "invalid_slurm_access",
+    });
+  }
+  const user = text(input.user) ?? text(credentials.login_user);
+  if (user && !SAFE_USER.test(user)) {
+    runtime.usage("--user must be a valid SSH login name.", {
+      code: "invalid_ssh_user",
+      field: "user",
+    });
+  }
+  const rawPort = credentials.login_port ?? 22;
+  const port = Number(rawPort);
+  if (!Number.isInteger(port) || port < 1 || port > 65_535) {
+    runtime.error("The gateway returned an invalid Slurm SSH port.", {
+      code: "invalid_slurm_access",
+    });
+  }
+  const identityFile = text(input.identityFile);
+  if (identityFile && /[\u0000-\u001f\u007f]/.test(identityFile)) {
+    runtime.usage("--identity-file contains an invalid path.", {
+      code: "invalid_identity_file",
+      field: "identityFile",
+    });
+  }
+  const args = [];
+  if (identityFile) args.push("-i", expandHome(identityFile));
+  if (port !== 22) args.push("-p", String(port));
+  args.push("--", user ? `${user}@${host}` : host);
+  return {
+    args,
+    command: "ssh",
+    host,
+    port,
+    user,
+  };
+}
+
+function privateTransport(state) {
+  if (!state.privateNetwork) return null;
+  return {
+    private_network: {
+      id: text(state.privateNetwork.id),
+      name: text(state.privateNetwork.name) ?? text(state.privateNetwork.label),
+    },
+    vpn_connection: state.vpnConnection
+      ? {
+          id: text(state.vpnConnection.id),
+          name: text(state.vpnConnection.name) ?? text(state.vpnConnection.label),
+          status: text(state.vpnConnection.lifecycle?.class) ?? text(state.vpnConnection.status),
+        }
+      : null,
+  };
+}
+
+function retryConnectAction(cluster) {
+  return {
+    command: `ornn connect ${cluster.id}`,
+    description: "Retry this exact Slurm cluster after its SSH login becomes ready.",
+    type: "command",
+  };
+}
+
+async function spawnSsh(invocation, spawnProcess) {
+  return new Promise((resolve, reject) => {
+    const child = spawnProcess(invocation.command, invocation.args, { stdio: "inherit" });
+    child.on("error", reject);
+    child.on("exit", (code, signal) => {
+      resolve({ code: signal ? 130 : (code ?? 0), signal: signal ?? null });
+    });
+  });
+}
+
+export function createSlurmConnectModeHandler({ spawnProcess = spawnProcessDefault } = {}) {
+  return {
+    mode: "slurm",
+    candidates(state) {
+      return clusterModeConnectCandidates(state, "slurm");
+    },
+    resolve(state) {
+      return resolveClusterModeConnectTarget(state, "slurm");
+    },
+    async matches(state) {
+      if (state.mode && state.mode !== "slurm" && state.cluster?.access_mode !== "slurm") {
+        return false;
+      }
+      const prepared = await readClusterModeConnectContext(state, "slurm");
+      if (!prepared) return false;
+      connectCache.set(state, prepared);
+      return true;
+    },
+    async connect(state) {
+      const runtime = state.interaction;
+      const prepared =
+        connectCache.get(state) ?? (await readClusterModeConnectContext(state, "slurm"));
+      if (!prepared) {
+        runtime.error("The selected Slurm cluster could not be rediscovered.", {
+          code: "cluster_not_found",
+        });
+      }
+      if (state.input.output || state.input.overwrite) {
+        runtime.usage(
+          "Slurm connect uses native SSH and does not write a kubeconfig or other output file.",
+          {
+            code: "slurm_output_unsupported",
+            field: "output",
+          }
+        );
+      }
+      const login = safeLogin(runtime, prepared.credentials, state.input);
+      const transport = privateTransport(state);
+      if (!login || ["partial", "failed", "ended"].includes(prepared.cluster.lifecycle.class)) {
+        const unavailable = prepared.credentialError === "unavailable";
+        return {
+          action: retryConnectAction(prepared.cluster),
+          data: {
+            capacity_reservation: prepared.capacityReservation,
+            cluster: prepared.cluster,
+            private_transport: transport,
+            ssh: null,
+          },
+          errors: [
+            {
+              code: unavailable ? "slurm_access_unavailable" : "slurm_access_not_ready",
+              message: unavailable
+                ? "Slurm SSH access could not be loaded; the cluster remains unchanged."
+                : "The Slurm cluster exists, but its SSH login is not usable yet.",
+              retryable: true,
+              resource_ref: prepared.cluster.id,
+            },
+          ],
+          exitCode: 4,
+          outcome: {
+            class: unavailable ? "partial" : "working",
+            phase: unavailable ? "access_unavailable" : "ssh_pending",
+          },
+          presentation: {
+            lines: [
+              unavailable
+                ? "Slurm SSH access is temporarily unavailable for the selected cluster."
+                : "The selected Slurm cluster is not SSH-ready yet.",
+            ],
+            next: "ornn connect",
+          },
+          resume: prepared.resume,
+        };
+      }
+      const ssh = {
+        command: commandText(login),
+        host: login.host,
+        port: login.port,
+        transport: "ssh",
+        user: login.user,
+      };
+      const data = {
+        capacity_reservation: prepared.capacityReservation,
+        cluster: prepared.cluster,
+        private_transport: transport,
+        ssh,
+      };
+      if (runtime.eligibleHuman && !runtime.machine && state.input.print !== true) {
+        const launched = await spawnSsh(login, spawnProcess);
+        if (launched.code === 130) {
+          return {
+            data,
+            errors: [
+              {
+                code: "interrupted",
+                message:
+                  "The local SSH process was interrupted; the Slurm cluster was not changed.",
+                retryable: true,
+                resource_ref: prepared.cluster.id,
+              },
+            ],
+            exitCode: 130,
+            outcome: { class: "ended", phase: "interrupted" },
+            resume: prepared.resume,
+          };
+        }
+        if (launched.code !== 0) {
+          return {
+            data,
+            errors: [
+              {
+                code: "ssh_failed",
+                message: `SSH exited with status ${launched.code}.`,
+                retryable: false,
+                resource_ref: prepared.cluster.id,
+              },
+            ],
+            exitCode: 1,
+            outcome: { class: "failed", phase: "ssh_failed" },
+            resume: prepared.resume,
+          };
+        }
+      }
+      return {
+        data,
+        outcome: { class: "ready", phase: "ssh_ready" },
+        presentation: {
+          lines: [
+            runtime.eligibleHuman && state.input.print !== true
+              ? `Connected to Slurm cluster ${prepared.cluster.id}.`
+              : ssh.command,
+            "Use standard Slurm tools such as sinfo, srun, sbatch, and sacct after login.",
+          ],
+        },
+        resume: prepared.resume,
+      };
+    },
+  };
+}
+
+export const slurmConnectModeHandler = createSlurmConnectModeHandler();
+
+export const slurmLaunchModeHandler = {
+  mode: "slurm",
+  launch: (state) => launchClusterMode(state, "slurm"),
+};

package/src/startup.mjs

@@ -6,6 +6,7 @@ import { pathToFileURL } from "node:url";
 import { forwardSignals } from "./signals.mjs";
 import {
   acquireUpdateLock,
+  CLI_MIGRATION_GUIDE_URL,
   compareVersions,
   detectInstallContext,
   installVersion,
@@ -31,6 +32,8 @@ process.exitCode = await entry.execute(process.argv.slice(3), {
 function hasHumanOnlyArgument(argv) {
   return argv.some(
     (arg) =>
+      arg === "--format" ||
+      arg.startsWith("--format=") ||
       arg === "--json" ||
       arg.startsWith("--json=") ||
       arg === "--raw" ||
@@ -39,7 +42,7 @@ function hasHumanOnlyArgument(argv) {
       arg === "help" ||
       arg === "--version" ||
       arg === "-v" ||
-      arg === "version",
+      arg === "version"
   );
 }
 
@@ -73,7 +76,7 @@ function failedProbe(stderr) {
 function unavailableLock(stderr) {
   warning(
     stderr,
-    "Automatic update unavailable; retry after any other ornn update finishes. If no updater or package installer is running, remove the stale update-install lock from your Ornn config directory or check that directory's permissions.",
+    "Automatic update unavailable; retry after any other ornn update finishes. If no updater or package installer is running, remove the stale update-install lock from your Ornn config directory or check that directory's permissions."
   );
   return { kind: "exit", code: 1 };
 }
@@ -88,7 +91,12 @@ function entryUrl(binPath) {
 
 export async function probeInstalledCli(
   binPath,
-  { spawnProcess = spawn, env = process.env, signalSource = process, timeoutMs = PROBE_TIMEOUT_MS } = {},
+  {
+    spawnProcess = spawn,
+    env = process.env,
+    signalSource = process,
+    timeoutMs = PROBE_TIMEOUT_MS,
+  } = {}
 ) {
   return await new Promise((resolve) => {
     let output = "";
@@ -96,11 +104,15 @@ export async function probeInstalledCli(
     let timedOut = false;
     let forceKillTimer;
     let timeoutTimer;
-    const child = spawnProcess(process.execPath, ["--input-type=module", "--eval", PROBE_PROGRAM, entryUrl(binPath)], {
-      env,
-      shell: false,
-      stdio: ["ignore", "pipe", "ignore"],
-    });
+    const child = spawnProcess(
+      process.execPath,
+      ["--input-type=module", "--eval", PROBE_PROGRAM, entryUrl(binPath)],
+      {
+        env,
+        shell: false,
+        stdio: ["ignore", "pipe", "ignore"],
+      }
+    );
     const scheduleForceKill = () => {
       forceKillTimer ??= setTimeout(() => child.kill?.("SIGKILL"), PROBE_KILL_GRACE_MS);
     };
@@ -136,14 +148,14 @@ export async function probeInstalledCli(
 export async function restartCli(
   binPath,
   argv,
-  { spawnProcess = spawn, env = process.env, signalSource = process } = {},
+  { spawnProcess = spawn, env = process.env, signalSource = process } = {}
 ) {
   return await new Promise((resolve, reject) => {
     let parentSignal = null;
     const child = spawnProcess(
       process.execPath,
       ["--input-type=module", "--eval", RESTART_PROGRAM, entryUrl(binPath), binPath, ...argv],
-      { env, shell: false, stdio: "inherit" },
+      { env, shell: false, stdio: "inherit" }
     );
     const removeSignals = forwardSignals(signalSource, child, (signal) => {
       parentSignal ??= signal;
@@ -165,7 +177,10 @@ function unexpectedVersion(stderr, version, currentVersion, target) {
     ? `The installer left ornn CLI at ${version}, expected ${target}.`
     : "The installer left an invalid ornn CLI version.";
   const downgrade = isValidReleaseVersion(version) && compareVersions(version, currentVersion) < 0;
-  warning(stderr, `${detail}${downgrade ? ` It is older than ${currentVersion}.` : ""} ${REINSTALL_GUIDANCE}`);
+  warning(
+    stderr,
+    `${detail}${downgrade ? ` It is older than ${currentVersion}.` : ""} ${REINSTALL_GUIDANCE}`
+  );
   return { kind: "exit", code: 1 };
 }
 
@@ -220,6 +235,14 @@ export async function prepareStartup(argv, options = {}) {
       return { kind: "continue" };
     }
 
+    if (Number(target.split(".")[0]) > Number(options.currentVersion.split(".")[0])) {
+      warning(
+        stderr,
+        `Major update available: ${target}. Review ${CLI_MIGRATION_GUIDE_URL}, then run ornn update --major.`
+      );
+      return { kind: "continue" };
+    }
+
     warning(stderr, `Updating ornn CLI ${options.currentVersion} -> ${target}...`);
     let stableBin;
     try {