@moldesk/cli 0.0.1 → 0.0.3

package/dist/commands/run.test.js

@@ -0,0 +1,136 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { Command } from "commander";
+import { registerRunCommand } from "./run.js";
+const state = vi.hoisted(() => ({ runModel: vi.fn() }));
+vi.mock("@moldesk/core", async (importOriginal) => {
+    const actual = await importOriginal();
+    return { ...actual, runModel: state.runModel };
+});
+class ProcessExitSignal extends Error {
+    code;
+    constructor(code) {
+        super(`process.exit(${code})`);
+        this.code = code;
+    }
+}
+function buildProgram() {
+    const program = new Command();
+    program.exitOverride();
+    registerRunCommand(program);
+    return program;
+}
+const baseRecord = {
+    schemaVersion: 1,
+    id: "run-1",
+    status: "succeeded",
+    model: "proteinmpnn",
+    modelVersion: "v_48_020",
+    adapterVersion: "0.1.0",
+    moldeskVersion: "0.0.1",
+    runtime: "python",
+    installationFingerprint: "python-abc",
+    manifestSha256: "abc",
+    hardware: {},
+    input: [],
+    parameters: { supplied: {}, effective: {} },
+    command: { executable: "python", args: [], cwd: "/runs/run-1" },
+    startedAt: new Date().toISOString(),
+    outputs: [],
+    logs: { stdout: "/runs/run-1/stdout.log", stderr: "/runs/run-1/stderr.log" },
+};
+let logs;
+let errors;
+beforeEach(() => {
+    logs = [];
+    errors = [];
+    process.exitCode = undefined;
+    vi.spyOn(console, "log").mockImplementation((msg) => {
+        logs.push(String(msg));
+    });
+    vi.spyOn(console, "error").mockImplementation((msg) => {
+        errors.push(String(msg));
+    });
+    state.runModel.mockReset();
+});
+afterEach(() => {
+    vi.restoreAllMocks();
+    process.exitCode = undefined;
+});
+describe("run (CLI, faked runModel)", () => {
+    it("prints the run record as JSON and leaves exit code 0 on success", async () => {
+        state.runModel.mockResolvedValue({ status: "succeeded", record: baseRecord });
+        const program = buildProgram();
+        await program.parseAsync(["run", "proteinmpnn", "input.pdb", "--json"], { from: "user" });
+        const parsed = JSON.parse(logs.join("\n"));
+        expect(parsed.status).toBe("succeeded");
+        expect(process.exitCode).toBeUndefined();
+    });
+    it("sets exit code 7 when the run failed", async () => {
+        state.runModel.mockResolvedValue({
+            status: "failed",
+            record: { ...baseRecord, status: "failed", error: { code: "RUN_EXECUTION_FAILED", message: "exit 1" } },
+        });
+        const program = buildProgram();
+        await program.parseAsync(["run", "proteinmpnn", "input.pdb", "--json"], { from: "user" });
+        expect(process.exitCode).toBe(7);
+    });
+    it("sets exit code 8 when the run was cancelled", async () => {
+        state.runModel.mockResolvedValue({
+            status: "cancelled",
+            record: { ...baseRecord, status: "cancelled", error: { code: "RUN_CANCELLED", message: "cancelled" } },
+        });
+        const program = buildProgram();
+        await program.parseAsync(["run", "proteinmpnn", "input.pdb", "--json"], { from: "user" });
+        expect(process.exitCode).toBe(8);
+    });
+    it("sets exit code 7 for a succeeded run whose --output copy collided", async () => {
+        state.runModel.mockResolvedValue({
+            status: "succeeded",
+            record: baseRecord,
+            exportError: { code: "OUTPUT_COLLISION", message: "already exists" },
+        });
+        const program = buildProgram();
+        await program.parseAsync(["run", "proteinmpnn", "input.pdb", "--output", "/tmp/out", "--json"], { from: "user" });
+        expect(process.exitCode).toBe(7);
+        const parsed = JSON.parse(logs.join("\n"));
+        expect(parsed.status).toBe("succeeded");
+    });
+    it("maps a thrown UNKNOWN_MODEL error to exit code 3", async () => {
+        const { MoldeskError } = await import("@moldesk/core");
+        state.runModel.mockRejectedValue(new MoldeskError({ code: "UNKNOWN_MODEL", message: 'Unknown model "bogus".' }));
+        const program = buildProgram();
+        await program.parseAsync(["run", "bogus", "input.pdb", "--json"], { from: "user" });
+        expect(process.exitCode).toBe(3);
+        const parsed = JSON.parse(logs.join("\n"));
+        expect(parsed.code).toBe("UNKNOWN_MODEL");
+    });
+    it("maps a thrown MODEL_NOT_INSTALLED error to exit code 5", async () => {
+        const { MoldeskError } = await import("@moldesk/core");
+        state.runModel.mockRejectedValue(new MoldeskError({ code: "MODEL_NOT_INSTALLED", message: "not installed" }));
+        const program = buildProgram();
+        await program.parseAsync(["run", "proteinmpnn", "input.pdb"], { from: "user" });
+        expect(process.exitCode).toBe(5);
+        expect(errors.some((e) => e.includes("not installed"))).toBe(true);
+    });
+    it("maps an unrecognized thrown error to exit code 10", async () => {
+        state.runModel.mockRejectedValue(new Error("boom"));
+        const program = buildProgram();
+        await program.parseAsync(["run", "proteinmpnn", "input.pdb"], { from: "user" });
+        expect(process.exitCode).toBe(10);
+    });
+    it("forwards --param key=value pairs to runModel", async () => {
+        state.runModel.mockResolvedValue({ status: "succeeded", record: baseRecord });
+        const program = buildProgram();
+        await program.parseAsync(["run", "proteinmpnn", "input.pdb", "--param", "seed=1", "--param", "ca_only=true", "--json"], { from: "user" });
+        expect(state.runModel).toHaveBeenCalledWith("proteinmpnn", "input.pdb", expect.objectContaining({ params: { seed: "1", ca_only: "true" } }));
+    });
+    it("rejects a malformed --param with a usage error (exit 2) before calling runModel", async () => {
+        const exitSpy = vi.spyOn(process, "exit").mockImplementation((code) => {
+            throw new ProcessExitSignal(typeof code === "number" ? code : undefined);
+        });
+        const program = buildProgram();
+        await expect(program.parseAsync(["run", "proteinmpnn", "input.pdb", "--param", "no-equals-sign"], { from: "user" })).rejects.toThrow(ProcessExitSignal);
+        expect(exitSpy).toHaveBeenCalledWith(2);
+        expect(state.runModel).not.toHaveBeenCalled();
+    });
+});

package/dist/commands/uninstall.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerUninstallCommand(program: Command): void;

package/dist/commands/uninstall.js

@@ -0,0 +1,65 @@
+import { createInterface } from "node:readline/promises";
+import { uninstallModel } from "@moldesk/core";
+function parseRuntime(value) {
+    if (value === "python" || value === "docker")
+        return value;
+    throw new Error(`Invalid --runtime "${value}". Expected python|docker.`);
+}
+async function confirmUninstall(model) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY)
+        return false;
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const answer = await rl.question(`Uninstall ${model} and its isolated environments? [y/N] `);
+        return /^y(es)?$/i.test(answer.trim());
+    }
+    finally {
+        rl.close();
+    }
+}
+export function registerUninstallCommand(program) {
+    program
+        .command("uninstall <model>")
+        .description("Remove a model's managed installations (shared download cache is retained)")
+        .option("--runtime <kind>", "remove only the selected python|docker runtime")
+        .option("--all", "remove every installed runtime variant")
+        .option("--yes", "uninstall without prompting")
+        .option("--json", "print result as JSON")
+        .action(async (model, options) => {
+        if (options.runtime && options.all) {
+            const message = "Use either --runtime or --all, not both.";
+            if (options.json)
+                console.log(JSON.stringify({ model, status: "failed", message }, null, 2));
+            else
+                console.error(message);
+            process.exitCode = 1;
+            return;
+        }
+        if (!options.yes && !await confirmUninstall(model)) {
+            if (options.json)
+                console.log(JSON.stringify({ model, status: "cancelled" }, null, 2));
+            else
+                console.log("Uninstall cancelled. Re-run with --yes for non-interactive use.");
+            return;
+        }
+        try {
+            const removed = await uninstallModel(model, {
+                runtime: options.runtime ? parseRuntime(options.runtime) : undefined,
+                all: options.all,
+            });
+            const status = removed.length > 0 ? "uninstalled" : "not-installed";
+            if (options.json)
+                console.log(JSON.stringify({ model, status, removed }, null, 2));
+            else
+                console.log(removed.length > 0 ? `${model}: uninstalled ${removed.length} environment(s).` : `${model} is not installed.`);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (options.json)
+                console.log(JSON.stringify({ model, status: "failed", message }, null, 2));
+            else
+                console.error(`Uninstall failed: ${message}`);
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/index.js

@@ -5,6 +5,7 @@ import { registerDoctorCommand } from "./commands/doctor.js";
 import { registerListCommand } from "./commands/list.js";
 import { registerInstallCommand } from "./commands/install.js";
 import { registerRunCommand } from "./commands/run.js";
+import { registerUninstallCommand } from "./commands/uninstall.js";
 const program = new Command();
 program
     .name("moldesk")
@@ -13,5 +14,6 @@ program
 registerDoctorCommand(program);
 registerListCommand(program);
 registerInstallCommand(program);
+registerUninstallCommand(program);
 registerRunCommand(program);
 program.parse();

package/dist/testSupport/spawnMock.d.ts

@@ -0,0 +1,21 @@
+import { EventEmitter } from "node:events";
+export interface FakeSpawnResult {
+    code?: number;
+    stdout?: string;
+    stderr?: string;
+    /** Simulate `spawn` itself failing (command not on PATH) instead of the process exiting non-zero. */
+    spawnError?: boolean;
+}
+export type FakeSpawnHandler = (command: string, args: string[]) => FakeSpawnResult;
+/**
+ * Minimal fake `child_process.ChildProcess` good enough for
+ * `packages/runtime/src/process/index.ts`'s `runCommand` — stdout/stderr
+ * event emitters plus `error`/`close`. Used to fake the process boundary
+ * (docker/nvidia-smi/nvcc/python3/which) in CLI-level tests without mocking
+ * `@moldesk/core` itself.
+ */
+export declare function createFakeSpawn(handler: FakeSpawnHandler): (command: string, args: string[]) => EventEmitter<[never]> & {
+    stdout: EventEmitter;
+    stderr: EventEmitter;
+    kill: () => void;
+};

package/dist/testSupport/spawnMock.js

@@ -0,0 +1,29 @@
+import { EventEmitter } from "node:events";
+/**
+ * Minimal fake `child_process.ChildProcess` good enough for
+ * `packages/runtime/src/process/index.ts`'s `runCommand` — stdout/stderr
+ * event emitters plus `error`/`close`. Used to fake the process boundary
+ * (docker/nvidia-smi/nvcc/python3/which) in CLI-level tests without mocking
+ * `@moldesk/core` itself.
+ */
+export function createFakeSpawn(handler) {
+    return (command, args) => {
+        const child = new EventEmitter();
+        child.stdout = new EventEmitter();
+        child.stderr = new EventEmitter();
+        child.kill = () => undefined;
+        const result = handler(command, args);
+        queueMicrotask(() => {
+            if (result.spawnError) {
+                child.emit("error", new Error("spawn ENOENT"));
+                return;
+            }
+            if (result.stdout)
+                child.stdout.emit("data", Buffer.from(result.stdout));
+            if (result.stderr)
+                child.stderr.emit("data", Buffer.from(result.stderr));
+            child.emit("close", result.code ?? 0);
+        });
+        return child;
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moldesk/cli",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "MoleculeDesk CLI — install and run computational biology models",
   "license": "MIT",
   "type": "module",
@@ -21,16 +21,18 @@
   ],
   "dependencies": {
     "commander": "^12.1.0",
-    "@moldesk/core": "0.0.1"
+    "@moldesk/core": "0.0.3"
   },
   "devDependencies": {
     "typescript": "^5.6.3",
     "tsx": "^4.19.1",
-    "@types/node": "^20.16.11"
+    "@types/node": "^20.16.11",
+    "vitest": "^3.0.0"
   },
   "scripts": {
     "dev": "tsx src/index.ts",
     "build": "tsc -p tsconfig.json",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
   }
 }