nebula-notebook 0.2.15 → 0.2.16

package/node-server/dist/scheduler/arch.js

@@ -0,0 +1,113 @@
+"use strict";
+/**
+ * Multi-arch launch support for compute allocations.
+ *
+ * An allocation re-launches THIS Nebula install on the compute node, so the
+ * node binary and node_modules must match the compute node's CPU arch. On
+ * heterogeneous clusters (CRI: x86_64 login nodes, aarch64 ghq/pearsonq) a
+ * per-arch runtime is configured via env:
+ *
+ *   NEBULA_ARM64_NODE_BIN=/shared/node22-arm64/bin/node
+ *   NEBULA_ARM64_DIR=/shared/nebula-notebook-arm64   # checkout with arm64 node_modules
+ *
+ * Both must live on storage the compute nodes share with the login node.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeArch = normalizeArch;
+exports.archOverridesFromEnv = archOverridesFromEnv;
+exports.pickLaunchContext = pickLaunchContext;
+const path = __importStar(require("path"));
+/** SLURM spellings (uname -m) → node's process.arch identifiers. */
+function normalizeArch(raw) {
+    const a = (raw || '').trim().toLowerCase();
+    if (a === 'x86_64' || a === 'amd64' || a === 'x64')
+        return 'x64';
+    if (a === 'aarch64' || a === 'arm64')
+        return 'arm64';
+    return a;
+}
+const CONFIGURABLE_ARCHES = ['arm64', 'x64'];
+/**
+ * Read per-arch runtime overrides from the environment. An arch is configured
+ * only when BOTH its vars are present — a node binary without its matching
+ * node_modules tree (or vice versa) would just fail later and worse.
+ */
+function archOverridesFromEnv(env = process.env) {
+    const overrides = {};
+    for (const arch of CONFIGURABLE_ARCHES) {
+        const prefix = `NEBULA_${arch.toUpperCase()}_`;
+        const nodeBin = env[`${prefix}NODE_BIN`]?.trim();
+        const dir = env[`${prefix}DIR`]?.trim();
+        if (!nodeBin || !dir)
+            continue;
+        overrides[arch] = {
+            nodeBin,
+            cwd: path.join(dir, 'node-server'),
+            scriptPath: path.join(dir, 'node-server', 'src', 'index.ts'),
+        };
+    }
+    return overrides;
+}
+/**
+ * Pick the launch context for a partition's arch: the server's own install
+ * when arches match (or the arch is unknown — the status quo), the configured
+ * override when they differ, and a loud, actionable refusal otherwise. The
+ * refusal is the point: without it the job dies on the compute node with
+ * "Exec format error" in a log nobody reads.
+ */
+function pickLaunchContext(ctx, targetArchRaw, serverArch = process.arch // undefined → the running process's arch
+) {
+    if (!targetArchRaw)
+        return ctx;
+    const target = normalizeArch(targetArchRaw);
+    if (target === normalizeArch(serverArch))
+        return ctx;
+    const override = ctx.archOverrides?.[target];
+    if (!override) {
+        const prefix = `NEBULA_${target.toUpperCase()}_`;
+        throw new Error(`this partition runs ${targetArchRaw} nodes but this Nebula server is ${serverArch} — ` +
+            `its runtime cannot execute there. Install a ${targetArchRaw} Node.js and Nebula checkout ` +
+            `on shared storage and set ${prefix}NODE_BIN and ${prefix}DIR on the server.`);
+    }
+    return {
+        ...ctx,
+        nodeBin: override.nodeBin,
+        cwd: override.cwd,
+        scriptPath: override.scriptPath,
+        // Never let a client restart itself mid-job on a source change.
+        execArgv: ctx.execArgv.filter((a) => a !== '--watch'),
+    };
+}

package/node-server/dist/scheduler/job-template.d.ts

@@ -26,5 +26,16 @@ export interface LaunchContext {
     cwd: string;
     /** Directory (on shared storage) for job scripts + logs */
     stateDir: string;
+    /**
+     * Per-arch runtime substitutions (node's process.arch keys, e.g. 'arm64')
+     * for partitions whose CPU arch differs from this server's — see arch.ts.
+     */
+    archOverrides?: Record<string, {
+        nodeBin: string;
+        cwd: string;
+        scriptPath: string;
+    }>;
+    /** Arch of nodeBin itself. Defaults to process.arch; overridable for tests. */
+    serverArch?: string;
 }
 export declare function renderJobScript(spec: JobSpec, ctx: LaunchContext, allocId: string, token: string): string;

package/node-server/dist/scheduler/mock-scheduler.d.ts

@@ -21,6 +21,7 @@ export declare class MockScheduler implements Scheduler {
     associations(_user: string): Promise<Associations>;
     load(): Promise<QueueLoad>;
     allowedQos(partition: string): Promise<string[] | null>;
+    partitionArch(_partition: string): Promise<string | null>;
     estimateStart(): Promise<StartEstimate>;
     submit(scriptPath: string): Promise<{
         jobId: string;

package/node-server/dist/scheduler/mock-scheduler.js

@@ -73,6 +73,9 @@ class MockScheduler {
             return ['priority', 'opportunistic'];
         return null;
     }
+    async partitionArch(_partition) {
+        return null; // mock cluster is arch-homogeneous
+    }
     async estimateStart() {
         // The launcher uses capacity-based availability, not this dry-run estimate.
         return {};

package/node-server/dist/scheduler/slurm-scheduler.d.ts

@@ -21,6 +21,7 @@ export declare class SlurmScheduler implements Scheduler {
     private associationsFresh;
     load(): Promise<QueueLoad>;
     private loadFresh;
+    partitionArch(partition: string): Promise<string | null>;
     allowedQos(partition: string): Promise<string[] | null>;
     estimateStart(spec: JobSpec): Promise<StartEstimate>;
     submit(scriptPath: string): Promise<{

package/node-server/dist/scheduler/slurm-scheduler.js

@@ -11,6 +11,7 @@ exports.SlurmScheduler = void 0;
 const child_process_1 = require("child_process");
 const util_1 = require("util");
 const util_2 = require("./util");
+const arch_1 = require("./arch");
 const execFileP = (0, util_1.promisify)(child_process_1.execFile);
 async function run(cmd, args, timeoutMs = 15_000) {
     const { stdout, stderr } = await execFileP(cmd, args, {
@@ -210,7 +211,26 @@ class SlurmScheduler {
         // GPU capacity per partition, from per-node TRES: configured (CfgTRES) vs
         // allocated (AllocTRES) `gres/gpu`, so we can report *idle* (available) GPUs
         // rather than a per-node count. Generic — no site-specific node/gres names.
+        // The same per-node dump also carries each node's CPU arch (`Arch=`), which
+        // multi-arch clusters (x86_64 login + aarch64 queues) need at submit time.
         if (nodeRes.status === 'fulfilled') {
+            const archAgg = new Map();
+            for (const line of nodeRes.value.stdout.split('\n')) {
+                if (!line.trim())
+                    continue;
+                const arch = scontrolField(line, 'Arch');
+                const nodeParts = scontrolField(line, 'Partitions');
+                if (arch && nodeParts) {
+                    for (const part of nodeParts.split(',')) {
+                        (archAgg.get(part) ?? archAgg.set(part, new Set()).get(part)).add(arch);
+                    }
+                }
+            }
+            for (const [part, archs] of archAgg) {
+                const p = partitions.get(part);
+                if (p)
+                    p.archs = [...archs].sort();
+            }
             // Aggregate per (partition, GPU model) — heterogeneous queues mix cards.
             const agg = new Map();
             for (const line of nodeRes.value.stdout.split('\n')) {
@@ -307,6 +327,20 @@ class SlurmScheduler {
         }
         return { partitions: [...partitions.values()], qoses, fetchedAt: Date.now() };
     }
+    async partitionArch(partition) {
+        try {
+            const load = await this.load();
+            const archs = load.partitions.find((p) => p.name === partition)?.archs;
+            // Mixed-arch partitions have no safe pick — the scheduler decides the
+            // node, so treat them as unknown rather than guessing wrong half the time.
+            if (!archs || archs.length !== 1)
+                return null;
+            return (0, arch_1.normalizeArch)(archs[0]);
+        }
+        catch {
+            return null;
+        }
+    }
     async allowedQos(partition) {
         const cached = this.qosCache.get(partition);
         if (cached && Date.now() - cached.at < 300_000)

package/node-server/dist/scheduler/types.d.ts

@@ -70,6 +70,9 @@ export interface PartitionLoad {
         pending: number;
         running: number;
     };
+    /** Distinct CPU arches of the partition's nodes, SLURM spelling (e.g.
+     *  'x86_64', 'aarch64'), sorted. Absent when no node reported one. */
+    archs?: string[];
 }
 export interface QosLoad {
     name: string;
@@ -105,6 +108,12 @@ export interface Scheduler {
      * scheduler would reject. Discovered from the scheduler, not configured.
      */
     allowedQos(partition: string): Promise<string[] | null>;
+    /**
+     * The partition's CPU arch as a node process.arch identifier ('x64',
+     * 'arm64'), or null when unknown or mixed — null means "assume the
+     * server's own arch", preserving pre-multi-arch behavior.
+     */
+    partitionArch(partition: string): Promise<string | null>;
     /** Dry-run estimated start time for a spec, without submitting. */
     estimateStart(spec: JobSpec): Promise<StartEstimate>;
     /** Submit a rendered job script; returns the scheduler job id. */

package/node-server/dist/scheduler/util.d.ts

@@ -5,3 +5,9 @@
 export declare function formatWalltime(minutes: number): string;
 /** POSIX single-quote a string so it is safe to embed in a shell script. */
 export declare function shellQuote(s: string): string;
+/**
+ * Compress a job log's tail into a one-line failure reason: the last few
+ * non-empty lines (the error is at the end), capped so a pathological log
+ * can't flood the UI. Null when there is nothing to say.
+ */
+export declare function summarizeLogTail(content: string): string | null;

package/node-server/dist/scheduler/util.js

@@ -5,6 +5,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatWalltime = formatWalltime;
 exports.shellQuote = shellQuote;
+exports.summarizeLogTail = summarizeLogTail;
 /** Format minutes as a SLURM walltime string (`D-HH:MM:SS` or `HH:MM:SS`). */
 function formatWalltime(minutes) {
     const total = Math.max(1, Math.floor(minutes));
@@ -18,3 +19,18 @@ function formatWalltime(minutes) {
 function shellQuote(s) {
     return `'${String(s).replace(/'/g, `'\\''`)}'`;
 }
+/**
+ * Compress a job log's tail into a one-line failure reason: the last few
+ * non-empty lines (the error is at the end), capped so a pathological log
+ * can't flood the UI. Null when there is nothing to say.
+ */
+function summarizeLogTail(content) {
+    const lines = content
+        .split('\n')
+        .map((l) => l.trimEnd())
+        .filter((l) => l.trim().length > 0);
+    if (lines.length === 0)
+        return null;
+    const joined = lines.slice(-3).join(' | ');
+    return joined.length > 300 ? `…${joined.slice(-300)}` : joined;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nebula-notebook",
-  "version": "0.2.15",
+  "version": "0.2.16",
   "description": "AI-native notebook computing environment — real Jupyter kernels, real filesystem, built to be driven by agents (Claude Code / Codex) via MCP",
   "type": "module",
   "license": "MIT",