@moldesk/cli 0.0.3 → 0.0.5

package/dist/commands/run.js

@@ -1,3 +1,4 @@
+import { pathToFileURL } from "node:url";
 import { MoldeskError, runModel } from "@moldesk/core";
 function parseRuntime(value) {
     if (value === "python" || value === "docker")
@@ -40,6 +41,7 @@ export function registerRunCommand(program) {
         .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("--no-visualize", "skip creating the offline molecular report")
         .option("--json", "print the run result as JSON")
         .action(async (model, input, options) => {
         const runtime = options.runtime ? parseRuntime(options.runtime) : undefined;
@@ -52,6 +54,7 @@ export function registerRunCommand(program) {
                 runtime,
                 params: options.param,
                 outputDir: options.output,
+                visualize: options.visualize,
                 signal: controller.signal,
                 onLog: options.json
                     ? undefined
@@ -64,6 +67,12 @@ export function registerRunCommand(program) {
                 console.log(`${result.record.model}: ${result.status}.`);
                 for (const output of result.record.outputs)
                     console.log(`  ${output.id}: ${output.path}`);
+                for (const artifact of result.record.artifacts ?? []) {
+                    console.log(`  report: ${artifact.path}`);
+                    console.log(`  Open in your browser: ${pathToFileURL(artifact.path).href}`);
+                }
+                for (const warning of result.record.warnings ?? [])
+                    console.error(`  Warning (${warning.code}): ${warning.message}`);
                 if (result.record.error)
                     console.error(`  ${result.record.error.code}: ${result.record.error.message}`);
                 if (result.exportError)

package/dist/commands/run.test.js

@@ -133,4 +133,35 @@ describe("run (CLI, faked runModel)", () => {
         expect(exitSpy).toHaveBeenCalledWith(2);
         expect(state.runModel).not.toHaveBeenCalled();
     });
+    it("defaults to visualizing and maps --no-visualize to visualize: false", async () => {
+        state.runModel.mockResolvedValue({ status: "succeeded", record: baseRecord });
+        await buildProgram().parseAsync(["run", "boltz", "job.yaml", "--json"], { from: "user" });
+        expect(state.runModel).toHaveBeenLastCalledWith("boltz", "job.yaml", expect.objectContaining({ visualize: true }));
+        await buildProgram().parseAsync(["run", "boltz", "job.yaml", "--no-visualize", "--json"], { from: "user" });
+        expect(state.runModel).toHaveBeenLastCalledWith("boltz", "job.yaml", expect.objectContaining({ visualize: false }));
+    });
+    it("prints the report path and an encoded file URL, and a warning keeps exit code 0", async () => {
+        state.runModel.mockResolvedValue({
+            status: "succeeded",
+            record: {
+                ...baseRecord,
+                artifacts: [{ id: "molecular-report", kind: "molecular-report", path: "/runs/my run/artifacts/viewer.html", sha256: "a", sizeBytes: 1, sourceSha256: [], viewerVersion: "1", bundleSha256: "b" }],
+                warnings: [{ code: "VISUALIZATION_FAILED", message: "Could not create the molecular report: boom" }],
+            },
+        });
+        await buildProgram().parseAsync(["run", "boltz", "job.yaml"], { from: "user" });
+        expect(logs).toContain("  report: /runs/my run/artifacts/viewer.html");
+        expect(logs).toContain("  Open in your browser: file:///runs/my%20run/artifacts/viewer.html");
+        expect(errors.join("\n")).toContain("Warning (VISUALIZATION_FAILED): Could not create the molecular report: boom");
+        expect(process.exitCode).toBeUndefined();
+    });
+    it("keeps --json parseable with artifacts and warnings present", async () => {
+        state.runModel.mockResolvedValue({
+            status: "succeeded",
+            record: { ...baseRecord, warnings: [{ code: "VISUALIZATION_FAILED", message: "x" }] },
+        });
+        await buildProgram().parseAsync(["run", "boltz", "job.yaml", "--json"], { from: "user" });
+        expect(JSON.parse(logs.join("\n")).record.warnings[0].code).toBe("VISUALIZATION_FAILED");
+        expect(errors).toEqual([]);
+    });
 });

package/dist/commands/view.d.ts

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

package/dist/commands/view.js

@@ -0,0 +1,50 @@
+import { createStandaloneReport, openInBrowser } from "@moldesk/core";
+import { reportFailure } from "../utils/report-errors.js";
+export function registerViewCommand(program) {
+    program
+        .command("view <file>")
+        .description("Create an offline, interactive 3D report for a PDB or mmCIF file")
+        .option("--output <file>", "write the report to this file (must not exist)")
+        .option("--open", "open the report in your default browser")
+        .option("--json", "print the result as JSON")
+        .action(async (file, options) => {
+        const controller = new AbortController();
+        const onSignal = () => controller.abort();
+        process.once("SIGINT", onSignal);
+        process.once("SIGTERM", onSignal);
+        try {
+            const result = await createStandaloneReport(file, {
+                outputPath: options.output,
+                signal: controller.signal,
+            });
+            const warnings = [];
+            let opened;
+            if (options.open) {
+                const outcome = await openInBrowser(result.path);
+                opened = outcome.opened;
+                if (!outcome.opened) {
+                    warnings.push({
+                        code: "OPEN_FAILED",
+                        message: `Could not open a browser: ${outcome.error ?? "unknown error"}. The report was saved.`,
+                    });
+                }
+            }
+            if (options.json) {
+                console.log(JSON.stringify({ status: "created", ...result, ...(opened === undefined ? {} : { opened }), warnings }, null, 2));
+            }
+            else {
+                console.log(`Report created: ${result.path}`);
+                console.log(`Open in your browser: ${result.fileUrl}`);
+                for (const w of warnings)
+                    console.error(`Warning: ${w.message}`);
+            }
+        }
+        catch (error) {
+            reportFailure(error, options.json);
+        }
+        finally {
+            process.removeListener("SIGINT", onSignal);
+            process.removeListener("SIGTERM", onSignal);
+        }
+    });
+}

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

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

package/dist/commands/view.test.js

@@ -0,0 +1,93 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { Command } from "commander";
+import { registerViewCommand } from "./view.js";
+const state = vi.hoisted(() => ({ open: vi.fn() }));
+vi.mock("@moldesk/core", async (importOriginal) => {
+    const actual = await importOriginal();
+    return { ...actual, openInBrowser: state.open };
+});
+const PDB = "ATOM      1  N   ALA A   1      11.104  13.207   2.100  1.00 20.00           N\n";
+let dir;
+let out;
+let err;
+beforeEach(() => {
+    dir = fs.mkdtempSync(path.join(os.tmpdir(), "moldesk-cli-view-"));
+    process.env.MOLDESK_HOME = path.join(dir, "home");
+    out = [];
+    err = [];
+    vi.spyOn(console, "log").mockImplementation((...a) => void out.push(a.join(" ")));
+    vi.spyOn(console, "error").mockImplementation((...a) => void err.push(a.join(" ")));
+    process.exitCode = undefined;
+    state.open.mockReset();
+});
+afterEach(() => {
+    vi.restoreAllMocks();
+    delete process.env.MOLDESK_HOME;
+    process.exitCode = undefined;
+    fs.rmSync(dir, { recursive: true, force: true });
+});
+async function run(...args) {
+    const program = new Command();
+    program.exitOverride();
+    registerViewCommand(program);
+    await program.parseAsync(args, { from: "user" });
+}
+const structure = (name = "p.pdb") => {
+    const p = path.join(dir, name);
+    fs.writeFileSync(p, PDB);
+    return p;
+};
+describe("view", () => {
+    it("prints the path and an encoded file URL, and does not open a browser by default", async () => {
+        const weird = path.join(dir, "my protein #1.pdb");
+        fs.writeFileSync(weird, PDB);
+        await run("view", weird, "--output", path.join(dir, "r e p.html"));
+        expect(out[0]).toContain(path.join(dir, "r e p.html"));
+        expect(out[1]).toContain("file://");
+        expect(out[1]).toContain("r%20e%20p.html");
+        expect(state.open).not.toHaveBeenCalled();
+        expect(process.exitCode).toBeUndefined();
+    });
+    it("emits exactly one JSON object on stdout", async () => {
+        await run("view", structure(), "--json", "--output", path.join(dir, "j.html"));
+        expect(out).toHaveLength(1);
+        const parsed = JSON.parse(out[0]);
+        expect(parsed).toMatchObject({ status: "created", format: "pdb", warnings: [] });
+        expect(parsed.sha256).toMatch(/^[0-9a-f]{64}$/);
+        expect(err).toEqual([]);
+    });
+    it("passes the report path to the opener and succeeds", async () => {
+        state.open.mockResolvedValue({ opened: true });
+        const target = path.join(dir, "o.html");
+        await run("view", structure(), "--open", "--output", target, "--json");
+        expect(state.open).toHaveBeenCalledWith(target);
+        expect(JSON.parse(out[0]).opened).toBe(true);
+    });
+    it("keeps the report and exit 0 when opening fails", async () => {
+        state.open.mockResolvedValue({ opened: false, error: "no display" });
+        const target = path.join(dir, "w.html");
+        await run("view", structure(), "--open", "--output", target);
+        expect(fs.existsSync(target)).toBe(true);
+        expect(err.join("\n")).toContain("no display");
+        expect(process.exitCode).toBeUndefined();
+    });
+    it.each([
+        ["bad extension", () => structure("a.txt"), 2],
+        ["missing file", () => path.join(dir, "missing.pdb"), 2],
+        ["URL", () => "https://x.test/a.pdb", 2],
+    ])("exits 2 for %s", async (_n, make, code) => {
+        await run("view", make(), "--json");
+        expect(JSON.parse(out[0])).toMatchObject({ status: "error", code: "INVALID_VIEW_INPUT" });
+        expect(process.exitCode).toBe(code);
+    });
+    it("refuses to overwrite --output with exit 2", async () => {
+        const target = path.join(dir, "exists.html");
+        fs.writeFileSync(target, "keep");
+        await run("view", structure(), "--output", target);
+        expect(fs.readFileSync(target, "utf8")).toBe("keep");
+        expect(process.exitCode).toBe(2);
+    });
+});

package/dist/commands/visualizer.d.ts

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

package/dist/commands/visualizer.js

@@ -0,0 +1,109 @@
+import { createInterface } from "node:readline/promises";
+import path from "node:path";
+import { applyReportUpdate, openInBrowser, prepareReportUpdate } from "@moldesk/core";
+import { reportFailure } from "../utils/report-errors.js";
+async function confirmUpdate(lines) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const answer = await rl.question(`${lines.join("\n")}\n\nContinue? [y/N] `);
+        return /^y(es)?$/i.test(answer.trim());
+    }
+    finally {
+        rl.close();
+    }
+}
+export function registerVisualizerCommand(program) {
+    const visualizer = program.command("visualizer").description("Manage offline molecular reports");
+    visualizer
+        .command("update <report>")
+        .description("Replace a report's viewer with the one installed with MoleculeDesk")
+        .option("--output <file>", "save the updated report as a separate file instead of replacing the original")
+        .option("--open", "open the report in your default browser afterwards")
+        .option("--yes", "confirm without prompting")
+        .option("--json", "print the result as JSON")
+        .action(async (report, options) => {
+        try {
+            await update(report, options);
+        }
+        catch (error) {
+            reportFailure(error, options.json);
+        }
+    });
+}
+async function update(report, options) {
+    const emit = (value, text, errText = []) => {
+        if (options.json)
+            console.log(JSON.stringify(value, null, 2));
+        else {
+            for (const line of text)
+                console.log(line);
+            for (const line of errText)
+                console.error(line);
+        }
+    };
+    const openIfRequested = async (file) => {
+        if (!options.open)
+            return { warnings: [] };
+        const outcome = await openInBrowser(file);
+        return outcome.opened
+            ? { opened: true, warnings: [] }
+            : {
+                opened: false,
+                warnings: [{ code: "OPEN_FAILED", message: `Could not open a browser: ${outcome.error ?? "unknown error"}. The report is at ${file}.` }],
+            };
+    };
+    const plan = await prepareReportUpdate(report, { outputPath: options.output });
+    const target = plan.targetPath;
+    if (plan.status === "unsupported") {
+        emit({ status: "unsupported", path: target, reason: plan.reason }, [], ["Your installed MoleculeDesk cannot update this report. Your report has not been changed."]);
+        process.exitCode = 2;
+        return;
+    }
+    if (plan.status === "noop" && options.output === undefined) {
+        const { opened, warnings } = await openIfRequested(target);
+        emit({ status: "up-to-date", path: target, viewerVersion: plan.toViewerVersion, bundleSha256: plan.toBundleSha256, ...(opened === undefined ? {} : { opened }), warnings }, ["This report already uses your current viewer."], warnings.map((w) => `Warning: ${w.message}`));
+        return;
+    }
+    if (!options.yes) {
+        if (options.json || !process.stdin.isTTY || !process.stdout.isTTY) {
+            emit({ status: "confirmation-required", path: target, message: "Re-run with --yes to confirm." }, [], ["Confirmation is required to update this report. Re-run with --yes to confirm."]);
+            process.exitCode = 2;
+            return;
+        }
+        const lines = [
+            "Update this report’s viewer?",
+            "",
+            `Report: ${target}`,
+            ...(plan.outputPath === undefined ? [] : [`Save as: ${plan.outputPath}`]),
+            "",
+            "Your structures and results will stay unchanged.",
+            plan.outputPath === undefined
+                ? "A backup of your current report will be saved."
+                : "Your updated report will be saved as a separate file.",
+        ];
+        if (!(await confirmUpdate(lines))) {
+            emit({ status: "cancelled", path: target }, ["Cancelled. Your report has not been changed."]);
+            return;
+        }
+    }
+    const result = await applyReportUpdate(plan);
+    const { opened, warnings } = await openIfRequested(result.path);
+    const text = result.backupPath !== undefined
+        ? ["Viewer updated. Refresh your report to see the changes.", `Backup saved: ${result.backupPath}`]
+        : [
+            result.status === "updated" ? "Viewer updated." : "Report saved.",
+            `Saved: ${path.resolve(result.path)}`,
+        ];
+    emit({
+        status: result.status,
+        path: result.path,
+        ...(result.backupPath === undefined ? {} : { backupPath: result.backupPath }),
+        sha256: result.sha256,
+        sizeBytes: result.sizeBytes,
+        payloadSha256: result.payloadSha256,
+        viewerVersion: result.viewerVersion,
+        bundleSha256: result.bundleSha256,
+        ...(opened === undefined ? {} : { opened }),
+        warnings,
+    }, text, warnings.map((w) => `Warning: ${w.message}`));
+}

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

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

package/dist/commands/visualizer.test.js

@@ -0,0 +1,171 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { Command } from "commander";
+import { registerViewCommand } from "./view.js";
+import { registerVisualizerCommand } from "./visualizer.js";
+const state = vi.hoisted(() => ({ answer: "n", questions: [], open: vi.fn() }));
+vi.mock("node:readline/promises", () => ({
+    createInterface: () => ({
+        question: async (q) => {
+            state.questions.push(q);
+            return state.answer;
+        },
+        close: () => undefined,
+    }),
+}));
+vi.mock("@moldesk/core", async (importOriginal) => {
+    const actual = await importOriginal();
+    return { ...actual, openInBrowser: state.open };
+});
+const PDB = "ATOM      1  N   ALA A   1      11.104  13.207   2.100  1.00 20.00           N\n";
+let dir;
+let out;
+let err;
+let report;
+function setTty(value) {
+    Object.defineProperty(process.stdin, "isTTY", { value, configurable: true });
+    Object.defineProperty(process.stdout, "isTTY", { value, configurable: true });
+}
+async function run(...args) {
+    const program = new Command();
+    program.exitOverride();
+    registerViewCommand(program);
+    registerVisualizerCommand(program);
+    await program.parseAsync(args, { from: "user" });
+}
+/** A report whose HTML no longer equals the trusted reconstruction (as an older/other build would). */
+function makeStale(file) {
+    fs.writeFileSync(file, fs.readFileSync(file, "utf8").replace("<body>", "<body><!-- older viewer -->"));
+}
+beforeEach(async () => {
+    dir = fs.mkdtempSync(path.join(os.tmpdir(), "moldesk-cli-update-"));
+    process.env.MOLDESK_HOME = path.join(dir, "home");
+    fs.writeFileSync(path.join(dir, "p.pdb"), PDB);
+    report = path.join(dir, "report.html");
+    out = [];
+    err = [];
+    vi.spyOn(console, "log").mockImplementation((...a) => void out.push(a.join(" ")));
+    vi.spyOn(console, "error").mockImplementation((...a) => void err.push(a.join(" ")));
+    await run("view", path.join(dir, "p.pdb"), "--output", report);
+    out.length = 0;
+    err.length = 0;
+    process.exitCode = undefined;
+    state.answer = "n";
+    state.questions = [];
+    state.open.mockReset();
+    setTty(false);
+});
+afterEach(() => {
+    vi.restoreAllMocks();
+    delete process.env.MOLDESK_HOME;
+    process.exitCode = undefined;
+    fs.rmSync(dir, { recursive: true, force: true });
+});
+const backups = () => fs.readdirSync(dir).filter((n) => n.includes("backup"));
+describe("visualizer update", () => {
+    it("is a successful no-op with no prompt when the viewer already matches", async () => {
+        const before = fs.readFileSync(report);
+        await run("visualizer", "update", report);
+        expect(out).toEqual(["This report already uses your current viewer."]);
+        expect(state.questions).toEqual([]);
+        expect(fs.readFileSync(report).equals(before)).toBe(true);
+        expect(backups()).toEqual([]);
+        expect(process.exitCode).toBeUndefined();
+    });
+    it.each([
+        ["no TTY", false, []],
+        ["--json even with a TTY", true, ["--json"]],
+    ])("requires --yes: %s", async (_n, tty, extra) => {
+        makeStale(report);
+        const before = fs.readFileSync(report);
+        setTty(tty);
+        await run("visualizer", "update", report, ...extra);
+        expect(process.exitCode).toBe(2);
+        expect(state.questions).toEqual([]);
+        expect(fs.readFileSync(report).equals(before)).toBe(true);
+        expect(backups()).toEqual([]);
+        if (extra.length)
+            expect(JSON.parse(out[0]).status).toBe("confirmation-required");
+    });
+    it("updates with --yes, keeps a backup of the original bytes, and prints the success text", async () => {
+        makeStale(report);
+        const before = fs.readFileSync(report);
+        await run("visualizer", "update", report, "--yes");
+        expect(out[0]).toBe("Viewer updated. Refresh your report to see the changes.");
+        expect(out[1]).toMatch(/^Backup saved: .*report\.backup\.html$/);
+        expect(fs.readFileSync(path.join(dir, "report.backup.html")).equals(before)).toBe(true);
+        expect(fs.readFileSync(report, "utf8")).not.toContain("older viewer");
+        expect(process.exitCode).toBeUndefined();
+    });
+    it("asks the documented question and proceeds on y", async () => {
+        makeStale(report);
+        setTty(true);
+        state.answer = "y";
+        await run("visualizer", "update", report);
+        const q = state.questions[0];
+        expect(q).toContain("Update this report’s viewer?");
+        expect(q).toContain(`Report: ${report}`);
+        expect(q).toContain("Your structures and results will stay unchanged.");
+        expect(q).toContain("A backup of your current report will be saved.");
+        expect(q).toContain("Continue? [y/N]");
+        expect(backups()).toHaveLength(1);
+    });
+    it("treats a declined confirmation as a successful no-op", async () => {
+        makeStale(report);
+        const before = fs.readFileSync(report);
+        setTty(true);
+        state.answer = "n";
+        await run("visualizer", "update", report);
+        expect(out.join("\n")).toContain("Cancelled");
+        expect(fs.readFileSync(report).equals(before)).toBe(true);
+        expect(backups()).toEqual([]);
+        expect(process.exitCode).toBeUndefined();
+    });
+    it("--output saves a separate file, leaves the original alone, and changes the prompt wording", async () => {
+        makeStale(report);
+        const before = fs.readFileSync(report);
+        const target = path.join(dir, "updated.html");
+        setTty(true);
+        state.answer = "yes";
+        await run("visualizer", "update", report, "--output", target);
+        expect(state.questions[0]).toContain("Your updated report will be saved as a separate file.");
+        expect(state.questions[0]).toContain(`Save as: ${target}`);
+        expect(state.questions[0]).not.toContain("backup");
+        expect(fs.readFileSync(report).equals(before)).toBe(true);
+        expect(fs.readFileSync(target, "utf8")).not.toContain("older viewer");
+        expect(backups()).toEqual([]);
+    });
+    it("copies on no-op with --output after confirmation, and never overwrites an existing --output", async () => {
+        const target = path.join(dir, "copy.html");
+        await run("visualizer", "update", report, "--output", target, "--yes");
+        expect(fs.readFileSync(target).equals(fs.readFileSync(report))).toBe(true);
+        process.exitCode = undefined;
+        await run("visualizer", "update", report, "--output", target, "--yes");
+        expect(process.exitCode).toBe(2);
+    });
+    it("rejects ordinary HTML and unsupported input with exit 2, unchanged", async () => {
+        const plain = path.join(dir, "plain.html");
+        fs.writeFileSync(plain, "<html><script>alert(1)</script></html>");
+        await run("visualizer", "update", plain, "--yes", "--json");
+        expect(JSON.parse(out[0])).toMatchObject({ status: "error", code: "INVALID_REPORT" });
+        expect(process.exitCode).toBe(2);
+        expect(fs.readFileSync(plain, "utf8")).toBe("<html><script>alert(1)</script></html>");
+    });
+    it("opens only after a successful update; open failure is a warning, not a failure", async () => {
+        makeStale(report);
+        state.open.mockResolvedValue({ opened: false, error: "no display" });
+        await run("visualizer", "update", report, "--yes", "--open", "--json");
+        const result = JSON.parse(out[0]);
+        expect(state.open).toHaveBeenCalledWith(report);
+        expect(result).toMatchObject({ status: "updated", opened: false });
+        expect(result.warnings[0].code).toBe("OPEN_FAILED");
+        expect(process.exitCode).toBeUndefined();
+    });
+    it("does not open when the update is refused", async () => {
+        makeStale(report);
+        await run("visualizer", "update", report, "--open");
+        expect(state.open).not.toHaveBeenCalled();
+    });
+});

package/dist/index.js

@@ -6,6 +6,8 @@ import { registerListCommand } from "./commands/list.js";
 import { registerInstallCommand } from "./commands/install.js";
 import { registerRunCommand } from "./commands/run.js";
 import { registerUninstallCommand } from "./commands/uninstall.js";
+import { registerViewCommand } from "./commands/view.js";
+import { registerVisualizerCommand } from "./commands/visualizer.js";
 const program = new Command();
 program
     .name("moldesk")
@@ -16,4 +18,6 @@ registerListCommand(program);
 registerInstallCommand(program);
 registerUninstallCommand(program);
 registerRunCommand(program);
+registerViewCommand(program);
+registerVisualizerCommand(program);
 program.parse();

package/dist/utils/report-errors.d.ts

@@ -0,0 +1,2 @@
+/** Prints an error as JSON (stdout, one object) or text (stderr) and sets the exit code. */
+export declare function reportFailure(error: unknown, json: boolean | undefined): void;

package/dist/utils/report-errors.js

@@ -0,0 +1,23 @@
+import { asMoldeskError } from "@moldesk/core";
+/** Exit codes for report commands: 2 = usage/invalid report or input, 8 = cancelled, 10 = internal. */
+const EXIT_CODES = {
+    INVALID_VIEW_INPUT: 2,
+    INVALID_REPORT: 2,
+    OUTPUT_EXISTS: 2,
+    UNSUPPORTED_REPORT: 2,
+    REPORT_CONFLICT: 2,
+    VIEW_CANCELLED: 8,
+};
+/** Prints an error as JSON (stdout, one object) or text (stderr) and sets the exit code. */
+export function reportFailure(error, json) {
+    const err = asMoldeskError(error);
+    if (json) {
+        console.log(JSON.stringify({ status: "error", code: err.code, message: err.message, remediation: err.remediation }, null, 2));
+    }
+    else {
+        console.error(err.message);
+        if (err.remediation)
+            console.error(err.remediation);
+    }
+    process.exitCode = EXIT_CODES[err.code] ?? 10;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moldesk/cli",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "description": "MoleculeDesk CLI — install and run computational biology models",
   "license": "MIT",
   "type": "module",
@@ -21,7 +21,7 @@
   ],
   "dependencies": {
     "commander": "^12.1.0",
-    "@moldesk/core": "0.0.3"
+    "@moldesk/core": "0.0.5"
   },
   "devDependencies": {
     "typescript": "^5.6.3",