@moldesk/cli 0.0.1 → 0.0.2

package/dist/commands/install.test.js

@@ -0,0 +1,231 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { Command } from "commander";
+import { createFakeSpawn } from "../testSupport/spawnMock.js";
+import { registerInstallCommand } from "./install.js";
+const state = vi.hoisted(() => ({
+    handler: ((_cmd, _args) => ({ code: 127 })),
+}));
+vi.mock("node:child_process", () => ({
+    spawn: (command, args) => createFakeSpawn((c, a) => state.handler(c, a))(command, args),
+}));
+function noDockerNoNvidia() {
+    return (cmd) => {
+        if (cmd === "python3" || cmd === "python" || cmd === "which")
+            return { code: 127, spawnError: true };
+        if (cmd === "docker")
+            return { code: 127, spawnError: true };
+        if (cmd === "nvidia-smi" || cmd === "nvcc")
+            return { code: 127, spawnError: true };
+        return { code: 1 };
+    };
+}
+function dirSnapshot(dir) {
+    if (!fs.existsSync(dir))
+        return [];
+    return fs.readdirSync(dir, { recursive: true }).map(String).sort();
+}
+function writeManifest(modelsDir, name, yaml) {
+    const dir = path.join(modelsDir, name);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(path.join(dir, "manifest.yaml"), yaml);
+}
+const CPU_PYTHON_MANIFEST = (name) => `
+schemaVersion: 1
+name: ${name}
+displayName: Test CPU Model
+modelVersion: "1.0.0"
+adapterVersion: "0.1.0"
+description: test
+category: other
+status: beta
+runtimes:
+  - kind: python
+    python: "3.11"
+    installer: uv
+    requirements:
+      - name: torch
+        version: "2.2.1"
+hardware:
+  platforms: [darwin-arm64, linux-x64]
+input:
+  formats: [".pdb"]
+  required: true
+outputs:
+  - id: out
+    glob: "*.txt"
+    required: true
+`;
+const UNSUPPORTED_PYTHON_VERSION_MANIFEST = (name) => `
+schemaVersion: 1
+name: ${name}
+displayName: Test Old Python Model
+modelVersion: "1.0.0"
+adapterVersion: "0.1.0"
+description: test
+category: other
+status: beta
+runtimes:
+  - kind: python
+    python: "3.8"
+    installer: uv
+    requirements:
+      - name: torch
+        version: "2.2.1"
+hardware:
+  platforms: [darwin-arm64, linux-x64]
+input:
+  formats: [".pdb"]
+  required: true
+outputs:
+  - id: out
+    glob: "*.txt"
+    required: true
+`;
+const DOCKER_GPU_REQUIRED_MANIFEST = (name) => `
+schemaVersion: 1
+name: ${name}
+displayName: Test Docker GPU Model
+modelVersion: "1.0.0"
+adapterVersion: "0.1.0"
+description: test
+category: other
+status: beta
+runtimes:
+  - kind: docker
+    image: example/test:latest
+    digest: "sha256:${"a".repeat(64)}"
+    gpu: required
+hardware:
+  platforms: [darwin-arm64, linux-x64]
+input:
+  formats: [".pdb"]
+  required: true
+outputs:
+  - id: out
+    glob: "*.txt"
+    required: true
+`;
+let modelsDir;
+let moldeskHome;
+let logs;
+let errors;
+beforeEach(() => {
+    modelsDir = fs.mkdtempSync(path.join(os.tmpdir(), "moldesk-models-"));
+    moldeskHome = fs.mkdtempSync(path.join(os.tmpdir(), "moldesk-home-"));
+    process.env["MOLDESK_MODELS_DIR"] = modelsDir;
+    process.env["MOLDESK_HOME"] = moldeskHome;
+    logs = [];
+    errors = [];
+    vi.spyOn(console, "log").mockImplementation((msg) => {
+        logs.push(String(msg));
+    });
+    vi.spyOn(console, "error").mockImplementation((msg) => {
+        errors.push(String(msg));
+    });
+    state.handler = noDockerNoNvidia();
+});
+afterEach(() => {
+    vi.restoreAllMocks();
+    delete process.env["MOLDESK_MODELS_DIR"];
+    delete process.env["MOLDESK_HOME"];
+    fs.rmSync(modelsDir, { recursive: true, force: true });
+    fs.rmSync(moldeskHome, { recursive: true, force: true });
+});
+function buildProgram() {
+    const program = new Command();
+    program.exitOverride();
+    registerInstallCommand(program);
+    return program;
+}
+describe("install (real command, faked process boundary only)", () => {
+    it("performs zero filesystem writes for an unsupported install", async () => {
+        writeManifest(modelsDir, "old-python", UNSUPPORTED_PYTHON_VERSION_MANIFEST("old-python"));
+        const before = dirSnapshot(moldeskHome);
+        const program = buildProgram();
+        await program.parseAsync(["install", "old-python"], { from: "user" });
+        const after = dirSnapshot(moldeskHome);
+        expect(after).toEqual(before);
+        expect(errors.some((e) => e.includes("No files were written."))).toBe(true);
+    });
+    it("--json output is valid JSON for an unsupported install", async () => {
+        writeManifest(modelsDir, "old-python", UNSUPPORTED_PYTHON_VERSION_MANIFEST("old-python"));
+        const program = buildProgram();
+        await program.parseAsync(["install", "old-python", "--json"], { from: "user" });
+        const parsed = JSON.parse(logs.join("\n"));
+        expect(parsed.status).toBe("unsupported");
+        expect(parsed.compatibility.runtimes[0].reasons.some((r) => r.code === "MANAGED_PYTHON_VERSION_UNSUPPORTED")).toBe(true);
+    });
+    it("--json output is valid JSON for a compatible install", async () => {
+        writeManifest(modelsDir, "good-python", CPU_PYTHON_MANIFEST("good-python"));
+        const program = buildProgram();
+        await program.parseAsync(["install", "good-python", "--json"], { from: "user" });
+        const parsed = JSON.parse(logs.join("\n"));
+        expect(parsed.status).toBe("compatible");
+        expect(parsed.compatibility.selectedRuntime).toBe("python");
+    });
+    it("human output includes remediation text per reason", async () => {
+        writeManifest(modelsDir, "old-python", UNSUPPORTED_PYTHON_VERSION_MANIFEST("old-python"));
+        const program = buildProgram();
+        await program.parseAsync(["install", "old-python"], { from: "user" });
+        expect(errors.some((e) => e.includes("MANAGED_PYTHON_VERSION_UNSUPPORTED") && e.includes("Use a manifest requesting one of"))).toBe(true);
+    });
+    it("rejects an unsupported managed Python version manifest", async () => {
+        writeManifest(modelsDir, "old-python", UNSUPPORTED_PYTHON_VERSION_MANIFEST("old-python"));
+        const program = buildProgram();
+        await program.parseAsync(["install", "old-python"], { from: "user" });
+        expect(errors.some((e) => e.includes("MANAGED_PYTHON_VERSION_UNSUPPORTED"))).toBe(true);
+    });
+    it("a docker-gpu-required manifest with unverified GPU access surfaces DOCKER_GPU_UNVERIFIED, not UNAVAILABLE", async () => {
+        writeManifest(modelsDir, "gpu-model", DOCKER_GPU_REQUIRED_MANIFEST("gpu-model"));
+        // A registered nvidia runtime leaves Tier 1 as "unknown" (unverified) rather than
+        // "unavailable" — this is the case a real GPU-capable Docker host would present.
+        state.handler = (cmd, args) => {
+            if (cmd === "docker" && args[0] === "--version")
+                return { code: 0, stdout: "Docker version 24.0.7\n" };
+            if (cmd === "docker" && args[0] === "info")
+                return { code: 0, stdout: JSON.stringify({ Runtimes: { runc: {}, nvidia: {} } }) };
+            if (cmd === "docker" && args[0] === "image")
+                return { code: 1, stderr: "No such image" };
+            return { code: 127, spawnError: true };
+        };
+        const program = buildProgram();
+        // Declined download (no --yes, no interactive stdin in test) -> stays unverified.
+        await program.parseAsync(["install", "gpu-model", "--json"], { from: "user" });
+        const parsed = JSON.parse(logs.join("\n"));
+        expect(parsed.status).toBe("unsupported");
+        const dockerReasons = parsed.compatibility.runtimes[0].reasons.map((r) => r.code);
+        expect(dockerReasons).toContain("DOCKER_GPU_UNVERIFIED");
+        expect(dockerReasons).not.toContain("DOCKER_GPU_UNAVAILABLE");
+    });
+    it("--yes confirms the download and a successful pull+probe transitions the install to compatible", async () => {
+        writeManifest(modelsDir, "gpu-model", DOCKER_GPU_REQUIRED_MANIFEST("gpu-model"));
+        state.handler = (cmd, args) => {
+            if (cmd === "docker" && args[0] === "--version")
+                return { code: 0, stdout: "Docker version 24.0.7\n" };
+            if (cmd === "docker" && args[0] === "info")
+                return { code: 0, stdout: JSON.stringify({ Runtimes: { runc: {}, nvidia: {} } }) };
+            if (cmd === "docker" && args[0] === "image")
+                return { code: 1, stderr: "No such image" }; // not cached
+            if (cmd === "docker" && args[0] === "pull")
+                return { code: 0, stdout: "Status: Downloaded newer image" };
+            if (cmd === "docker" && args[0] === "run")
+                return { code: 0, stdout: "GPU 0: NVIDIA A100" };
+            return { code: 127, spawnError: true };
+        };
+        const program = buildProgram();
+        await program.parseAsync(["install", "gpu-model", "--json", "--yes"], { from: "user" });
+        const parsed = JSON.parse(logs.join("\n"));
+        expect(parsed.status).toBe("compatible");
+        expect(parsed.selectedRuntime).toBe("docker");
+    });
+    it("unknown model prints a message and writes no files", async () => {
+        const before = dirSnapshot(moldeskHome);
+        const program = buildProgram();
+        await program.parseAsync(["install", "does-not-exist"], { from: "user" });
+        expect(dirSnapshot(moldeskHome)).toEqual(before);
+        expect(errors.some((e) => e.includes("Unknown model"))).toBe(true);
+    });
+});

package/dist/commands/list.js

@@ -1,20 +1,72 @@
-import { listAvailableModels, listInstalledModels } from "@moldesk/core";
+import { evaluateCompatibility, getSystemReport, listAvailableModels, listInstalledModels, shortReason, } from "@moldesk/core";
+function parseRuntime(value) {
+    if (value === "python" || value === "docker")
+        return value;
+    console.error(`Invalid --runtime "${value}". Expected python|docker.`);
+    process.exit(1);
+    throw new Error("unreachable");
+}
 export function registerListCommand(program) {
     program
         .command("list")
-        .description("List available and installed models")
-        .action(() => {
-        const available = listAvailableModels();
-        const installed = listInstalledModels();
-        const installedNames = new Set(installed.map((m) => m.name));
-        if (available.length === 0) {
-            console.log("No models found in the registry.");
-            return;
+        .description("List available models with compatibility")
+        .option("--json", "print raw manifests + compatibility results as JSON")
+        .option("--runtime <kind>", "constrain compatibility selection to python|docker")
+        .option("--installed", "show installed models only")
+        .action(async (options) => {
+        try {
+            const requestedRuntime = options.runtime ? parseRuntime(options.runtime) : undefined;
+            const available = listAvailableModels();
+            const installed = listInstalledModels();
+            const installedNames = new Set(installed.map((m) => m.model));
+            if (options.installed) {
+                if (options.json) {
+                    console.log(JSON.stringify({ installed }, null, 2));
+                    return;
+                }
+                if (installed.length === 0) {
+                    console.log("No models installed yet.");
+                    return;
+                }
+                for (const model of installed) {
+                    console.log(`  ${model.model} ${model.modelVersion} (${model.runtime.kind}, ${model.status})`);
+                }
+                return;
+            }
+            if (available.length === 0) {
+                if (options.json) {
+                    console.log(JSON.stringify([], null, 2));
+                    return;
+                }
+                console.log("No models found in the registry.");
+                return;
+            }
+            const report = await getSystemReport();
+            const rows = available.map((manifest) => {
+                const compatibility = evaluateCompatibility(manifest, report, { requestedRuntime });
+                return { manifest, compatibility };
+            });
+            if (options.json) {
+                console.log(JSON.stringify(rows, null, 2));
+                return;
+            }
+            const header = `${"MODEL".padEnd(14)} ${"CATEGORY".padEnd(21)} ${"STATUS".padEnd(11)} COMPATIBILITY`;
+            console.log(header);
+            for (const { manifest, compatibility } of rows) {
+                const installedMark = installedNames.has(manifest.name) ? "*" : " ";
+                const compat = compatibility.status === "compatible"
+                    ? "compatible"
+                    : compatibility.status === "warning"
+                        ? `warning: ${shortReason(compatibility)}`
+                        : manifest.status === "planned"
+                            ? "not installable"
+                            : `unsupported: ${shortReason(compatibility)}`;
+                console.log(`${installedMark}${manifest.name.padEnd(13)} ${manifest.category.padEnd(21)} ${manifest.status.padEnd(11)} ${compat}`);
+            }
         }
-        console.log("Available models:\n");
-        for (const model of available) {
-            const status = installedNames.has(model.name) ? "installed" : "not installed";
-            console.log(`  ${model.name.padEnd(12)} ${model.version.padEnd(10)} ${status}`);
+        catch (error) {
+            console.error(error instanceof Error ? error.message : String(error));
+            process.exitCode = 1;
         }
     });
 }

package/dist/commands/list.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/list.test.js

@@ -0,0 +1,164 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { Command } from "commander";
+import { createFakeSpawn } from "../testSupport/spawnMock.js";
+import { registerListCommand } from "./list.js";
+const state = vi.hoisted(() => ({
+    handler: ((_cmd, _args) => ({ code: 127, spawnError: true })),
+}));
+vi.mock("node:child_process", () => ({
+    spawn: (command, args) => createFakeSpawn((c, a) => state.handler(c, a))(command, args),
+}));
+function writeManifest(modelsDir, name, yaml) {
+    const dir = path.join(modelsDir, name);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(path.join(dir, "manifest.yaml"), yaml);
+}
+const CPU_PYTHON_MANIFEST = (name) => `
+schemaVersion: 1
+name: ${name}
+displayName: Test CPU Model
+modelVersion: "1.0.0"
+adapterVersion: "0.1.0"
+description: test
+category: other
+status: beta
+runtimes:
+  - kind: python
+    python: "3.11"
+    installer: uv
+    requirements:
+      - name: torch
+        version: "2.2.1"
+hardware:
+  platforms: [darwin-arm64, linux-x64]
+input:
+  formats: [".pdb"]
+  required: true
+outputs:
+  - id: out
+    glob: "*.txt"
+    required: true
+`;
+const UNSUPPORTED_PYTHON_VERSION_MANIFEST = (name) => `
+schemaVersion: 1
+name: ${name}
+displayName: Test Old Python Model
+modelVersion: "1.0.0"
+adapterVersion: "0.1.0"
+description: test
+category: other
+status: beta
+runtimes:
+  - kind: python
+    python: "3.8"
+    installer: uv
+    requirements:
+      - name: torch
+        version: "2.2.1"
+hardware:
+  platforms: [darwin-arm64, linux-x64]
+input:
+  formats: [".pdb"]
+  required: true
+outputs:
+  - id: out
+    glob: "*.txt"
+    required: true
+`;
+const DOCKER_GPU_REQUIRED_MANIFEST = (name) => `
+schemaVersion: 1
+name: ${name}
+displayName: Test Docker GPU Model
+modelVersion: "1.0.0"
+adapterVersion: "0.1.0"
+description: test
+category: other
+status: beta
+runtimes:
+  - kind: docker
+    image: example/test:latest
+    digest: "sha256:${"b".repeat(64)}"
+    gpu: required
+hardware:
+  platforms: [darwin-arm64, linux-x64]
+input:
+  formats: [".pdb"]
+  required: true
+outputs:
+  - id: out
+    glob: "*.txt"
+    required: true
+`;
+let modelsDir;
+let logs;
+beforeEach(() => {
+    modelsDir = fs.mkdtempSync(path.join(os.tmpdir(), "moldesk-models-"));
+    process.env["MOLDESK_MODELS_DIR"] = modelsDir;
+    logs = [];
+    vi.spyOn(console, "log").mockImplementation((msg) => {
+        logs.push(String(msg));
+    });
+    vi.spyOn(console, "error").mockImplementation(() => undefined);
+    // Nvidia runtime registered but never explicitly probed/pulled by `list`.
+    state.handler = (cmd, args) => {
+        if (cmd === "docker" && args[0] === "--version")
+            return { code: 0, stdout: "Docker version 24.0.7\n" };
+        if (cmd === "docker" && args[0] === "info")
+            return { code: 0, stdout: JSON.stringify({ Runtimes: { runc: {}, nvidia: {} } }) };
+        if (cmd === "docker")
+            throw new Error(`list must never run/pull docker images (got: ${args.join(" ")})`);
+        return { code: 127, spawnError: true };
+    };
+});
+afterEach(() => {
+    vi.restoreAllMocks();
+    delete process.env["MOLDESK_MODELS_DIR"];
+    fs.rmSync(modelsDir, { recursive: true, force: true });
+});
+function buildProgram() {
+    const program = new Command();
+    program.exitOverride();
+    registerListCommand(program);
+    return program;
+}
+describe("list (real command, faked process boundary only)", () => {
+    it("never runs or pulls a Docker image, even for a docker-gpu-required manifest", async () => {
+        writeManifest(modelsDir, "gpu-model", DOCKER_GPU_REQUIRED_MANIFEST("gpu-model"));
+        const program = buildProgram();
+        await program.parseAsync(["list"], { from: "user" });
+        // The handler above throws if `docker run`/`docker pull` is ever invoked;
+        // reaching this line without a thrown error is the assertion.
+        expect(logs.join("\n")).toContain("gpu-model");
+    });
+    it("--json output is valid JSON and includes a per-runtime breakdown for each row", async () => {
+        writeManifest(modelsDir, "good-python", CPU_PYTHON_MANIFEST("good-python"));
+        writeManifest(modelsDir, "old-python", UNSUPPORTED_PYTHON_VERSION_MANIFEST("old-python"));
+        const program = buildProgram();
+        await program.parseAsync(["list", "--json"], { from: "user" });
+        const rows = JSON.parse(logs.join("\n"));
+        expect(rows).toHaveLength(2);
+        for (const row of rows) {
+            expect(Array.isArray(row.compatibility.runtimes)).toBe(true);
+            expect(row.compatibility.runtimes.length).toBeGreaterThan(0);
+        }
+        const goodRow = rows.find((r) => r.manifest.name === "good-python");
+        const oldRow = rows.find((r) => r.manifest.name === "old-python");
+        expect(goodRow?.compatibility.status).toBe("compatible");
+        expect(oldRow?.compatibility.status).toBe("unsupported");
+    });
+    it("human-mode table's compatibility column matches evaluateCompatibility's status for compatible/unsupported/docker-unverified rows", async () => {
+        writeManifest(modelsDir, "good-python", CPU_PYTHON_MANIFEST("good-python"));
+        writeManifest(modelsDir, "old-python", UNSUPPORTED_PYTHON_VERSION_MANIFEST("old-python"));
+        writeManifest(modelsDir, "gpu-model", DOCKER_GPU_REQUIRED_MANIFEST("gpu-model"));
+        const program = buildProgram();
+        await program.parseAsync(["list"], { from: "user" });
+        const lines = logs.join("\n").split("\n");
+        const line = (name) => lines.find((l) => l.includes(name));
+        expect(line("good-python")).toMatch(/\bcompatible\b/);
+        expect(line("old-python")).toMatch(/unsupported: MANAGED_PYTHON_VERSION_UNSUPPORTED/);
+        expect(line("gpu-model")).toMatch(/unsupported: DOCKER_GPU_UNVERIFIED/);
+    });
+});

package/dist/commands/run.js

@@ -1,9 +1,93 @@
+import { MoldeskError, runModel } from "@moldesk/core";
+function parseRuntime(value) {
+    if (value === "python" || value === "docker")
+        return value;
+    console.error(`Invalid --runtime "${value}". Expected python|docker.`);
+    process.exit(2);
+    throw new Error("unreachable");
+}
+function collectParam(value, previous) {
+    const eq = value.indexOf("=");
+    if (eq <= 0) {
+        console.error(`Invalid --param "${value}". Expected key=value.`);
+        process.exit(2);
+    }
+    return { ...previous, [value.slice(0, eq)]: value.slice(eq + 1) };
+}
+/**
+ * Maps `MoldeskError.code` for usage errors thrown *before* a run directory is
+ * allocated (spec §4.2 steps 1-3). Run outcomes (succeeded/failed/cancelled)
+ * never throw — their exit code (0/7/8) comes from `result.status` instead.
+ */
+const EXIT_CODES = {
+    UNKNOWN_MODEL: 3,
+    ADAPTER_NOT_FOUND: 3,
+    MODEL_NOT_INSTALLED: 5,
+    INVALID_RUN_PARAMS: 2,
+    INVALID_RUN_INPUT: 2,
+    RUN_RUNTIME_SELECTION_REQUIRED: 2,
+    RUNTIME_EXECUTION_UNSUPPORTED: 4,
+};
+function exitCodeFor(error) {
+    if (error instanceof MoldeskError && error.code in EXIT_CODES)
+        return EXIT_CODES[error.code];
+    return 10;
+}
 export function registerRunCommand(program) {
     program
         .command("run <model> <input>")
-        .description("Run a model against an input file (coming soon)")
-        .action((model, input) => {
-        console.log(`Running "${model}" on "${input}" is not yet supported.`);
-        console.log("Track progress at https://github.com/pooriyapfn/moldesk");
+        .description("Run a model against an input file")
+        .option("--output <directory>", "copy declared outputs to this directory")
+        .option("--runtime <kind>", "select runtime python|docker (no silent fallback)")
+        .option("--param <key=value>", "set a model parameter (repeatable)", collectParam, {})
+        .option("--json", "print the run result as JSON")
+        .action(async (model, input, options) => {
+        const runtime = options.runtime ? parseRuntime(options.runtime) : undefined;
+        const controller = new AbortController();
+        const onSignal = () => controller.abort();
+        process.once("SIGINT", onSignal);
+        process.once("SIGTERM", onSignal);
+        try {
+            const result = await runModel(model, input, {
+                runtime,
+                params: options.param,
+                outputDir: options.output,
+                signal: controller.signal,
+                onLog: options.json
+                    ? undefined
+                    : (stream, chunk) => (stream === "stdout" ? process.stdout : process.stderr).write(chunk),
+            });
+            if (options.json) {
+                console.log(JSON.stringify({ model, ...result }, null, 2));
+            }
+            else {
+                console.log(`${result.record.model}: ${result.status}.`);
+                for (const output of result.record.outputs)
+                    console.log(`  ${output.id}: ${output.path}`);
+                if (result.record.error)
+                    console.error(`  ${result.record.error.code}: ${result.record.error.message}`);
+                if (result.exportError)
+                    console.error(`  --output copy failed: ${result.exportError.message}`);
+                console.log(`  Run directory: ${result.record.command.cwd}`);
+            }
+            if (result.status === "cancelled")
+                process.exitCode = 8;
+            else if (result.status === "failed" || result.exportError)
+                process.exitCode = 7;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (options.json) {
+                console.log(JSON.stringify({ model, status: "error", message, code: error instanceof MoldeskError ? error.code : undefined }, null, 2));
+            }
+            else {
+                console.error(message);
+            }
+            process.exitCode = exitCodeFor(error);
+        }
+        finally {
+            process.removeListener("SIGINT", onSignal);
+            process.removeListener("SIGTERM", onSignal);
+        }
     });
 }

package/dist/commands/run.test.d.ts

@@ -0,0 +1 @@
+export {};