@autifyhq/aximo-cli 0.1.0

package/dist/desktop-server/setup.js

@@ -0,0 +1,200 @@
+import { spawn, spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { createWriteStream, existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync, } from "node:fs";
+import { arch as osArch, platform } from "node:os";
+import { join } from "node:path";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { getAximoDir, getCacheDir, getDepsMarkerPath, getEmbeddedPythonBinary, getPythonDir, getPythonMarkerPath, getRemoteLogPath, } from "../commands/device/paths.js";
+import { ensureAgent } from "./agent-sync.js";
+export const PYTHON_RELEASE = "20260414";
+export const PYTHON_VERSION = "3.12.13";
+const BUILDS = {
+    "darwin-x64": {
+        target: "x86_64-apple-darwin",
+        sha256: "801b03fbe004181d55a02ebd8b4e04d74973e70d716062aebe3b3cf32e9be297",
+    },
+    "darwin-arm64": {
+        target: "aarch64-apple-darwin",
+        sha256: "8966b2bcd9fa03ba22c080ad15a86bc12e41a00122b16f4b3740e302261124d9",
+    },
+    "linux-x64": {
+        target: "x86_64-unknown-linux-gnu",
+        sha256: "cdcf8724d46e4857f8db5ee9f4252dc2f5da34f7940294ec6b312389dd3f41e0",
+    },
+    "linux-arm64": {
+        target: "aarch64-unknown-linux-gnu",
+        sha256: "355d981eafb9b2870af79ddc106ced7266b6f6d2101d8fbcb05620fa386642b9",
+    },
+    "win32-x64": {
+        target: "x86_64-pc-windows-msvc",
+        sha256: "c5a9e011e284c49c48106ca177342f3e3f64e95b4c6652d4a382cc7c9bb1cc46",
+    },
+    "win32-arm64": {
+        target: "aarch64-pc-windows-msvc",
+        sha256: "f55326c894fde76fc0faffe95d2bce60be533c88a8c44c1b88bbbc17bf6a5cd5",
+    },
+};
+function selectBuild() {
+    const key = `${platform()}-${osArch()}`;
+    const build = BUILDS[key];
+    if (!build) {
+        throw new Error(`Unsupported platform/arch: ${key}`);
+    }
+    return build;
+}
+function buildDownloadUrl(build) {
+    const filename = `cpython-${PYTHON_VERSION}+${PYTHON_RELEASE}-${build.target}-install_only.tar.gz`;
+    return `https://github.com/astral-sh/python-build-standalone/releases/download/${PYTHON_RELEASE}/${filename}`;
+}
+export function installedPythonTag() {
+    return `${PYTHON_RELEASE}-${PYTHON_VERSION}`;
+}
+async function downloadTarball(url, dest, expectedSha256) {
+    const response = await fetch(url);
+    if (!response.ok || !response.body) {
+        throw new Error(`Download failed: ${response.status} ${response.statusText} (${url})`);
+    }
+    const totalBytes = Number(response.headers.get("content-length") ?? 0);
+    const hash = createHash("sha256");
+    let received = 0;
+    let lastProgressMs = 0;
+    const source = Readable.fromWeb(response.body);
+    source.on("data", (chunk) => {
+        hash.update(chunk);
+        received += chunk.length;
+        const now = Date.now();
+        if (totalBytes && now - lastProgressMs > 250 && process.stderr.isTTY) {
+            const pct = Math.floor((received / totalBytes) * 100);
+            const mb = (received / 1_000_000).toFixed(1);
+            const totalMb = (totalBytes / 1_000_000).toFixed(1);
+            process.stderr.write(`\rDownloading Python... ${pct}% (${mb}/${totalMb} MB)`);
+            lastProgressMs = now;
+        }
+    });
+    await pipeline(source, createWriteStream(dest));
+    if (totalBytes && process.stderr.isTTY)
+        process.stderr.write("\n");
+    const actual = hash.digest("hex");
+    if (actual !== expectedSha256) {
+        rmSync(dest, { force: true });
+        throw new Error(`SHA256 mismatch for ${url}\n  expected ${expectedSha256}\n  actual   ${actual}`);
+    }
+}
+function extractTarball(tarball, destDir) {
+    mkdirSync(destDir, { recursive: true });
+    const result = spawnSync("tar", ["-xzf", tarball, "-C", destDir], { stdio: "inherit" });
+    if (result.error) {
+        throw new Error(`Failed to run tar: ${result.error.message}. ` +
+            "A system 'tar' is required to extract the Python archive.");
+    }
+    if (result.status !== 0) {
+        throw new Error(`tar extraction failed (exit ${result.status})`);
+    }
+}
+async function installEmbeddedPython() {
+    const pythonDir = getPythonDir();
+    const cacheDir = getCacheDir();
+    const pythonMarker = getPythonMarkerPath();
+    const depsMarker = getDepsMarkerPath();
+    if (existsSync(pythonDir)) {
+        rmSync(pythonDir, { recursive: true, force: true });
+    }
+    const build = selectBuild();
+    const url = buildDownloadUrl(build);
+    mkdirSync(cacheDir, { recursive: true });
+    const tarball = join(cacheDir, `python-${installedPythonTag()}.tar.gz`);
+    const staging = join(cacheDir, "python-staging");
+    if (existsSync(staging))
+        rmSync(staging, { recursive: true, force: true });
+    console.log(`Fetching embedded Python ${PYTHON_VERSION} (${build.target})...`);
+    await downloadTarball(url, tarball, build.sha256);
+    console.log("Extracting...");
+    extractTarball(tarball, staging);
+    const extracted = join(staging, "python");
+    if (!existsSync(extracted)) {
+        throw new Error(`Unexpected archive layout: 'python/' not found after extracting ${tarball}`);
+    }
+    mkdirSync(getAximoDir(), { recursive: true });
+    renameSync(extracted, pythonDir);
+    rmSync(staging, { recursive: true, force: true });
+    rmSync(tarball, { force: true });
+    writeFileSync(pythonMarker, installedPythonTag(), { mode: 0o644 });
+    if (existsSync(depsMarker))
+        rmSync(depsMarker, { force: true });
+}
+async function ensurePython() {
+    const binary = getEmbeddedPythonBinary();
+    const markerPath = getPythonMarkerPath();
+    const marker = existsSync(markerPath) ? readFileSync(markerPath, "utf-8").trim() : "";
+    if (marker === installedPythonTag() && existsSync(binary)) {
+        return binary;
+    }
+    await installEmbeddedPython();
+    return binary;
+}
+function hashFile(path) {
+    return createHash("sha256").update(readFileSync(path)).digest("hex");
+}
+function ensureDependencies(python, requirementsPath) {
+    if (!existsSync(requirementsPath)) {
+        throw new Error(`requirements.txt not found at ${requirementsPath}`);
+    }
+    const requirementsHash = hashFile(requirementsPath);
+    const depsMarker = getDepsMarkerPath();
+    const marker = existsSync(depsMarker) ? readFileSync(depsMarker, "utf-8").trim() : "";
+    if (marker === requirementsHash)
+        return;
+    console.log("Installing Python dependencies...");
+    const result = spawnSync(python, [
+        "-m",
+        "pip",
+        "install",
+        "--disable-pip-version-check",
+        "--no-warn-script-location",
+        "-r",
+        requirementsPath,
+    ], { stdio: "inherit" });
+    if (result.status !== 0) {
+        throw new Error(`pip install failed (exit ${result.status})`);
+    }
+    writeFileSync(depsMarker, requirementsHash, { mode: 0o644 });
+}
+export async function ensurePythonReady(deps) {
+    const pythonPath = await ensurePython();
+    const agent = await ensureAgent(deps);
+    if (agent.changed) {
+        console.log(`Agent script updated to version ${agent.version}`);
+    }
+    ensureDependencies(pythonPath, agent.requirementsPath);
+    return {
+        pythonPath,
+        scriptPath: agent.scriptPath,
+        agentVersion: agent.version,
+        agentChanged: agent.changed,
+    };
+}
+export function startDesktopRemote(pythonPath, scriptPath, options) {
+    const child = spawn(pythonPath, [scriptPath], {
+        env: {
+            ...process.env,
+            AXIMO_HOME: getAximoDir(),
+            LOG_FILE: getRemoteLogPath(),
+            RELAY_URL: options.relayUrl,
+            DEVICE_TOKEN: options.deviceToken,
+            DEVICE_NAME: options.deviceName,
+        },
+        stdio: "pipe",
+    });
+    child.stdout?.on("data", (data) => {
+        const msg = data.toString().trim();
+        if (msg)
+            console.log(msg);
+    });
+    child.stderr?.on("data", (data) => {
+        const msg = data.toString().trim();
+        if (msg)
+            console.error(`[remote] ${msg}`);
+    });
+    return child;
+}

package/dist/errors.d.ts

@@ -0,0 +1,2 @@
+import type { ErrorEnvelope } from "./types.js";
+export declare function handleApiError(error: unknown): ErrorEnvelope;

package/dist/errors.js

@@ -0,0 +1,71 @@
+import { formatError } from "./output.js";
+function isHttpError(error) {
+    if (typeof error !== "object" || error === null)
+        return false;
+    const e = error;
+    return typeof e["status"] === "number" && typeof e["message"] === "string";
+}
+const NOT_FOUND_HINT = "Check the ID exists and you have access. List resources: aximo project list / aximo device list / aximo upload list";
+const AUTH_HINT = "Run `aximo configure` to save credentials, or set AXIMO_API_KEY via `export AXIMO_API_KEY=your-key` or `node --env-file=.env`.";
+// Node's net layer surfaces transient transport failures via these system error codes.
+const RETRYABLE_NET_CODES = new Set([
+    "ECONNRESET",
+    "ECONNREFUSED",
+    "ENOTFOUND",
+    "EAI_AGAIN",
+    "ETIMEDOUT",
+    "EPIPE",
+    "EHOSTUNREACH",
+    "ENETUNREACH",
+    "UND_ERR_SOCKET",
+    "UND_ERR_CONNECT_TIMEOUT",
+]);
+function isTransientNetworkError(error) {
+    // global fetch raises TypeError("fetch failed") when no HTTP response is received
+    if (error instanceof TypeError)
+        return true;
+    if (typeof error !== "object" || error === null)
+        return false;
+    const cause = error.cause;
+    if (typeof cause !== "object" || cause === null)
+        return false;
+    const code = cause.code;
+    return typeof code === "string" && RETRYABLE_NET_CODES.has(code);
+}
+export function handleApiError(error) {
+    if (isHttpError(error)) {
+        const { status, message, retryAfter } = error;
+        if (status === 401) {
+            return formatError("unauthorized", message, false, AUTH_HINT);
+        }
+        if (status === 403) {
+            return formatError("unauthorized", message, false, AUTH_HINT);
+        }
+        if (status === 404) {
+            return formatError("not_found", message, false, NOT_FOUND_HINT);
+        }
+        if (status === 429) {
+            const base = "Aximo enforces a daily session limit. Retry after cooldown.";
+            const hint = retryAfter !== undefined ? `Retry after ${retryAfter}s. ${base}` : base;
+            return formatError("rate_limited", message, true, hint);
+        }
+        if (status >= 500) {
+            return formatError("api_error", message, true);
+        }
+        if (status >= 400) {
+            return formatError("validation_error", message, false);
+        }
+        return formatError("api_error", message, false);
+    }
+    if (error instanceof SyntaxError) {
+        return formatError("validation_error", error.message, false);
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.includes("No API key configured")) {
+        return formatError("unauthorized", message, false, AUTH_HINT);
+    }
+    if (isTransientNetworkError(error)) {
+        return formatError("api_error", message, true);
+    }
+    return formatError("api_error", message, false);
+}

package/dist/errors.test.d.ts

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

package/dist/errors.test.js

@@ -0,0 +1,88 @@
+import { describe, expect, it } from "vitest";
+import { handleApiError } from "./errors.js";
+function httpErr(status, message = `status ${status}`, retryAfter) {
+    const err = Object.assign(new Error(message), { status });
+    if (retryAfter !== undefined)
+        err.retryAfter = retryAfter;
+    return err;
+}
+describe("handleApiError", () => {
+    it("maps 401 to unauthorized with AXIMO_API_KEY hint", () => {
+        const r = handleApiError(httpErr(401, "Unauthorized"));
+        expect(r.ok).toBe(false);
+        expect(r.error.code).toBe("unauthorized");
+        expect(r.error.retryable).toBe(false);
+        expect(r.error.hint).toContain("AXIMO_API_KEY");
+        expect(r.error.hint).toContain("--env-file");
+    });
+    it("maps 403 to unauthorized", () => {
+        expect(handleApiError(httpErr(403)).error.code).toBe("unauthorized");
+    });
+    it("maps 404 to not_found with list hint", () => {
+        const r = handleApiError(httpErr(404));
+        expect(r.error.code).toBe("not_found");
+        expect(r.error.retryable).toBe(false);
+        expect(r.error.hint).toContain("aximo project list");
+    });
+    it("maps 429 with Retry-After header into hint", () => {
+        const r = handleApiError(httpErr(429, "Too many", "60"));
+        expect(r.error.code).toBe("rate_limited");
+        expect(r.error.hint).toContain("Retry after 60s");
+        expect(r.error.hint).toContain("daily");
+    });
+    it("maps 429 to rate_limited (retryable)", () => {
+        const r = handleApiError(httpErr(429));
+        expect(r.error.code).toBe("rate_limited");
+        expect(r.error.retryable).toBe(true);
+        expect(r.error.hint).toContain("daily");
+    });
+    it("maps 400 to validation_error", () => {
+        expect(handleApiError(httpErr(400)).error.code).toBe("validation_error");
+    });
+    it("maps 422 to validation_error", () => {
+        expect(handleApiError(httpErr(422)).error.code).toBe("validation_error");
+    });
+    it("maps 500 to api_error retryable", () => {
+        const r = handleApiError(httpErr(500));
+        expect(r.error.code).toBe("api_error");
+        expect(r.error.retryable).toBe(true);
+    });
+    it("maps 503 to api_error retryable", () => {
+        expect(handleApiError(httpErr(503)).error.retryable).toBe(true);
+    });
+    it("treats SyntaxError as validation_error", () => {
+        expect(handleApiError(new SyntaxError("bad json")).error.code).toBe("validation_error");
+    });
+    it("treats unknown Error as api_error", () => {
+        const r = handleApiError(new Error("boom"));
+        expect(r.error.code).toBe("api_error");
+        expect(r.error.message).toBe("boom");
+    });
+    it("routes 'No API key configured' Error to unauthorized (parity with notion/slack/excalidraw)", () => {
+        const r = handleApiError(new Error("No API key configured. Run `aximo configure` ..."));
+        expect(r.error.code).toBe("unauthorized");
+        expect(r.error.retryable).toBe(false);
+        expect(r.error.hint).toContain("AXIMO_API_KEY");
+    });
+    it("treats fetch network failure (TypeError) as retryable api_error", () => {
+        // Node's global fetch throws TypeError on DNS / TLS / connection failure
+        const r = handleApiError(new TypeError("fetch failed"));
+        expect(r.error.code).toBe("api_error");
+        expect(r.error.retryable).toBe(true);
+    });
+    it("treats Error with cause.code=ECONNRESET as retryable api_error", () => {
+        const err = new Error("socket hang up");
+        err.cause = { code: "ECONNRESET" };
+        const r = handleApiError(err);
+        expect(r.error.code).toBe("api_error");
+        expect(r.error.retryable).toBe(true);
+    });
+    it("treats Error with cause.code=ENOTFOUND as retryable api_error", () => {
+        const err = new Error("getaddrinfo");
+        err.cause = { code: "ENOTFOUND" };
+        expect(handleApiError(err).error.retryable).toBe(true);
+    });
+    it("handles non-Error values", () => {
+        expect(handleApiError("weird").error.message).toBe("weird");
+    });
+});

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+export { request, getApiKey, getBaseUrl } from "./client.js";
+export type { ClientDeps, RequestOptions } from "./client.js";
+export { formatSuccess, formatError, printResult, validationError } from "./output.js";
+export { handleApiError } from "./errors.js";
+export { runHealthCheck } from "./commands/health/check.js";
+export { runProjectList } from "./commands/project/list.js";
+export { runDeviceList } from "./commands/device/list.js";
+export { runSessionCreate } from "./commands/session/create.js";
+export { runSessionGet } from "./commands/session/get.js";
+export { runTriggerCaseRun } from "./commands/trigger/case/run.js";
+export { runTriggerCaseGet } from "./commands/trigger/case/get.js";
+export { runTriggerPlanRun } from "./commands/trigger/plan/run.js";
+export { runTriggerPlanGet } from "./commands/trigger/plan/get.js";
+export { runUploadCreate } from "./commands/upload/create.js";
+export { runUploadList } from "./commands/upload/list.js";
+export { runUploadGet } from "./commands/upload/get.js";
+export { runUploadPut } from "./commands/upload/put.js";
+export { runUploadSubmit } from "./commands/upload/submit.js";
+export type * from "./types.js";

package/dist/index.js

@@ -0,0 +1,17 @@
+export { request, getApiKey, getBaseUrl } from "./client.js";
+export { formatSuccess, formatError, printResult, validationError } from "./output.js";
+export { handleApiError } from "./errors.js";
+export { runHealthCheck } from "./commands/health/check.js";
+export { runProjectList } from "./commands/project/list.js";
+export { runDeviceList } from "./commands/device/list.js";
+export { runSessionCreate } from "./commands/session/create.js";
+export { runSessionGet } from "./commands/session/get.js";
+export { runTriggerCaseRun } from "./commands/trigger/case/run.js";
+export { runTriggerCaseGet } from "./commands/trigger/case/get.js";
+export { runTriggerPlanRun } from "./commands/trigger/plan/run.js";
+export { runTriggerPlanGet } from "./commands/trigger/plan/get.js";
+export { runUploadCreate } from "./commands/upload/create.js";
+export { runUploadList } from "./commands/upload/list.js";
+export { runUploadGet } from "./commands/upload/get.js";
+export { runUploadPut } from "./commands/upload/put.js";
+export { runUploadSubmit } from "./commands/upload/submit.js";

package/dist/mutate.d.ts

@@ -0,0 +1,13 @@
+import type { SuccessEnvelope, ErrorEnvelope } from "./types.js";
+export interface DryRunResult {
+    dryRun: true;
+    method: string;
+    url: string;
+    body?: unknown;
+}
+export declare function dryRunEnvelope(method: string, path: string, body?: unknown): SuccessEnvelope<DryRunResult>;
+export declare function resolveJsonOverride(jsonFlag: unknown): {
+    body: Record<string, unknown>;
+} | {
+    error: ErrorEnvelope;
+} | undefined;

package/dist/mutate.js

@@ -0,0 +1,25 @@
+import { formatError, formatSuccess, validationError } from "./output.js";
+import { parseJsonBody, JsonBodyError, OPENAPI_URL } from "./validate.js";
+import { getBaseUrl } from "./client.js";
+export function dryRunEnvelope(method, path, body) {
+    const url = `${getBaseUrl()}${path.startsWith("/") ? path : `/${path}`}`;
+    const data = { dryRun: true, method, url };
+    if (body !== undefined)
+        data.body = body;
+    return formatSuccess(data);
+}
+export function resolveJsonOverride(jsonFlag) {
+    if (jsonFlag === undefined || jsonFlag === "")
+        return undefined;
+    try {
+        return { body: parseJsonBody(jsonFlag) };
+    }
+    catch (err) {
+        if (err instanceof JsonBodyError) {
+            return {
+                error: formatError("validation_error", err.message, false, `See ${OPENAPI_URL} for the request body shape.`),
+            };
+        }
+        return { error: validationError(err) };
+    }
+}

package/dist/mutate.test.d.ts

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

package/dist/mutate.test.js

@@ -0,0 +1,49 @@
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import { dryRunEnvelope } from "./mutate.js";
+const ORIG_URL = process.env["AXIMO_BASE_URL"];
+beforeAll(() => {
+    process.env["AXIMO_BASE_URL"] = "https://aximo.test";
+});
+afterAll(() => {
+    if (ORIG_URL !== undefined)
+        process.env["AXIMO_BASE_URL"] = ORIG_URL;
+    else
+        delete process.env["AXIMO_BASE_URL"];
+});
+describe("dryRunEnvelope", () => {
+    it("returns flat envelope with dryRun, method, url, body at top level (no `request` wrapper)", () => {
+        const env = dryRunEnvelope("POST", "/api/sessions", { title: "t" });
+        expect(env).toEqual({
+            ok: true,
+            data: {
+                dryRun: true,
+                method: "POST",
+                url: "https://aximo.test/api/sessions",
+                body: { title: "t" },
+            },
+        });
+    });
+    it("omits body when undefined (GET-style preview)", () => {
+        const env = dryRunEnvelope("POST", "/api/uploads/u1/submit");
+        expect(env.ok).toBe(true);
+        if (env.ok) {
+            expect(env.data.dryRun).toBe(true);
+            expect(env.data.method).toBe("POST");
+            expect(env.data.url).toBe("https://aximo.test/api/uploads/u1/submit");
+            expect("body" in env.data).toBe(false);
+        }
+    });
+    it("constructs full URL from AXIMO_BASE_URL + path", () => {
+        process.env["AXIMO_BASE_URL"] = "https://staging.aximo.test/";
+        const env = dryRunEnvelope("PUT", "/api/uploads/u1");
+        if (env.ok)
+            expect(env.data.url).toBe("https://staging.aximo.test/api/uploads/u1");
+        process.env["AXIMO_BASE_URL"] = "https://aximo.test";
+    });
+    it("does NOT have a nested `request` field", () => {
+        const env = dryRunEnvelope("POST", "/api/sessions", {});
+        if (env.ok) {
+            expect("request" in env.data).toBe(false);
+        }
+    });
+});

package/dist/output.d.ts

@@ -0,0 +1,5 @@
+import type { SuccessEnvelope, SuccessMeta, ErrorEnvelope, ErrorCode, Envelope } from "./types.js";
+export declare function formatSuccess<T>(data: T, meta?: SuccessMeta): SuccessEnvelope<T>;
+export declare function formatError(code: ErrorCode, message: string, retryable: boolean, hint?: string): ErrorEnvelope;
+export declare function validationError(err: unknown): ErrorEnvelope;
+export declare function printResult(result: Envelope<unknown>): void;

package/dist/output.js

@@ -0,0 +1,23 @@
+export function formatSuccess(data, meta) {
+    const envelope = { ok: true, data };
+    if (meta) {
+        envelope.meta = meta;
+    }
+    return envelope;
+}
+export function formatError(code, message, retryable, hint) {
+    const error = { code, message, retryable };
+    if (hint !== undefined) {
+        error.hint = hint;
+    }
+    return { ok: false, error };
+}
+export function validationError(err) {
+    return formatError("validation_error", err instanceof Error ? err.message : String(err), false);
+}
+export function printResult(result) {
+    console.log(JSON.stringify(result, null, 2));
+    if (!result.ok) {
+        process.exitCode = 1;
+    }
+}

package/dist/output.test.d.ts

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

package/dist/output.test.js

@@ -0,0 +1,42 @@
+import { describe, expect, it, vi, afterEach } from "vitest";
+import { formatSuccess, formatError, printResult } from "./output.js";
+describe("formatSuccess", () => {
+    it("returns envelope without meta by default", () => {
+        expect(formatSuccess({ a: 1 })).toEqual({ ok: true, data: { a: 1 } });
+    });
+    it("includes meta when provided", () => {
+        expect(formatSuccess({ a: 1 }, { total: 3 })).toEqual({
+            ok: true,
+            data: { a: 1 },
+            meta: { total: 3 },
+        });
+    });
+});
+describe("formatError", () => {
+    it("builds error envelope without hint", () => {
+        expect(formatError("not_found", "nope", false)).toEqual({
+            ok: false,
+            error: { code: "not_found", message: "nope", retryable: false },
+        });
+    });
+    it("includes hint when provided", () => {
+        const env = formatError("unauthorized", "401", false, "set AXIMO_API_KEY");
+        expect(env.error.hint).toBe("set AXIMO_API_KEY");
+    });
+});
+describe("printResult", () => {
+    const logSpy = vi.spyOn(console, "log").mockImplementation(() => undefined);
+    afterEach(() => {
+        logSpy.mockClear();
+        process.exitCode = 0;
+    });
+    it("prints success as JSON and does not set exitCode", () => {
+        printResult({ ok: true, data: { x: 1 } });
+        expect(logSpy).toHaveBeenCalledOnce();
+        expect(process.exitCode).not.toBe(1);
+    });
+    it("sets exitCode=1 on error envelope", () => {
+        printResult({ ok: false, error: { code: "api_error", message: "boom", retryable: false } });
+        expect(process.exitCode).toBe(1);
+    });
+});

package/dist/test-setup.d.ts

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

package/dist/test-setup.js

@@ -0,0 +1,13 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+// Isolate $AXIMO_HOME for every test file so a developer's real
+// ~/.aximo/config.json never leaks into a test run. Individual test
+// files may override AXIMO_HOME again in their own beforeAll hooks.
+if (!process.env["AXIMO_HOME"]) {
+    const tempHome = mkdtempSync(join(tmpdir(), "aximo-test-"));
+    process.env["AXIMO_HOME"] = tempHome;
+    process.on("exit", () => {
+        rmSync(tempHome, { recursive: true, force: true });
+    });
+}

package/dist/test-utils.d.ts

@@ -0,0 +1,4 @@
+import { http, HttpResponse } from "msw";
+export { http, HttpResponse };
+export declare const server: import("msw/node").SetupServer;
+export declare const TEST_BASE_URL = "https://aximo.test";

package/dist/test-utils.js

@@ -0,0 +1,5 @@
+import { setupServer } from "msw/node";
+import { http, HttpResponse } from "msw";
+export { http, HttpResponse };
+export const server = setupServer();
+export const TEST_BASE_URL = "https://aximo.test";