jungle-grid 0.1.0

package/dist/index.js

@@ -0,0 +1,1769 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * index.ts — Entry point for the Jungle Grid CLI (`jungle` command).
+ *
+ * Architecture role: Pillar 1 (Abstract GPU Selection) — primary user interface.
+ * This is the main user-facing surface of Jungle Grid. Every command must
+ * uphold the abstraction boundary: users declare WHAT they want to run
+ * (workload type, model size, optimization preference), never WHERE or HOW.
+ *
+ * PILLAR 1 INVARIANTS enforced here:
+ *   - `jungle submit` accepts --workload and --model-size, NOT --gpu-type.
+ *   - Job-oriented commands stay workload-first and scheduling-focused.
+ *   - `jungle nodes` is a marketplace overview, while `jungle nodes show`
+ *     intentionally exposes full node capability and pricing metadata.
+ *   - The CLI never prints node API keys, shared secrets, or auth material.
+ *
+ * Pillar 2 (Intelligent Routing): The CLI does not route — it delegates to
+ * the orchestrator API, which runs the classifier and matcher server-side.
+ *
+ * Upstream: User's terminal.
+ * Downstream: Orchestrator REST API via api.ts; local credentials via auth.ts.
+ */
+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 });
+const commander_1 = require("commander");
+const banner_1 = require("./banner");
+const repl_1 = require("./repl");
+const api_1 = require("./api");
+const auth_1 = require("./auth");
+const config_1 = require("./config");
+const node_config_1 = require("./node-config");
+const node_agent_installer_1 = require("./node-agent-installer");
+const prompt_1 = require("./prompt");
+const version_1 = require("./version");
+const ui_1 = require("./ui");
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const CLI_VERSION = (0, version_1.getCliVersion)();
+/**
+ * Interval in milliseconds between token polling attempts during device login.
+ * 2 seconds is the standard device-flow cadence — fast enough to feel
+ * responsive, slow enough to not hammer the API.
+ */
+const LOGIN_POLL_INTERVAL_MS = 2000;
+/**
+ * Maximum time in milliseconds to wait for the user to complete browser login.
+ * 5 minutes is generous — if the user walks away, the CLI stops polling
+ * and the server-side device_code expires independently.
+ */
+const LOGIN_TIMEOUT_MS = 5 * 60 * 1000;
+/**
+ * Generates a random 16-character hex string for the device auth flow.
+ * Used as the device_code that links the CLI session to the browser login.
+ *
+ * @returns A 16-char hex string (8 random bytes).
+ */
+function generateDeviceCode() {
+    // crypto.randomBytes is available in Node 18+ without importing crypto
+    // because it's on the global. We use the array approach for simplicity.
+    const bytes = new Uint8Array(8);
+    // Node 18+ has crypto.getRandomValues on globalThis
+    require("crypto").randomFillSync(bytes);
+    return Array.from(bytes)
+        .map((b) => b.toString(16).padStart(2, "0"))
+        .join("");
+}
+/**
+ * Pauses execution for the specified duration.
+ * Used only in the device-flow polling loop.
+ *
+ * @param ms - Duration in milliseconds.
+ */
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Detects whether a Linux session has a GUI display available.
+ * Device login stays browser-based even on VPS hosts, but we should not try to
+ * launch a local browser when there is clearly no display server attached.
+ */
+function hasLinuxDisplaySession() {
+    return Boolean(process.env.DISPLAY || process.env.WAYLAND_DISPLAY);
+}
+/**
+ * Chooses the native browser-launch command for the current platform.
+ * This avoids the ESM/CJS interop problem from the `open` package while
+ * keeping local browser launch as a convenience rather than a hard dependency.
+ */
+function resolveBrowserLaunchCommand(url) {
+    switch (process.platform) {
+        case "win32":
+            return { command: "cmd", args: ["/c", "start", "", url] };
+        case "darwin":
+            return { command: "open", args: [url] };
+        case "linux":
+            return { command: "xdg-open", args: [url] };
+        default:
+            return null;
+    }
+}
+/**
+ * Attempts to open the device-login URL locally without making login depend on
+ * the existence of a GUI environment. A failure here is informational only.
+ */
+async function launchBrowserBestEffort(url) {
+    if (process.platform === "linux" && !hasLinuxDisplaySession()) {
+        return {
+            attempted: false,
+            launched: false,
+            reason: "This host appears headless; open the login URL on any machine to continue.",
+        };
+    }
+    const launchCommand = resolveBrowserLaunchCommand(url);
+    if (!launchCommand) {
+        return {
+            attempted: false,
+            launched: false,
+            reason: `Automatic browser launch is not supported on platform ${process.platform}.`,
+        };
+    }
+    return new Promise((resolve) => {
+        let settled = false;
+        const finish = (result) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            resolve(result);
+        };
+        const child = (0, child_process_1.spawn)(launchCommand.command, launchCommand.args, {
+            detached: true,
+            stdio: "ignore",
+        });
+        child.once("error", (err) => {
+            finish({
+                attempted: true,
+                launched: false,
+                reason: err.message,
+            });
+        });
+        child.once("exit", (code) => {
+            if (typeof code === "number" && code !== 0) {
+                finish({
+                    attempted: true,
+                    launched: false,
+                    reason: `launcher exited with code ${code}`,
+                });
+            }
+        });
+        child.once("spawn", () => {
+            child.unref();
+            // If the platform launcher survived long enough to spawn cleanly, treat
+            // it as a successful handoff and let login continue in parallel.
+            setTimeout(() => {
+                finish({
+                    attempted: true,
+                    launched: true,
+                });
+            }, 150);
+        });
+    });
+}
+/**
+ * Prints the device-login instructions in a form that works for both local
+ * desktop sessions and remote VPS sessions. The browser can complete login on
+ * any machine; the CLI simply keeps polling with the device code.
+ */
+function printDeviceLoginInstructions(loginURL, deviceCode) {
+    console.log((0, ui_1.joinBlocks)([
+        (0, ui_1.section)("Browser handoff", (0, ui_1.kvLines)([
+            ["Login URL", (0, ui_1.info)(loginURL)],
+            ["Device code", (0, ui_1.accent)(deviceCode)],
+        ]), "primary"),
+        (0, ui_1.section)("What to do next", (0, ui_1.stepLines)([
+            `Open the login URL in any browser, including one on another machine.`,
+            `Enter the device code ${(0, ui_1.code)(deviceCode)} when the sign-in flow asks for it.`,
+            "Leave this terminal open while Jungle Grid waits for browser confirmation.",
+        ]), "success"),
+    ]));
+}
+/**
+ * Column widths for `jungle jobs` tabular output.
+ * Increasing these widths improves readability for long values but widens
+ * terminal output and may wrap on narrow screens.
+ */
+const JOB_TABLE_COLUMNS = {
+    id: 18,
+    name: 24,
+    status: 12,
+    workload: 14,
+    optimize: 10,
+    created: 20,
+    updated: 20,
+};
+/**
+ * Truncates a value to fit a fixed-width table column.
+ *
+ * @param value - Source value to render in the column.
+ * @param width - Maximum column width in characters.
+ * @returns A padded or truncated string that fits exactly in width.
+ */
+function fitColumn(value, width) {
+    if (value.length <= width) {
+        return value.padEnd(width);
+    }
+    if (width <= 3) {
+        return value.slice(0, width);
+    }
+    return `${value.slice(0, width - 3)}...`;
+}
+/**
+ * Converts unix seconds to a compact ISO UTC timestamp for table display.
+ *
+ * @param unixSeconds - Timestamp in unix seconds.
+ * @returns Compact timestamp (`YYYY-MM-DDTHH:MM:SSZ`) or "-" when absent.
+ */
+function formatUnixSeconds(unixSeconds) {
+    if (!unixSeconds || unixSeconds <= 0) {
+        return "-";
+    }
+    const iso = new Date(unixSeconds * 1000).toISOString();
+    return `${iso.slice(0, 19)}Z`;
+}
+function formatTimestamp(value) {
+    return value && value.trim().length > 0 ? value : (0, ui_1.muted)("not recorded");
+}
+function formatText(value, fallback = "not reported") {
+    return value && value.trim().length > 0 ? value : (0, ui_1.muted)(fallback);
+}
+function formatNumber(value, digits = 2, fallback = "not reported") {
+    return typeof value === "number" && Number.isFinite(value)
+        ? value.toFixed(digits)
+        : (0, ui_1.muted)(fallback);
+}
+function formatInteger(value, fallback = "not reported") {
+    return typeof value === "number" && Number.isFinite(value)
+        ? String(value)
+        : (0, ui_1.muted)(fallback);
+}
+function formatCurrency(value, fallback = "not reported") {
+    return typeof value === "number" && Number.isFinite(value)
+        ? `$${value.toFixed(2)}`
+        : (0, ui_1.muted)(fallback);
+}
+function formatGigabytes(value, fallback = "not reported") {
+    return typeof value === "number" && Number.isFinite(value)
+        ? `${value} GB`
+        : (0, ui_1.muted)(fallback);
+}
+function formatBoolean(value, trueLabel = "yes", falseLabel = "no") {
+    if (typeof value !== "boolean") {
+        return (0, ui_1.muted)("not reported");
+    }
+    return value ? (0, ui_1.success)(trueLabel) : (0, ui_1.muted)(falseLabel);
+}
+function formatHeartbeatTimestamp(unixSeconds) {
+    if (typeof unixSeconds !== "number" || !Number.isFinite(unixSeconds) || unixSeconds <= 0) {
+        return (0, ui_1.muted)("not reported");
+    }
+    return new Date(unixSeconds * 1000).toISOString();
+}
+function healthLabel(value) {
+    const normalized = value?.trim().toLowerCase();
+    if (!normalized) {
+        return (0, ui_1.muted)("not reported");
+    }
+    if (normalized === "healthy") {
+        return (0, ui_1.success)(value.trim());
+    }
+    if (normalized === "unhealthy" || normalized === "offline") {
+        return (0, ui_1.danger)(value.trim());
+    }
+    if (normalized === "degraded") {
+        return (0, ui_1.warning)(value.trim());
+    }
+    return (0, ui_1.info)(value.trim());
+}
+function formatArg(arg) {
+    return /^[A-Za-z0-9_./:@%+=,-]+$/.test(arg) ? arg : JSON.stringify(arg);
+}
+function formatCommandLine(command, args, fallback = "image default") {
+    const parts = [];
+    if (command && command.trim().length > 0) {
+        parts.push(command.trim());
+    }
+    if (Array.isArray(args)) {
+        for (const arg of args) {
+            if (arg.trim().length > 0) {
+                parts.push(arg);
+            }
+        }
+    }
+    if (parts.length === 0) {
+        return (0, ui_1.muted)(fallback);
+    }
+    return (0, ui_1.code)(parts.map(formatArg).join(" "));
+}
+function pickRecordValue(record, ...keys) {
+    for (const key of keys) {
+        const value = record[key];
+        if (value !== undefined && value !== null) {
+            return value;
+        }
+    }
+    return undefined;
+}
+function normalizeTextValue(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function normalizeNumberValue(value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value === "string" && value.trim().length > 0) {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed)) {
+            return parsed;
+        }
+    }
+    return undefined;
+}
+function normalizeBooleanValue(value) {
+    if (typeof value === "boolean") {
+        return value;
+    }
+    if (typeof value === "string") {
+        if (value.trim().toLowerCase() === "true") {
+            return true;
+        }
+        if (value.trim().toLowerCase() === "false") {
+            return false;
+        }
+    }
+    return undefined;
+}
+function normalizeNodeRecord(node) {
+    return {
+        id: normalizeTextValue(pickRecordValue(node, "id", "ID")) || "",
+        status: normalizeTextValue(pickRecordValue(node, "status", "Status")),
+        healthStatus: normalizeTextValue(pickRecordValue(node, "health_status", "healthStatus", "HealthStatus")),
+        location: normalizeTextValue(pickRecordValue(node, "location", "Location")),
+        queueDepth: normalizeNumberValue(pickRecordValue(node, "queue_depth", "queueDepth", "QueueDepth")),
+        pricePerHour: normalizeNumberValue(pickRecordValue(node, "price_per_hour", "pricePerHour", "PricePerHour")),
+        reliabilityScore: normalizeNumberValue(pickRecordValue(node, "reliability_score", "reliabilityScore", "ReliabilityScore")),
+        latencyScore: normalizeNumberValue(pickRecordValue(node, "latency_score", "latencyScore", "LatencyScore")),
+        performanceScore: normalizeNumberValue(pickRecordValue(node, "performance_score", "performanceScore", "PerformanceScore")),
+        gpuType: normalizeTextValue(pickRecordValue(node, "gpu_type", "gpuType", "GPUType")),
+        vramGB: normalizeNumberValue(pickRecordValue(node, "vram_gb", "vramGb", "VRAMGB")),
+        gpuCount: normalizeNumberValue(pickRecordValue(node, "gpu_count", "gpuCount", "GPUCount")),
+        cudaVersion: normalizeTextValue(pickRecordValue(node, "cuda_version", "cudaVersion", "CUDAVersion")),
+        cudaSupport: normalizeBooleanValue(pickRecordValue(node, "cuda_support", "cudaSupport", "CUDASupport")),
+        computeCapability: normalizeTextValue(pickRecordValue(node, "compute_capability", "computeCapability", "ComputeCapability")),
+        dispatchURL: normalizeTextValue(pickRecordValue(node, "dispatch_url", "dispatchUrl", "DispatchURL")),
+        thermalThrottled: normalizeBooleanValue(pickRecordValue(node, "thermal_throttled", "thermalThrottled", "ThermalThrottled")),
+        lastHeartbeatUnix: normalizeNumberValue(pickRecordValue(node, "last_heartbeat_unix", "lastHeartbeatUnix", "LastHeartbeatUnix")),
+    };
+}
+async function collectNodeRegistrationPrompts(defaultEmail) {
+    const emailInput = await (0, prompt_1.askPrompt)(`Enter email [${defaultEmail}]: `);
+    const email = emailInput || defaultEmail;
+    const bankName = await (0, prompt_1.askPrompt)("Enter payout bank name: ");
+    const accountNumber = await (0, prompt_1.askPrompt)("Enter payout account number: ");
+    const accountName = await (0, prompt_1.askPrompt)("Enter payout account name: ");
+    if (!email || !bankName || !accountNumber || !accountName) {
+        throw new Error("email, bank name, account number, and account name are required");
+    }
+    return { email, bankName, accountNumber, accountName };
+}
+async function resolveDispatchURL(providedDispatchURL) {
+    const fromFlag = (providedDispatchURL || "").trim();
+    if (fromFlag) {
+        return fromFlag;
+    }
+    const promptedDispatchURL = (await (0, prompt_1.askPrompt)("Enter public dispatch URL for this node (e.g. http://127.0.0.1:8090): ")).trim();
+    if (!promptedDispatchURL) {
+        throw new Error("dispatch URL is required");
+    }
+    return promptedDispatchURL;
+}
+function runCommandOrFail(command, args, errorMessage) {
+    const result = spawnSyncCompat(command, args);
+    if (result.exitCode !== 0 || !result.stdout.trim()) {
+        throw new Error(errorMessage);
+    }
+    return result.stdout;
+}
+function spawnSyncCompat(command, args) {
+    const { spawnSync } = require("child_process");
+    const result = spawnSync(command, args, { encoding: "utf-8" });
+    return {
+        stdout: result.stdout || "",
+        stderr: result.stderr || "",
+        exitCode: typeof result.status === "number" ? result.status : 1,
+    };
+}
+function parseBooleanEnv(raw, fallback) {
+    if (!raw) {
+        return fallback;
+    }
+    const normalized = raw.trim().toLowerCase();
+    if (["1", "true", "yes", "on"].includes(normalized)) {
+        return true;
+    }
+    if (["0", "false", "no", "off"].includes(normalized)) {
+        return false;
+    }
+    return fallback;
+}
+function parsePositiveIntegerEnv(raw, fallback) {
+    if (!raw) {
+        return fallback;
+    }
+    const parsed = parseInt(raw, 10);
+    if (!Number.isFinite(parsed) || parsed < 1) {
+        return fallback;
+    }
+    return parsed;
+}
+function parseNonEmptyEnv(raw, fallback) {
+    const value = (raw || "").trim();
+    return value.length > 0 ? value : fallback;
+}
+function isSimulationModeEnabled() {
+    return parseBooleanEnv(process.env.JUNGLE_SIMULATION_MODE, false);
+}
+function detectHostSystemInfo() {
+    const cpus = os.cpus();
+    return {
+        cpuCores: cpus.length,
+        cpuMHz: cpus.length > 0 ? cpus[0].speed : 0,
+        ramGB: Math.round((os.totalmem() / (1024 ** 3)) * 10) / 10,
+        osLabel: `${os.platform()}-${os.release()}`,
+    };
+}
+function detectComputeCapabilityOrUnknown() {
+    const result = spawnSyncCompat("nvidia-smi", ["--query-gpu=compute_cap", "--format=csv,noheader,nounits"]);
+    if (result.exitCode !== 0 || !result.stdout.trim()) {
+        return "unknown";
+    }
+    const firstLine = result.stdout
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .find((line) => line.length > 0);
+    return firstLine || "unknown";
+}
+function detectSimulatedNodeHardware() {
+    const host = detectHostSystemInfo();
+    return {
+        gpu: parseNonEmptyEnv(process.env.JUNGLE_SIM_GPU_NAME, "RTX 3090"),
+        vramGb: parsePositiveIntegerEnv(process.env.JUNGLE_SIM_GPU_VRAM_GB, 24),
+        gpuCount: parsePositiveIntegerEnv(process.env.JUNGLE_SIM_GPU_COUNT, 1),
+        cpuCores: host.cpuCores,
+        cpuMHz: host.cpuMHz,
+        ramGB: host.ramGB,
+        cudaVersion: parseNonEmptyEnv(process.env.JUNGLE_SIM_CUDA_VERSION, "12.4"),
+        cudaSupport: parseBooleanEnv(process.env.JUNGLE_SIM_CUDA_SUPPORT, true),
+        computeCapability: parseNonEmptyEnv(process.env.JUNGLE_SIM_COMPUTE_CAPABILITY, "8.6"),
+        os: host.osLabel,
+    };
+}
+function detectNodeHardwareOrFail() {
+    if (isSimulationModeEnabled()) {
+        return detectSimulatedNodeHardware();
+    }
+    // Production requirement: registration fails if nvidia-smi is unavailable.
+    const nvidiaQuery = runCommandOrFail("nvidia-smi", [
+        "--query-gpu=name,memory.total",
+        "--format=csv,noheader,nounits",
+    ], "nvidia-smi is required for node registration but was not found or returned no GPU data");
+    const gpuLines = nvidiaQuery
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+    if (gpuLines.length === 0) {
+        throw new Error("nvidia-smi returned no GPUs; registration cannot proceed");
+    }
+    const firstGpuParts = gpuLines[0].split(",").map((x) => x.trim());
+    const gpu = firstGpuParts[0] || "unknown";
+    const vramGb = Math.max(1, Math.round((parseFloat(firstGpuParts[1] || "0") || 0) / 1024));
+    const gpuCount = gpuLines.length;
+    const cudaOut = runCommandOrFail("nvidia-smi", [], "unable to read CUDA version from nvidia-smi");
+    const cudaMatch = cudaOut.match(/CUDA Version:\s*([0-9.]+)/i);
+    const cudaVersion = cudaMatch ? cudaMatch[1] : "unknown";
+    const cudaSupport = cudaMatch !== null;
+    const computeCapability = detectComputeCapabilityOrUnknown();
+    const host = detectHostSystemInfo();
+    return {
+        gpu,
+        vramGb,
+        gpuCount,
+        cpuCores: host.cpuCores,
+        cpuMHz: host.cpuMHz,
+        ramGB: host.ramGB,
+        cudaVersion,
+        cudaSupport,
+        computeCapability,
+        os: host.osLabel,
+    };
+}
+async function measureLatencyMs(apiUrl) {
+    const started = Date.now();
+    const target = `${apiUrl.replace(/\/+$/, "")}/healthz`;
+    const timeoutMs = 5000;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        await fetch(target, {
+            method: "GET",
+            headers: { Accept: "application/json" },
+            signal: controller.signal,
+        });
+        return Math.max(1, Date.now() - started);
+    }
+    catch {
+        return 100;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+function resolveNodeAgentGoRunCwd() {
+    const candidates = [
+        process.cwd(),
+        path.resolve(__dirname, "..", "..", ".."),
+    ];
+    for (const candidate of candidates) {
+        const marker = path.join(candidate, "services", "node-agent", "cmd", "main.go");
+        if (fs.existsSync(marker)) {
+            return candidate;
+        }
+    }
+    throw new Error("Unable to locate services/node-agent/cmd/main.go. Run from the repo root or use the managed installer via jungle node start.");
+}
+/**
+ * Resolves how the provider runtime should be launched on this machine.
+ *
+ * Launch precedence:
+ * 1. Explicit --binary path supplied by the operator
+ * 2. Explicit --binary go for local repo development
+ * 3. Managed installer path under ~/.jungle-grid/bin/node-agent/<version>
+ *
+ * This keeps provider UX simple in production while preserving an intentional
+ * escape hatch for contributors who still want to run the service from source.
+ */
+async function resolveNodeAgentLaunchSpec(binaryOption) {
+    const requestedBinary = binaryOption ? String(binaryOption).trim() : "";
+    if (requestedBinary.length > 0) {
+        if (requestedBinary === "go") {
+            return {
+                binary: "go",
+                args: ["run", "./services/node-agent/cmd"],
+                cwd: resolveNodeAgentGoRunCwd(),
+            };
+        }
+        return {
+            binary: requestedBinary,
+            args: [],
+            cwd: process.cwd(),
+        };
+    }
+    const installResult = await (0, node_agent_installer_1.ensureManagedNodeAgentInstalled)(CLI_VERSION);
+    return {
+        binary: installResult.binaryPath,
+        args: [],
+        cwd: installResult.installDir,
+        installSummary: {
+            downloaded: installResult.downloaded,
+            binaryPath: installResult.binaryPath,
+            version: installResult.releaseTag,
+            platformLabel: installResult.platformLabel,
+        },
+    };
+}
+function isProcessRunning(pid) {
+    if (!Number.isInteger(pid) || pid <= 0) {
+        return false;
+    }
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        const code = err.code;
+        // EPERM means the process exists but we may not have permissions.
+        return code === "EPERM";
+    }
+}
+async function waitForProcessExit(pid, timeoutMs) {
+    const started = Date.now();
+    while (Date.now() - started < timeoutMs) {
+        if (!isProcessRunning(pid)) {
+            return true;
+        }
+        await sleep(200);
+    }
+    return !isProcessRunning(pid);
+}
+async function stopProcessByPid(pid) {
+    if (!isProcessRunning(pid)) {
+        return;
+    }
+    if (process.platform === "win32") {
+        const result = spawnSyncCompat("taskkill", ["/PID", String(pid), "/T", "/F"]);
+        if (result.exitCode !== 0 && isProcessRunning(pid)) {
+            const msg = result.stderr.trim() || result.stdout.trim() || `taskkill failed with code ${result.exitCode}`;
+            throw new Error(msg);
+        }
+        return;
+    }
+    try {
+        process.kill(pid, "SIGTERM");
+    }
+    catch (err) {
+        const code = err.code;
+        if (code !== "ESRCH") {
+            throw err;
+        }
+        return;
+    }
+    if (await waitForProcessExit(pid, 5000)) {
+        return;
+    }
+    try {
+        process.kill(pid, "SIGKILL");
+    }
+    catch (err) {
+        const code = err.code;
+        if (code !== "ESRCH") {
+            throw err;
+        }
+    }
+    if (!(await waitForProcessExit(pid, 2000))) {
+        throw new Error(`process ${pid} did not exit`);
+    }
+}
+function ensureProviderSessionOrFail(creds) {
+    if (!creds) {
+        throw new Error("Not logged in. Run `jungle login` and authenticate as provider.");
+    }
+}
+/**
+ * Normalises multiline help sections so command help stays readable.
+ *
+ * @param content - Raw multiline help content.
+ * @returns Help block padded with surrounding newlines.
+ */
+function helpBlock(content) {
+    return `\n${content.trim()}\n`;
+}
+function renderGuide(options) {
+    return helpBlock((0, ui_1.joinBlocks)([
+        (0, ui_1.section)("What this command does", [options.summary], "primary"),
+        options.examples && options.examples.length > 0
+            ? (0, ui_1.section)("Examples", options.examples.map((example) => `${(0, ui_1.muted)("$")} ${(0, ui_1.code)(example)}`), "info")
+            : null,
+        options.steps && options.steps.length > 0
+            ? (0, ui_1.section)("Suggested flow", (0, ui_1.stepLines)(options.steps), "success")
+            : null,
+        options.behavior && options.behavior.length > 0
+            ? (0, ui_1.section)("Behavior", (0, ui_1.listLines)(options.behavior), "warning")
+            : null,
+        options.notes && options.notes.length > 0
+            ? (0, ui_1.section)("Notes", (0, ui_1.listLines)(options.notes), "muted")
+            : null,
+    ]));
+}
+function renderSummary(title, entries, tone = "success", nextSteps) {
+    return (0, ui_1.joinBlocks)([
+        (0, ui_1.section)(title, (0, ui_1.kvLines)(entries), tone),
+        nextSteps && nextSteps.length > 0
+            ? (0, ui_1.section)("Next steps", (0, ui_1.listLines)(nextSteps), "info")
+            : null,
+    ]);
+}
+function renderApiError(prefix, err) {
+    if (err instanceof api_1.ApiError) {
+        return `${prefix} (${err.status}): ${err.message}`;
+    }
+    return `${prefix}: ${err.message}`;
+}
+const ROOT_HELP_DETAILS = helpBlock((0, ui_1.joinBlocks)([
+    (0, ui_1.section)("Overview", [
+        "Jungle Grid keeps the terminal workload-first: submit jobs by intent, inspect lifecycle cleanly, and run provider workflows without digging through backend internals.",
+    ], "primary"),
+    (0, ui_1.section)("Start here", (0, ui_1.stepLines)([
+        `Authenticate with ${(0, ui_1.code)("jungle login")}.`,
+        `Queue a first workload with ${(0, ui_1.code)("jungle submit --workload inference --model-size 7 --image ghcr.io/acme/infer:latest --name chat-infer")}.`,
+        `Track activity with ${(0, ui_1.code)("jungle jobs")} and inspect a single run with ${(0, ui_1.code)("jungle status <job-id>")}.`,
+    ]), "success"),
+    (0, ui_1.section)("Command lanes", (0, ui_1.kvLines)([
+        ["submit/jobs/status/logs", "User workload flow from queue to runtime inspection."],
+        ["login/logout/whoami", "Account session flow for this machine."],
+        ["nodes", "Remote marketplace and node-detail inspection."],
+        ["node", "Provider registration and local node-agent lifecycle."],
+        ["shell", "Interactive REPL when you want to stay inside the CLI."],
+    ]), "info"),
+    (0, ui_1.section)("Need more detail", (0, ui_1.listLines)([
+        `Run ${(0, ui_1.code)("jungle <command> --help")} for a command-specific guide.`,
+        `Run ${(0, ui_1.code)("jungle help <command>")} if you prefer the Commander help path.`,
+    ]), "muted"),
+]));
+// ─── Program definition ────────────────────────────────────────────────────
+const program = new commander_1.Command();
+program
+    .name("jungle")
+    .description("Jungle Grid CLI — submit GPU workloads without thinking about hardware")
+    .version(CLI_VERSION)
+    .showSuggestionAfterError()
+    .showHelpAfterError(`${(0, ui_1.muted)("Run")} ${(0, ui_1.code)("jungle --help")} ${(0, ui_1.muted)("for the full operator brief.")}`)
+    .addHelpText("after", ROOT_HELP_DETAILS);
+// ─── jungle submit ─────────────────────────────────────────────────────────
+program
+    .command("submit")
+    .description("Submit a containerized GPU workload for scheduling and dispatch")
+    .requiredOption("--workload <type>", 'Workload type: "inference", "training", "fine-tuning", or "batch"')
+    .requiredOption("--image <image>", "Public container image to run")
+    .requiredOption("--model-size <gb>", "Estimated model size in GB (drives hardware tier selection)")
+    .option("--optimize-for <mode>", 'Optimization target: "cost", "speed", or "balanced"', "balanced")
+    .option("--name <name>", "Human-readable job name")
+    .option("--command <command>", "Optional runtime command override. Omit this to use the image default entrypoint/CMD.")
+    .option("--arg <value>", "Optional runtime argument. Repeat this flag to pass multiple args.", (value, previous) => {
+    previous.push(value);
+    return previous;
+}, [])
+    .option("--batch-size <n>", "Batch size hint for throughput estimation", "1")
+    .option("--precision <p>", 'Numeric precision: "fp32", "fp16", "bf16", "int8"', "fp16")
+    .addHelpText("after", renderGuide({
+    summary: "Creates a real container job from workload intent fields. The orchestrator handles placement and the node-agent runs the image.",
+    examples: [
+        "jungle submit --workload inference --model-size 7 --image ghcr.io/acme/infer:latest --name chat-infer",
+        "jungle submit --workload batch --model-size 3 --image node:22-alpine --command node --arg app.js --optimize-for cost",
+        "jungle submit --workload training --model-size 40 --image pytorch/pytorch:2.4.0-cuda12.1-cudnn9-runtime --command python --arg train.py --optimize-for speed",
+    ],
+    notes: [
+        "--image is required and should point to a public image.",
+        "--model-size must be greater than zero.",
+        "Omit --command to use the image default entrypoint or CMD.",
+        "Repeat --arg to pass multiple runtime arguments.",
+        "Use jungle jobs after submit to find the new job ID.",
+    ],
+}))
+    .action(async (opts) => {
+    try {
+        // Validate model size is a positive number.
+        const modelSize = parseFloat(opts.modelSize);
+        if (isNaN(modelSize) || modelSize <= 0) {
+            console.error((0, ui_1.danger)("Error: --model-size must be a positive number (in GB)"));
+            process.exit(1);
+        }
+        const batchSize = parseInt(opts.batchSize, 10) || 1;
+        /**
+         * Build the job submission payload using workload intent fields.
+         * PILLAR 1: We send workload_type and model_size_gb — never gpu_type.
+         * The orchestrator's classifier will resolve the appropriate GPU tier.
+         */
+        const payload = {
+            name: opts.name || `${opts.workload}-job`,
+            image: opts.image,
+            command: opts.command || undefined,
+            args: Array.isArray(opts.arg) ? opts.arg : [],
+            workload_type: opts.workload,
+            model_size_gb: modelSize,
+            batch_size: batchSize,
+            precision: opts.precision,
+            optimize_for: opts.optimizeFor,
+        };
+        const result = await (0, api_1.apiRequest)("POST", "/v1/jobs", payload);
+        console.log(renderSummary("Job queued", [
+            ["Job ID", (0, ui_1.strong)(result.job_id)],
+            ["Status", (0, ui_1.statusLabel)(result.status)],
+            ["Queued at", result.queued_at],
+        ], "success", [
+            `List workloads with ${(0, ui_1.code)("jungle jobs")}.`,
+            `Inspect this job with ${(0, ui_1.code)(`jungle status ${result.job_id}`)}.`,
+        ]));
+    }
+    catch (err) {
+        console.error((0, ui_1.danger)(renderApiError("Failed to submit job", err)));
+        process.exit(1);
+    }
+});
+// ─── jungle status ─────────────────────────────────────────────────────────
+program
+    .command("status <job-id>")
+    .description("Check the status of a submitted job")
+    .addHelpText("after", renderGuide({
+    summary: "Shows the full job record for a single workload, including intent, execution request, scheduler signals, and runtime summary when available.",
+    examples: [
+        "jungle status job-123456",
+        "jungle status 3f4e2d10-89ab-4f9d-a122-c57a3be31c10",
+    ],
+    notes: [
+        "Use jungle jobs first if you need to look up a job ID.",
+        "Typical progression is queued -> running -> completed, with failed when execution or scheduling cannot complete.",
+        "Use jungle logs <job-id> when you need the persisted stdout and stderr tail.",
+    ],
+}))
+    .action(async (jobId) => {
+    try {
+        const result = await (0, api_1.apiRequest)("GET", `/v1/jobs/${encodeURIComponent(jobId)}`);
+        let runtimeResult = null;
+        let runtimeWarningMessage = null;
+        try {
+            runtimeResult = await (0, api_1.apiRequest)("GET", `/v1/jobs/${encodeURIComponent(jobId)}/runtime`);
+        }
+        catch (err) {
+            if (!(err instanceof api_1.ApiError && err.status === 404)) {
+                runtimeWarningMessage = renderApiError("Runtime detail unavailable", err);
+            }
+        }
+        const summaryRows = [
+            ["Job ID", (0, ui_1.strong)(result.job_id)],
+            ["Status", (0, ui_1.statusLabel)(result.status)],
+        ];
+        if (result.name) {
+            summaryRows.push(["Name", (0, ui_1.strong)(result.name)]);
+        }
+        if (result.status_reason) {
+            summaryRows.push(["Reason", result.status_reason]);
+        }
+        if (result.assigned_node_id) {
+            summaryRows.push(["Assigned node", result.assigned_node_id]);
+        }
+        const blocks = [
+            (0, ui_1.section)("Job status", (0, ui_1.kvLines)(summaryRows), "info"),
+        ];
+        const intentRows = [];
+        if (result.workload_type) {
+            intentRows.push(["Workload", result.workload_type]);
+        }
+        if (typeof result.model_size_gb === "number" && Number.isFinite(result.model_size_gb)) {
+            intentRows.push(["Model size", formatGigabytes(result.model_size_gb)]);
+        }
+        if (typeof result.batch_size === "number" && Number.isFinite(result.batch_size)) {
+            intentRows.push(["Batch size", String(result.batch_size)]);
+        }
+        if (result.precision) {
+            intentRows.push(["Precision", result.precision]);
+        }
+        intentRows.push(["Optimize for", formatText(result.optimize_for || "balanced")]);
+        if (intentRows.length > 0) {
+            blocks.push((0, ui_1.section)("Workload intent", (0, ui_1.kvLines)(intentRows), "primary"));
+        }
+        const executionRows = [];
+        if (result.image) {
+            executionRows.push(["Image", (0, ui_1.code)(result.image)]);
+        }
+        executionRows.push([
+            "Command",
+            result.command && result.command.trim().length > 0
+                ? (0, ui_1.code)(formatArg(result.command.trim()))
+                : (0, ui_1.muted)("image default"),
+        ]);
+        executionRows.push([
+            "Args",
+            result.args && result.args.length > 0
+                ? (0, ui_1.code)(result.args.map(formatArg).join(" "))
+                : (0, ui_1.muted)("none"),
+        ]);
+        executionRows.push(["Resolved", formatCommandLine(result.command, result.args)]);
+        if (executionRows.length > 0) {
+            blocks.push((0, ui_1.section)("Execution request", (0, ui_1.kvLines)(executionRows), "muted"));
+        }
+        const lifecycleRows = [
+            ["Created", formatTimestamp(result.created_at)],
+            ["Queued", formatTimestamp(result.queued_at)],
+            ["Started", formatTimestamp(result.started_at)],
+            ["Completed", formatTimestamp(result.completed_at)],
+            ["Updated", formatTimestamp(result.updated_at)],
+        ];
+        if (typeof result.dispatch_attempt === "number" && Number.isFinite(result.dispatch_attempt)) {
+            lifecycleRows.push(["Dispatch attempt", String(result.dispatch_attempt)]);
+        }
+        if (result.last_failed_node_id) {
+            lifecycleRows.push(["Last failed node", result.last_failed_node_id]);
+        }
+        blocks.push((0, ui_1.section)("Lifecycle", (0, ui_1.kvLines)(lifecycleRows), "info"));
+        if (result.score_breakdown) {
+            const s = result.score_breakdown;
+            blocks.push((0, ui_1.section)("Scheduler signals", (0, ui_1.kvLines)([
+                ["Total", s.total.toFixed(2)],
+                ["Price", s.price.toFixed(2)],
+                ["Reliability", s.reliability.toFixed(2)],
+                ["Latency", s.latency.toFixed(2)],
+                ["Performance", s.performance.toFixed(2)],
+                ["Queue depth", s.queue_depth.toFixed(2)],
+                ["Thermal", s.thermal.toFixed(2)],
+            ]), "muted"));
+        }
+        if (runtimeResult) {
+            const runtimeRows = [
+                ["Exit code", typeof runtimeResult.exit_code === "number" ? String(runtimeResult.exit_code) : (0, ui_1.muted)("not reported")],
+                ["Timed out", formatBoolean(runtimeResult.timed_out ?? false)],
+                ["Runtime started", formatTimestamp(runtimeResult.started_at)],
+                ["Runtime finished", formatTimestamp(runtimeResult.finished_at)],
+            ];
+            blocks.push((0, ui_1.section)("Runtime summary", [
+                ...(0, ui_1.kvLines)(runtimeRows),
+                "",
+                `${(0, ui_1.muted)("Logs")} ${(0, ui_1.code)(`jungle logs ${result.job_id}`)}`,
+            ], runtimeResult.status === "completed" ? "success" : "warning"));
+        }
+        else if (runtimeWarningMessage) {
+            blocks.push((0, ui_1.section)("Runtime summary", [runtimeWarningMessage], "warning"));
+        }
+        console.log((0, ui_1.joinBlocks)(blocks));
+    }
+    catch (err) {
+        console.error((0, ui_1.danger)(renderApiError("Failed to get job status", err)));
+        process.exit(1);
+    }
+});
+// ─── jungle jobs ───────────────────────────────────────────────────────────
+program
+    .command("logs <job-id>")
+    .description("Fetch the persisted runtime log tail for a completed or failed job")
+    .addHelpText("after", renderGuide({
+    summary: "Fetches the latest persisted stdout and stderr tails for a job's real runtime record.",
+    examples: ["jungle logs job-123456"],
+    notes: [
+        "Logs appear after the node-agent reports runtime state back to the orchestrator.",
+        "Use jungle status first if you want the lifecycle state before fetching logs.",
+    ],
+}))
+    .action(async (jobId) => {
+    try {
+        const result = await (0, api_1.apiRequest)("GET", `/v1/jobs/${encodeURIComponent(jobId)}/runtime`);
+        const blocks = [
+            (0, ui_1.section)("Runtime", (0, ui_1.kvLines)([
+                ["Job ID", (0, ui_1.strong)(result.job_id)],
+                ["Status", (0, ui_1.statusLabel)(result.status)],
+                ["Reason", result.status_reason || (0, ui_1.muted)("not reported")],
+                ["Image", (0, ui_1.code)(result.image)],
+                ["Command", result.command ? (0, ui_1.code)(formatArg(result.command)) : (0, ui_1.muted)("image default")],
+                [
+                    "Args",
+                    result.args && result.args.length > 0
+                        ? (0, ui_1.code)(result.args.map(formatArg).join(" "))
+                        : (0, ui_1.muted)("none"),
+                ],
+                [
+                    "Exit code",
+                    typeof result.exit_code === "number"
+                        ? String(result.exit_code)
+                        : (0, ui_1.muted)("not reported"),
+                ],
+                ["Timed out", formatBoolean(Boolean(result.timed_out))],
+                ["Started", formatTimestamp(result.started_at)],
+                ["Finished", formatTimestamp(result.finished_at)],
+            ]), result.status === "completed" ? "success" : "warning"),
+            (0, ui_1.section)("Stdout", result.stdout_tail
+                ? result.stdout_tail.replace(/\s+$/, "").split(/\r?\n/)
+                : [(0, ui_1.muted)("(no persisted stdout)")], "info"),
+            (0, ui_1.section)("Stderr", result.stderr_tail
+                ? result.stderr_tail.replace(/\s+$/, "").split(/\r?\n/)
+                : [(0, ui_1.muted)("(no persisted stderr)")], result.stderr_tail ? "danger" : "muted"),
+        ];
+        console.log((0, ui_1.joinBlocks)(blocks));
+    }
+    catch (err) {
+        console.error((0, ui_1.danger)(renderApiError("Failed to fetch job logs", err)));
+        process.exit(1);
+    }
+});
+program
+    .command("jobs")
+    .description("List all of your jobs (active and completed)")
+    .addHelpText("after", renderGuide({
+    summary: "Lists every job owned by the authenticated account in a terminal-friendly table.",
+    examples: ["jungle jobs"],
+    steps: [
+        "Submit a workload with jungle submit.",
+        "Run jungle jobs to find the most recent ID and current status.",
+        "Inspect one workload in detail with jungle status <job-id>.",
+    ],
+}))
+    .action(async () => {
+    // Fast local check to provide clear auth guidance before network calls.
+    if (!(0, auth_1.readCredentials)()) {
+        console.log((0, ui_1.section)("Authentication required", (0, ui_1.listLines)([`Run ${(0, ui_1.code)("jungle login")} to authenticate.`]), "warning"));
+        process.exit(1);
+    }
+    try {
+        const result = await (0, api_1.apiRequest)("GET", "/v1/jobs");
+        const jobsFromApi = Array.isArray(result.jobs) ? result.jobs : [];
+        // Default behavior: show all owner-filtered jobs from the API,
+        // including terminal states like completed/failed.
+        const jobs = [...jobsFromApi].sort((a, b) => (b.CreatedAtUnix ?? 0) - (a.CreatedAtUnix ?? 0));
+        if (jobs.length === 0) {
+            console.log((0, ui_1.joinBlocks)([
+                (0, ui_1.section)("No jobs found", ["No workloads are currently associated with this account."], "warning"),
+                (0, ui_1.section)("Next step", (0, ui_1.listLines)([`Queue one with ${(0, ui_1.code)("jungle submit ...")}.`]), "info"),
+            ]));
+            return;
+        }
+        // PILLAR 1: Render intent and lifecycle fields only.
+        // We intentionally do not display any hardware-specific API fields.
+        const rows = jobs.map((job) => [
+            fitColumn(job.ID ?? "", JOB_TABLE_COLUMNS.id),
+            fitColumn(job.Name ?? "", JOB_TABLE_COLUMNS.name),
+            (0, ui_1.statusLabel)(fitColumn(job.Status ?? "unknown", JOB_TABLE_COLUMNS.status)),
+            fitColumn(job.WorkloadType ?? "", JOB_TABLE_COLUMNS.workload),
+            fitColumn(job.OptimizeFor ?? "balanced", JOB_TABLE_COLUMNS.optimize),
+            fitColumn(formatUnixSeconds(job.CreatedAtUnix), JOB_TABLE_COLUMNS.created),
+            fitColumn(formatUnixSeconds(job.UpdatedAtUnix), JOB_TABLE_COLUMNS.updated),
+        ]);
+        console.log((0, ui_1.joinBlocks)([
+            (0, ui_1.section)("Jobs overview", [
+                `${jobs.length} workload${jobs.length === 1 ? "" : "s"} returned for the current account.`,
+            ], "info"),
+            (0, ui_1.renderTable)(["ID", "NAME", "STATUS", "WORKLOAD", "OPTIMIZE", "CREATED", "UPDATED"], rows),
+        ]));
+    }
+    catch (err) {
+        if (err instanceof api_1.ApiError && err.status === 401) {
+            (0, auth_1.clearCredentials)();
+            console.error((0, ui_1.danger)(`Session expired. Run ${(0, ui_1.code)("jungle login")} to re-authenticate.`));
+            process.exit(1);
+        }
+        console.error((0, ui_1.danger)(renderApiError("Failed to list jobs", err)));
+        process.exit(1);
+    }
+});
+// ─── jungle nodes ──────────────────────────────────────────────────────────
+const nodesCommand = program
+    .command("nodes")
+    .description("List available nodes in the pool")
+    .option("--workload <type>", "Filter nodes eligible for a workload type")
+    .addHelpText("after", renderGuide({
+    summary: "Lists currently registered nodes with marketplace-facing signals such as health, reliability, queue depth, and price.",
+    examples: [
+        "jungle nodes",
+        "jungle nodes --workload inference",
+        "jungle nodes show node-abc123",
+    ],
+    notes: [
+        "Use jungle nodes show <node-id> for the full remote node detail view.",
+        "Workload filtering is currently best-effort and may expand in future API versions.",
+    ],
+}))
+    .action(async (opts) => {
+    try {
+        let endpoint = "/v1/nodes";
+        // When logged in as a provider, prefer the provider-owned node listing endpoint.
+        // Fall back to the public list for unauthenticated sessions and non-provider roles.
+        const creds = (0, auth_1.readCredentials)();
+        if (creds) {
+            try {
+                const me = await (0, api_1.apiRequest)("GET", "/auth/me");
+                if (me.role === "provider") {
+                    endpoint = "/v1/nodes/mine";
+                }
+            }
+            catch (err) {
+                if (err instanceof api_1.ApiError && err.status === 401) {
+                    (0, auth_1.clearCredentials)();
+                    console.error((0, ui_1.danger)(`Session expired. Run ${(0, ui_1.code)("jungle login")} to re-authenticate.`));
+                    process.exit(1);
+                }
+                // If identity lookup fails for transient reasons, keep global list fallback.
+            }
+        }
+        // TODO: Pillar 2 — When the API supports GET /v1/nodes?workload_type=...,
+        // pass the filter server-side so the classifier determines eligibility.
+        // For now we fetch nodes from either the global or provider-owned endpoint.
+        const result = await (0, api_1.apiRequest)("GET", endpoint);
+        if (!result.nodes || result.nodes.length === 0) {
+            console.log((0, ui_1.section)("No nodes found", ["No nodes are currently registered for this view."], "warning"));
+            return;
+        }
+        const rows = result.nodes.map((node) => {
+            const normalized = normalizeNodeRecord(node);
+            return [
+                fitColumn(normalized.id, 20),
+                (0, ui_1.statusLabel)(fitColumn(normalized.status ?? "unknown", 12)),
+                healthLabel(fitColumn(normalized.healthStatus ?? "unknown", 10)),
+                fitColumn(normalized.location ?? "-", 15),
+                formatInteger(normalized.queueDepth, "0"),
+                formatCurrency(normalized.pricePerHour, "0.00"),
+                formatNumber(normalized.reliabilityScore, 2, "-"),
+                formatNumber(normalized.latencyScore, 2, "-"),
+                formatNumber(normalized.performanceScore, 2, "-"),
+            ];
+        });
+        console.log((0, ui_1.joinBlocks)([
+            (0, ui_1.section)(endpoint === "/v1/nodes/mine" ? "Provider nodes" : "Global node view", [
+                `${result.nodes.length} node${result.nodes.length === 1 ? "" : "s"} returned${opts.workload ? ` for workload ${(0, ui_1.strong)(opts.workload)}` : ""}.`,
+            ], "info"),
+            (0, ui_1.renderTable)(["ID", "STATUS", "HEALTH", "LOCATION", "QUEUE", "$/HR", "RELIAB", "LAT", "PERF"], rows),
+        ]));
+    }
+    catch (err) {
+        console.error((0, ui_1.danger)(renderApiError("Failed to list nodes", err)));
+        process.exit(1);
+    }
+});
+nodesCommand
+    .command("show <node-id>")
+    .description("Show full remote marketplace detail for one node")
+    .addHelpText("after", renderGuide({
+    summary: "Shows the full remote node record, including hardware, pricing, scheduling signals, and heartbeat state.",
+    examples: [
+        "jungle nodes show node-abc123",
+    ],
+    notes: [
+        "This command inspects the remote marketplace node, not the local node-agent daemon.",
+        `Use ${(0, ui_1.code)("jungle node status")} for the local daemon process on this machine.`,
+    ],
+}))
+    .action(async (nodeId) => {
+    try {
+        const result = await (0, api_1.apiRequest)("GET", "/v1/nodes");
+        const normalizedNodes = (result.nodes ?? []).map(normalizeNodeRecord);
+        const node = normalizedNodes.find((candidate) => candidate.id === nodeId);
+        if (!node) {
+            console.log((0, ui_1.joinBlocks)([
+                (0, ui_1.section)("Node not found", [`No remote node matched ${(0, ui_1.strong)(nodeId)} in the current marketplace view.`], "warning"),
+                (0, ui_1.section)("Next step", (0, ui_1.listLines)([`Run ${(0, ui_1.code)("jungle nodes")} to inspect the available node IDs.`]), "info"),
+            ]));
+            process.exit(1);
+        }
+        console.log((0, ui_1.joinBlocks)([
+            (0, ui_1.section)("Remote node detail", (0, ui_1.kvLines)([
+                ["Node ID", (0, ui_1.strong)(node.id)],
+                ["Status", (0, ui_1.statusLabel)(node.status ?? "unknown")],
+                ["Health", healthLabel(node.healthStatus)],
+                ["Location", formatText(node.location)],
+                ["Last heartbeat", formatHeartbeatTimestamp(node.lastHeartbeatUnix)],
+            ]), "info"),
+            (0, ui_1.section)("Marketplace signals", (0, ui_1.kvLines)([
+                ["Price / hour", formatCurrency(node.pricePerHour)],
+                ["Reliability", formatNumber(node.reliabilityScore)],
+                ["Latency", formatNumber(node.latencyScore)],
+                ["Performance", formatNumber(node.performanceScore)],
+                ["Queue depth", formatInteger(node.queueDepth)],
+                ["Thermal throttled", formatBoolean(node.thermalThrottled)],
+            ]), "primary"),
+            (0, ui_1.section)("Hardware profile", (0, ui_1.kvLines)([
+                ["GPU type", formatText(node.gpuType)],
+                ["VRAM", formatGigabytes(node.vramGB)],
+                ["GPU count", formatInteger(node.gpuCount)],
+                ["CUDA support", formatBoolean(node.cudaSupport)],
+                ["CUDA version", formatText(node.cudaVersion)],
+                ["Compute capability", formatText(node.computeCapability)],
+            ]), "muted"),
+            (0, ui_1.section)("Control plane", (0, ui_1.kvLines)([
+                ["Dispatch URL", formatText(node.dispatchURL)],
+            ]), "muted"),
+        ]));
+    }
+    catch (err) {
+        console.error((0, ui_1.danger)(renderApiError("Failed to show node detail", err)));
+        process.exit(1);
+    }
+});
+// ─── jungle login ──────────────────────────────────────────────────────────
+program
+    .command("login")
+    .description("Authenticate with Jungle Grid via browser-based login")
+    .option("--no-browser", "Do not try to open a local browser; print login instructions and keep polling")
+    .addHelpText("after", renderGuide({
+    summary: "Starts browser-based device login and stores the resulting session locally on this machine.",
+    examples: ["jungle login", "jungle login --no-browser"],
+    behavior: [
+        "If already logged in, the CLI reports the active session and does not restart login.",
+        "If the stored token has expired, credentials are cleared and login restarts cleanly.",
+        "The login URL can be opened in any browser, including one on another machine.",
+    ],
+}))
+    .action(async (opts) => {
+    try {
+        // If credentials already exist, verify before starting a new login flow.
+        // This avoids unnecessary device-flow prompts for users who are already authenticated.
+        const existingCreds = (0, auth_1.readCredentials)();
+        if (existingCreds) {
+            try {
+                const me = await (0, api_1.apiRequest)("GET", "/auth/me");
+                console.log(renderSummary("Session already active", [
+                    ["Email", (0, ui_1.strong)(me.email)],
+                    ["Account ID", me.id],
+                ], "info", [`Run ${(0, ui_1.code)("jungle logout")} first if you want to switch accounts.`]));
+                return;
+            }
+            catch (err) {
+                if (err instanceof api_1.ApiError && err.status === 401) {
+                    // Expired/revoked token: clear and continue with normal login below.
+                    (0, auth_1.clearCredentials)();
+                }
+                else {
+                    // If verification fails for non-auth reasons, preserve current local session.
+                    if (existingCreds.user?.email && existingCreds.user?.id) {
+                        console.log(renderSummary("Offline session detected", [
+                            ["Email", (0, ui_1.strong)(existingCreds.user.email)],
+                            ["Account ID", existingCreds.user.id],
+                            ["Verification", (0, ui_1.warning)("offline - could not verify token")],
+                        ], "warning", [`Run ${(0, ui_1.code)("jungle logout")} first if you want to switch accounts.`]));
+                    }
+                    else {
+                        console.log((0, ui_1.section)("Offline session detected", ["Stored credentials exist but the session could not be verified right now."], "warning"));
+                    }
+                    return;
+                }
+            }
+        }
+        // Step 1: Generate a random device code to link this CLI session
+        // to the browser-based login flow.
+        const deviceCode = generateDeviceCode();
+        // Step 2: Register the device code with the API.
+        const authResponse = await (0, api_1.apiRequest)("POST", "/auth/device", { device_code: deviceCode });
+        // Step 3: Print device-login details in a format that works for both
+        // desktop and headless sessions. Browser launch is optional convenience;
+        // the actual auth contract is the device code plus login URL.
+        printDeviceLoginInstructions(authResponse.login_url, deviceCode);
+        if (opts.noBrowser) {
+            console.log((0, ui_1.section)("Browser launch", ["Auto-open disabled. Continue with the URL above."], "warning"));
+        }
+        else {
+            const launchResult = await launchBrowserBestEffort(authResponse.login_url);
+            if (launchResult.launched) {
+                console.log((0, ui_1.section)("Browser launch", ["Opening a local browser for authentication."], "info"));
+            }
+            else if (!launchResult.attempted) {
+                console.log((0, ui_1.section)("Browser launch", [launchResult.reason || "Open the login URL on any machine to continue."], "warning"));
+            }
+            else {
+                console.log((0, ui_1.section)("Browser launch", ["Could not open a local browser. Continue manually with the login details above."], "warning"));
+                if (launchResult.reason) {
+                    console.log((0, ui_1.muted)(`  detail ${launchResult.reason}`));
+                }
+            }
+        }
+        // Step 4: Poll for token completion.
+        // The browser step may happen on this machine or a different one. The CLI
+        // simply polls until the server confirms authentication or times out.
+        console.log((0, ui_1.section)("Waiting for confirmation", [
+            `Polling every ${LOGIN_POLL_INTERVAL_MS / 1000}s for up to ${LOGIN_TIMEOUT_MS / 60000} minutes.`,
+            "Leave this terminal open while you finish the browser step.",
+        ], "info"));
+        const startTime = Date.now();
+        while (Date.now() - startTime < LOGIN_TIMEOUT_MS) {
+            await sleep(LOGIN_POLL_INTERVAL_MS);
+            const tokenResult = await (0, api_1.apiPoll)(`/auth/token?device_code=${encodeURIComponent(deviceCode)}`);
+            if (tokenResult) {
+                // Step 5: Store credentials locally.
+                // SECURITY: The token itself is never printed to the console.
+                (0, auth_1.writeCredentials)({
+                    token: tokenResult.token,
+                    user: tokenResult.user,
+                });
+                console.log(renderSummary("Login complete", [
+                    ["Email", (0, ui_1.strong)(tokenResult.user.email)],
+                    ["Role", tokenResult.user.role ? (0, ui_1.statusLabel)(tokenResult.user.role) : (0, ui_1.muted)("unknown")],
+                ], "success", [
+                    `Check the active session with ${(0, ui_1.code)("jungle whoami")}.`,
+                    `Start working with ${(0, ui_1.code)("jungle jobs")} or ${(0, ui_1.code)("jungle nodes")}.`,
+                ]));
+                return;
+            }
+            // null means 202 (still pending) — continue polling.
+        }
+        // Timeout reached without successful login.
+        console.error((0, ui_1.danger)(`Login timed out. Please try again with ${(0, ui_1.code)("jungle login")}.`));
+        process.exit(1);
+    }
+    catch (err) {
+        console.error((0, ui_1.danger)(renderApiError("Login failed", err)));
+        process.exit(1);
+    }
+});
+// ─── jungle logout ─────────────────────────────────────────────────────────
+program
+    .command("logout")
+    .description("Clear stored authentication credentials")
+    .addHelpText("after", renderGuide({
+    summary: "Removes locally stored credentials for the current CLI session.",
+    examples: ["jungle logout"],
+    notes: ["Run jungle login again after logout to switch accounts."],
+}))
+    .action(() => {
+    (0, auth_1.clearCredentials)();
+    console.log((0, ui_1.section)("Session cleared", ["Stored credentials were removed from this machine."], "success"));
+});
+// ─── jungle whoami ─────────────────────────────────────────────────────────
+program
+    .command("whoami")
+    .description("Print the currently authenticated user")
+    .addHelpText("after", renderGuide({
+    summary: "Prints the identity currently associated with the stored session.",
+    examples: ["jungle whoami"],
+    notes: ["If the session has expired, run jungle login to re-authenticate."],
+}))
+    .action(async () => {
+    // First check local credentials for a quick response.
+    const creds = (0, auth_1.readCredentials)();
+    if (!creds) {
+        console.log((0, ui_1.section)("Authentication required", (0, ui_1.listLines)([`Run ${(0, ui_1.code)("jungle login")} to authenticate.`]), "warning"));
+        process.exit(1);
+    }
+    try {
+        // Verify the token is still valid by calling the /auth/me endpoint.
+        const me = await (0, api_1.apiRequest)("GET", "/auth/me");
+        console.log(renderSummary("Active session", [
+            ["Email", (0, ui_1.strong)(me.email)],
+            ["Account ID", me.id],
+            ["Role", me.role ? (0, ui_1.statusLabel)(me.role) : (0, ui_1.muted)("unknown")],
+        ], "info"));
+    }
+    catch (err) {
+        if (err instanceof api_1.ApiError && err.status === 401) {
+            // Token expired or revoked.
+            console.log((0, ui_1.section)("Session expired", (0, ui_1.listLines)([`Run ${(0, ui_1.code)("jungle login")} to re-authenticate.`]), "warning"));
+            (0, auth_1.clearCredentials)();
+            process.exit(1);
+        }
+        // Server unreachable — fall back to locally stored info.
+        console.log(`Logged in as ${creds.user.email} (${creds.user.id}) [offline — could not verify token]`);
+    }
+});
+// ─── jungle shell ──────────────────────────────────────────────────────────
+program
+    .command("shell")
+    .description("Start an interactive REPL shell session")
+    .addHelpText("after", renderGuide({
+    summary: "Opens an interactive prompt so you can stay inside Jungle Grid while running multiple commands.",
+    examples: ["jungle shell"],
+    notes: [
+        `Inside the shell, try ${(0, ui_1.code)("help")}, ${(0, ui_1.code)("jobs")}, or ${(0, ui_1.code)("submit --workload inference --model-size 7 --image ...")}.`,
+        "Use exit or quit to leave the shell.",
+    ],
+}))
+    .action(async () => {
+    await (0, repl_1.startRepl)(program);
+});
+// ─── jungle node register/start/stop/status ───────────────────────────────
+const nodeCommand = program
+    .command("node")
+    .description("Node owner workflows: register and manage node-agent runtime");
+nodeCommand
+    .command("register")
+    .alias("registration")
+    .description("Register this machine as a provider node")
+    .option("--dispatch-url <url>", "Public dispatch URL for this node")
+    .option("--location <location>", "Node location label", "local")
+    .option("--price-per-hour <amount>", "Node hourly price", "1.0")
+    .option("--reliability-score <score>", "Reliability score [0..1]", "0.90")
+    .option("--performance-score <score>", "Performance score [0..1]", "0.85")
+    .addHelpText("after", renderGuide({
+    summary: "Registers this machine as a provider node endpoint and stores the returned local node configuration.",
+    examples: [
+        "jungle node register --dispatch-url http://127.0.0.1:8090 --location lagos",
+    ],
+    notes: [
+        "Requires provider login.",
+        "Requires nvidia-smi unless JUNGLE_SIMULATION_MODE is enabled.",
+        "Validates payout account details through backend Paystack validation.",
+    ],
+}))
+    .action(async (opts) => {
+    try {
+        const creds = (0, auth_1.readCredentials)();
+        ensureProviderSessionOrFail(creds);
+        const me = await (0, api_1.apiRequest)("GET", "/auth/me");
+        if (me.role !== "provider") {
+            console.error((0, ui_1.danger)("Only provider accounts can register nodes."));
+            process.exit(1);
+        }
+        if (isSimulationModeEnabled()) {
+            console.log((0, ui_1.section)("Simulation mode", ["JUNGLE_SIMULATION_MODE is enabled; using the simulated GPU profile."], "warning"));
+        }
+        const hardware = detectNodeHardwareOrFail();
+        const prompts = await collectNodeRegistrationPrompts(me.email);
+        const dispatchURL = await resolveDispatchURL(opts.dispatchUrl);
+        const apiUrl = (0, config_1.getApiUrl)();
+        const payload = {
+            node_id: `node-${Date.now().toString(36)}`,
+            email: prompts.email,
+            payout: {
+                bank_name: prompts.bankName,
+                account_number: prompts.accountNumber,
+                account_name: prompts.accountName,
+            },
+            hardware: {
+                gpu: hardware.gpu,
+                vram_gb: hardware.vramGb,
+                gpu_count: hardware.gpuCount,
+                cpu_cores: hardware.cpuCores,
+                cpu_mhz: hardware.cpuMHz,
+                ram_gb: hardware.ramGB,
+                cuda_version: hardware.cudaVersion,
+                cuda_support: hardware.cudaSupport,
+                compute_capability: hardware.computeCapability,
+            },
+            network: {
+                latency_ms: await measureLatencyMs(apiUrl),
+            },
+            environment: {
+                os: hardware.os,
+                location: opts.location,
+                dispatch_url: dispatchURL,
+            },
+            price_per_hour: parseFloat(opts.pricePerHour),
+            reliability_score: parseFloat(opts.reliabilityScore),
+            performance_score: parseFloat(opts.performanceScore),
+        };
+        const registered = await (0, api_1.apiRequest)("POST", "/v1/nodes/register", payload);
+        (0, node_config_1.writeNodeConfig)({
+            node_id: registered.node_id,
+            api_key: registered.api_key,
+            email: prompts.email,
+            orchestrator_url: apiUrl,
+            dispatch_url: dispatchURL,
+            gpu: hardware.gpu,
+            vram_gb: hardware.vramGb,
+            gpu_count: hardware.gpuCount,
+            cpu_cores: hardware.cpuCores,
+            cpu_mhz: hardware.cpuMHz,
+            ram_gb: hardware.ramGB,
+            cuda_version: hardware.cudaVersion,
+            cuda_support: hardware.cudaSupport,
+            compute_capability: hardware.computeCapability,
+            os: hardware.os,
+            location: opts.location,
+            latency_ms: payload.network.latency_ms,
+            price_per_hour: payload.price_per_hour,
+            reliability_score: payload.reliability_score,
+            performance_score: payload.performance_score,
+            registered_status: registered.status,
+        });
+        console.log(renderSummary("Node registered", [
+            ["Node ID", (0, ui_1.strong)(registered.node_id)],
+            ["Status", (0, ui_1.statusLabel)(registered.status)],
+            ["Config", (0, ui_1.pathLabel)((0, node_config_1.nodeConfigFilePath)())],
+        ], "success", [
+            `Activate the runtime with ${(0, ui_1.code)("jungle node start --daemon")} ${(0, ui_1.muted)("(installs node-agent automatically when needed)")}.`,
+            `Inspect runtime state with ${(0, ui_1.code)("jungle node status")}.`,
+        ]));
+    }
+    catch (err) {
+        if (err instanceof api_1.ApiError && err.status === 401) {
+            (0, auth_1.clearCredentials)();
+            console.error((0, ui_1.danger)(`Session expired. Run ${(0, ui_1.code)("jungle login")} again.`));
+        }
+        else {
+            console.error((0, ui_1.danger)(renderApiError("Node registration failed", err)));
+        }
+        process.exit(1);
+    }
+});
+nodeCommand
+    .command("install-agent")
+    .description("Install the managed node-agent binary for this machine")
+    .option("--force", "Re-download the node-agent even if a verified copy already exists")
+    .addHelpText("after", renderGuide({
+    summary: "Downloads the node-agent release binary that matches the installed CLI version and current platform.",
+    examples: [
+        "jungle node install-agent",
+        "jungle node install-agent --force",
+    ],
+    notes: [
+        "This command does not require node registration.",
+        "The binary is stored under ~/.jungle-grid/bin/node-agent/<version>.",
+        `Most providers can skip this and just run ${(0, ui_1.code)("jungle node start")}, which auto-installs on demand.`,
+    ],
+}))
+    .action(async (opts) => {
+    try {
+        const result = await (0, node_agent_installer_1.ensureManagedNodeAgentInstalled)(CLI_VERSION, {
+            force: Boolean(opts.force),
+            onProgress: (message) => console.log((0, ui_1.muted)(message)),
+        });
+        console.log(renderSummary(result.downloaded ? "Node-agent installed" : "Node-agent ready", [
+            ["Version", (0, ui_1.strong)(result.releaseTag)],
+            ["Platform", (0, ui_1.info)(result.platformLabel)],
+            ["Binary", (0, ui_1.pathLabel)(result.binaryPath)],
+        ], "success", result.downloaded
+            ? [
+                `Start the runtime with ${(0, ui_1.code)("jungle node start --daemon")}.`,
+                `Manual override still works via ${(0, ui_1.code)("jungle node start --binary <path>")}.`,
+            ]
+            : [`The verified managed binary is already cached locally.`]));
+    }
+    catch (err) {
+        console.error((0, ui_1.danger)(renderApiError("Node-agent install failed", err)));
+        process.exit(1);
+    }
+});
+nodeCommand
+    .command("start")
+    .description("Start node-agent process for this registered node")
+    .option("--binary <path>", "Path to node-agent binary", "")
+    .option("--daemon", "Run node-agent as a detached background process")
+    .addHelpText("after", renderGuide({
+    summary: "Launches the node-agent with the stored node configuration and optionally detaches it as a tracked daemon.",
+    examples: [
+        "jungle node start",
+        "jungle node start --daemon",
+        "jungle node start --binary go",
+        "jungle node start --binary C:/tools/node-agent.exe",
+    ],
+    notes: [
+        "Requires prior jungle node register.",
+        "Installs the matching managed node-agent automatically when no --binary is supplied.",
+        "Use --daemon to run in the background with PID tracking.",
+        "Starts the heartbeat loop and dispatch listener through the node-agent runtime.",
+    ],
+}))
+    .action(async (opts) => {
+    let daemonPid = null;
+    let child = null;
+    try {
+        const config = (0, node_config_1.readNodeConfig)();
+        if (!config) {
+            console.error((0, ui_1.danger)(`No node config found. Run ${(0, ui_1.code)("jungle node register")} first.`));
+            process.exit(1);
+        }
+        const trackedRuntime = (0, node_config_1.readNodeRuntime)();
+        if (trackedRuntime) {
+            if (isProcessRunning(trackedRuntime.pid)) {
+                console.error((0, ui_1.danger)(`Node-agent daemon is already running (PID ${trackedRuntime.pid}).`));
+                console.error((0, ui_1.muted)(`Use ${(0, ui_1.code)("jungle node status")} or ${(0, ui_1.code)("jungle node stop")}.`));
+                process.exit(1);
+            }
+            (0, node_config_1.clearNodeRuntime)();
+        }
+        const daemonMode = Boolean(opts.daemon);
+        const launch = await resolveNodeAgentLaunchSpec(opts.binary);
+        const { binary, args, cwd: spawnCwd } = launch;
+        const runtimeEnv = {
+            ...process.env,
+            ORCH_BASE_URL: config.orchestrator_url,
+            NODE_AGENT_ID: config.node_id,
+            NODE_AGENT_KEY: config.api_key,
+            NODE_AGENT_SECRET: process.env.NODE_AGENT_SECRET || "",
+            NODE_GPU_TYPE: config.gpu,
+            NODE_VRAM_GB: String(config.vram_gb),
+            NODE_PRICE_PER_HOUR: String(config.price_per_hour),
+            NODE_RELIABILITY_SCORE: String(config.reliability_score),
+            NODE_PERFORMANCE_SCORE: String(config.performance_score),
+            NODE_LATENCY_SCORE: String(Math.max(0.1, Math.min(0.99, 1 - (config.latency_ms / 500)))),
+            NODE_DISPATCH_PUBLIC_URL: config.dispatch_url,
+        };
+        if (launch.installSummary?.downloaded) {
+            console.log((0, ui_1.section)("Managed node-agent", [
+                `Installed ${(0, ui_1.strong)(launch.installSummary.version)} for ${(0, ui_1.info)(launch.installSummary.platformLabel)}.`,
+                `Binary ${(0, ui_1.pathLabel)(launch.installSummary.binaryPath)}`,
+            ], "success"));
+        }
+        if (daemonMode) {
+            child = (0, child_process_1.spawn)(binary, args, {
+                cwd: spawnCwd,
+                detached: true,
+                stdio: "ignore",
+                env: runtimeEnv,
+            });
+            const pid = child.pid ?? 0;
+            if (pid <= 0) {
+                throw new Error("failed to start node-agent daemon process");
+            }
+            daemonPid = pid;
+            child.unref();
+            // Give the process a short window to fail fast (bad binary, env, etc).
+            await sleep(600);
+            if (!isProcessRunning(pid)) {
+                throw new Error("node-agent daemon exited immediately");
+            }
+            (0, node_config_1.writeNodeRuntime)({
+                node_id: config.node_id,
+                pid,
+                mode: "daemon",
+                started_at_unix: Math.floor(Date.now() / 1000),
+                binary,
+                args,
+                cwd: spawnCwd,
+            });
+            const activated = await (0, api_1.apiRequest)("POST", `/v1/nodes/${encodeURIComponent(config.node_id)}/activate`, {
+                dispatch_url: config.dispatch_url,
+                api_key: config.api_key,
+            });
+            console.log(renderSummary("Node daemon started", [
+                ["Node ID", (0, ui_1.strong)(activated.node_id)],
+                ["Status", (0, ui_1.statusLabel)(activated.status)],
+                ["PID", String(pid)],
+                ["Runtime", (0, ui_1.pathLabel)((0, node_config_1.nodeRuntimeFilePath)())],
+            ], "success", [
+                `Verify health with ${(0, ui_1.code)("jungle node status")}.`,
+                `Stop the daemon with ${(0, ui_1.code)("jungle node stop")}.`,
+            ]));
+            return;
+        }
+        child = (0, child_process_1.spawn)(binary, args, {
+            cwd: spawnCwd,
+            stdio: "inherit",
+            env: runtimeEnv,
+        });
+        await new Promise((resolve, reject) => {
+            child?.once("spawn", () => resolve());
+            child?.once("error", (spawnErr) => reject(spawnErr));
+        });
+        const activated = await (0, api_1.apiRequest)("POST", `/v1/nodes/${encodeURIComponent(config.node_id)}/activate`, {
+            dispatch_url: config.dispatch_url,
+            api_key: config.api_key,
+        });
+        if (child.exitCode !== null) {
+            throw new Error(`node-agent exited before activation completed (code ${child.exitCode})`);
+        }
+        console.log(renderSummary("Node runtime attached", [
+            ["Node ID", (0, ui_1.strong)(activated.node_id)],
+            ["Status", (0, ui_1.statusLabel)(activated.status)],
+            ["Mode", (0, ui_1.info)("foreground")],
+        ], "success"));
+        child.on("exit", (code) => {
+            process.exit(typeof code === "number" ? code : 0);
+        });
+    }
+    catch (err) {
+        if (daemonPid !== null) {
+            try {
+                await stopProcessByPid(daemonPid);
+            }
+            catch {
+                // Best-effort rollback.
+            }
+            (0, node_config_1.clearNodeRuntime)();
+        }
+        if (child && child.exitCode === null && !child.killed) {
+            child.kill();
+        }
+        if (err instanceof api_1.ApiError && err.status === 401) {
+            (0, auth_1.clearCredentials)();
+            console.error((0, ui_1.danger)(`Session expired. Run ${(0, ui_1.code)("jungle login")} again.`));
+        }
+        else {
+            console.error((0, ui_1.danger)(renderApiError("Node start failed", err)));
+        }
+        process.exit(1);
+    }
+});
+nodeCommand
+    .command("stop")
+    .description("Stop node-agent daemon process")
+    .addHelpText("after", renderGuide({
+    summary: "Stops the node-agent process started with jungle node start --daemon.",
+    examples: ["jungle node stop"],
+}))
+    .action(async () => {
+    try {
+        const runtime = (0, node_config_1.readNodeRuntime)();
+        if (!runtime) {
+            console.log((0, ui_1.section)("No daemon runtime", ["No tracked node-agent daemon was found on this machine."], "warning"));
+            return;
+        }
+        if (!isProcessRunning(runtime.pid)) {
+            (0, node_config_1.clearNodeRuntime)();
+            console.log((0, ui_1.section)("Runtime cleaned up", [`A stale PID record was removed for ${(0, ui_1.strong)(String(runtime.pid))}.`], "warning"));
+            return;
+        }
+        await stopProcessByPid(runtime.pid);
+        (0, node_config_1.clearNodeRuntime)();
+        console.log(renderSummary("Node daemon stopped", [["PID", String(runtime.pid)]], "success"));
+    }
+    catch (err) {
+        console.error((0, ui_1.danger)(renderApiError("Node stop failed", err)));
+        process.exit(1);
+    }
+});
+nodeCommand
+    .command("status")
+    .description("Show node-agent daemon status")
+    .addHelpText("after", renderGuide({
+    summary: "Shows whether a daemonized node-agent process is currently running on this machine.",
+    examples: ["jungle node status"],
+}))
+    .action(() => {
+    const runtime = (0, node_config_1.readNodeRuntime)();
+    if (!runtime) {
+        console.log(renderSummary("Node daemon stopped", [["Runtime file", `${(0, ui_1.pathLabel)((0, node_config_1.nodeRuntimeFilePath)())} ${(0, ui_1.muted)("(not found)")}`]], "warning"));
+        return;
+    }
+    const running = isProcessRunning(runtime.pid);
+    if (!running) {
+        (0, node_config_1.clearNodeRuntime)();
+        console.log(renderSummary("Node daemon stopped", [["Last PID", `${runtime.pid} ${(0, ui_1.muted)("(stale PID removed)")}`]], "warning"));
+        return;
+    }
+    console.log(renderSummary("Node daemon running", [
+        ["Node ID", (0, ui_1.strong)(runtime.node_id)],
+        ["PID", String(runtime.pid)],
+        ["Mode", (0, ui_1.info)(runtime.mode)],
+        ["Started", new Date(runtime.started_at_unix * 1000).toISOString()],
+        ["Binary", runtime.binary],
+        ["CWD", (0, ui_1.pathLabel)(runtime.cwd)],
+        ["Runtime", (0, ui_1.pathLabel)((0, node_config_1.nodeRuntimeFilePath)())],
+    ], "info"));
+});
+// ─── Parse and execute ─────────────────────────────────────────────────────
+function shouldPrintStartupBanner(argv) {
+    if (!process.stdout.isTTY) {
+        return false;
+    }
+    if (argv.length === 0) {
+        return false;
+    }
+    if (argv.length === 1 && (argv[0] === "--version" || argv[0] === "-V")) {
+        return false;
+    }
+    return true;
+}
+async function main() {
+    const argv = process.argv.slice(2);
+    // Start REPL only when no arguments are supplied.
+    // This avoids recursive REPL startup when invalid commands are entered in REPL mode.
+    if (argv.length === 0) {
+        await (0, repl_1.startRepl)(program);
+        return;
+    }
+    if (shouldPrintStartupBanner(argv)) {
+        (0, banner_1.printBanner)(CLI_VERSION);
+    }
+    await program.parseAsync(process.argv);
+}
+main().catch((err) => {
+    if (err instanceof Error) {
+        console.error(`CLI failed: ${err.message}`);
+    }
+    else {
+        console.error("CLI failed: unexpected error");
+    }
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map