@autifyhq/aximo-cli 0.15.0 → 0.16.0

package/dist/commands/device/testbox/logs.d.ts

@@ -0,0 +1,15 @@
+declare const _default: import("citty").CommandDef<{
+    readonly lines: {
+        readonly type: "string";
+        readonly description: "Lines of history to show (default 50)";
+    };
+    readonly follow: {
+        readonly type: "boolean";
+        readonly description: "Stream the log until interrupted";
+    };
+    readonly name: {
+        readonly type: "string";
+        readonly description: "Box name when running more than one (default: the single default box)";
+    };
+}>;
+export default _default;

package/dist/commands/device/testbox/logs.js

@@ -0,0 +1,43 @@
+import { spawn } from "node:child_process";
+import { defineCommand } from "citty";
+import { formatError, printResult } from "../../../output.js";
+import { agentLog, agentLogFollowArgs } from "./box.js";
+import { TestboxError } from "./errors.js";
+import { nameArg, toEnvelope } from "./result.js";
+function parseLines(raw) {
+    const lines = raw === undefined ? 50 : Number(raw);
+    if (!Number.isInteger(lines) || lines < 1)
+        throw new TestboxError("--lines must be a positive integer");
+    return lines;
+}
+export default defineCommand({
+    meta: { name: "logs", description: "The device agent's log inside the box" },
+    args: {
+        ...nameArg,
+        lines: { type: "string", description: "Lines of history to show (default 50)" },
+        follow: { type: "boolean", description: "Stream the log until interrupted" },
+    },
+    async run({ args }) {
+        if (!args.follow) {
+            printResult(await toEnvelope(() => agentLog(args.name, parseLines(args.lines))));
+            return;
+        }
+        const result = await toEnvelope(async () => agentLogFollowArgs(args.name, parseLines(args.lines)));
+        if (!result.ok) {
+            printResult(result);
+            return;
+        }
+        const child = spawn("docker", result.data, { stdio: "inherit" });
+        await new Promise((resolve) => {
+            child.on("error", (err) => {
+                printResult(formatError("api_error", err.message, true));
+                resolve();
+            });
+            child.on("close", (code) => {
+                if (code !== 0)
+                    process.exitCode = 1;
+                resolve();
+            });
+        });
+    },
+});

package/dist/commands/device/testbox/prune.d.ts

@@ -0,0 +1,11 @@
+declare const _default: import("citty").CommandDef<{
+    readonly "keep-image": {
+        readonly type: "boolean";
+        readonly description: "Leave the image in the local Docker cache";
+    };
+    readonly name: {
+        readonly type: "string";
+        readonly description: "Box name when running more than one (default: the single default box)";
+    };
+}>;
+export default _default;

package/dist/commands/device/testbox/prune.js

@@ -0,0 +1,17 @@
+import { defineCommand } from "citty";
+import { printResult } from "../../../output.js";
+import { pruneTestbox } from "./box.js";
+import { nameArg, toEnvelope } from "./result.js";
+export default defineCommand({
+    meta: {
+        name: "prune",
+        description: "down, then remove everything: the device registration on the server, the profile, the local token and the image",
+    },
+    args: {
+        ...nameArg,
+        "keep-image": { type: "boolean", description: "Leave the image in the local Docker cache" },
+    },
+    async run({ args }) {
+        printResult(await toEnvelope(() => pruneTestbox(args.name, { keepImage: Boolean(args["keep-image"]) })));
+    },
+});

package/dist/commands/device/testbox/registration.d.ts

@@ -0,0 +1,9 @@
+import { type ClientDeps } from "../../../client.js";
+import type { UserDevice } from "../../../types.js";
+import { type DeviceConfig } from "../device-config.js";
+export declare function readRegistration(name: string): DeviceConfig | null;
+export declare function ensureRegistration(name: string, own: UserDevice[], deps: ClientDeps & {
+    hostName?: () => string;
+}): Promise<DeviceConfig>;
+/** Deletes the device row; false when it was already gone. */
+export declare function unregister(deviceId: string, deps: ClientDeps): Promise<boolean>;

package/dist/commands/device/testbox/registration.js

@@ -0,0 +1,56 @@
+import { randomBytes } from "node:crypto";
+import { hostname } from "node:os";
+import { getBaseUrl, request } from "../../../client.js";
+import { readDeviceConfig, writeDeviceConfig } from "../device-config.js";
+import { getTestboxConfigPath } from "../paths.js";
+import { DEFAULT_BOX_NAME } from "./container.js";
+import { TestboxError } from "./errors.js";
+export function readRegistration(name) {
+    return readDeviceConfig(getTestboxConfigPath(name));
+}
+function deviceNameFor(name, host) {
+    const machine = host.replace(/\.local$/, "");
+    const base = name === DEFAULT_BOX_NAME ? `${machine}-testbox` : `${machine}-testbox-${name}`;
+    return `${base}-${randomBytes(2).toString("hex")}`;
+}
+// One device row per box. The owner-scoped list can miss a row that still
+// exists (another API key owner, another server), so those cases stop instead
+// of quietly registering a second device.
+export async function ensureRegistration(name, own, deps) {
+    const baseUrl = deps.baseUrl ?? getBaseUrl();
+    const existing = readRegistration(name);
+    if (existing) {
+        if (existing.baseUrl !== undefined && existing.baseUrl !== baseUrl) {
+            throw new TestboxError(`This testbox is registered against ${existing.baseUrl}, not ${baseUrl}. Run 'aximo device testbox prune' there first, or use a different --name.`);
+        }
+        if (own.some((d) => d.id === existing.deviceId))
+            return existing;
+        const org = await request("/api/organizations/devices", {}, deps);
+        if ((org.devices ?? []).some((d) => d.id === existing.deviceId)) {
+            throw new TestboxError(`Device ${existing.deviceId} belongs to another API key owner in this organization. Use that key, or 'aximo device testbox prune' with it.`);
+        }
+    }
+    const deviceName = existing?.name ?? deviceNameFor(name, (deps.hostName ?? hostname)());
+    const res = await request("/api/devices/register", { method: "POST", body: { name: deviceName, platform: "linux", os: "Testbox (Docker)" } }, deps);
+    const registration = {
+        deviceId: res.deviceId,
+        deviceToken: res.deviceToken,
+        name: deviceName,
+        registeredAt: new Date().toISOString(),
+        baseUrl,
+    };
+    writeDeviceConfig(registration, getTestboxConfigPath(name));
+    return registration;
+}
+/** Deletes the device row; false when it was already gone. */
+export async function unregister(deviceId, deps) {
+    try {
+        await request(`/api/devices/user/${encodeURIComponent(deviceId)}`, { method: "DELETE" }, deps);
+        return true;
+    }
+    catch (err) {
+        if (err.status === 404)
+            return false;
+        throw err;
+    }
+}

package/dist/commands/device/testbox/reset.d.ts

@@ -0,0 +1,7 @@
+declare const _default: import("citty").CommandDef<{
+    readonly name: {
+        readonly type: "string";
+        readonly description: "Box name when running more than one (default: the single default box)";
+    };
+}>;
+export default _default;

package/dist/commands/device/testbox/reset.js

@@ -0,0 +1,14 @@
+import { defineCommand } from "citty";
+import { printResult } from "../../../output.js";
+import { resetTestbox } from "./box.js";
+import { nameArg, toEnvelope } from "./result.js";
+export default defineCommand({
+    meta: {
+        name: "reset",
+        description: "down, then drop the browser profile so the next sign-in starts fresh",
+    },
+    args: { ...nameArg },
+    async run({ args }) {
+        printResult(await toEnvelope(() => resetTestbox(args.name)));
+    },
+});

package/dist/commands/device/testbox/result.d.ts

@@ -0,0 +1,8 @@
+import type { Envelope } from "../../../types.js";
+export declare function toEnvelope<T>(fn: () => Promise<T>): Promise<Envelope<T>>;
+export declare const nameArg: {
+    readonly name: {
+        readonly type: "string";
+        readonly description: "Box name when running more than one (default: the single default box)";
+    };
+};

package/dist/commands/device/testbox/result.js

@@ -0,0 +1,23 @@
+import { handleApiError } from "../../../errors.js";
+import { formatError, formatSuccess } from "../../../output.js";
+import { DockerCommandError } from "./docker.js";
+import { TestboxError } from "./errors.js";
+export async function toEnvelope(fn) {
+    try {
+        return formatSuccess(await fn());
+    }
+    catch (err) {
+        if (err instanceof TestboxError) {
+            return formatError(err.retryable ? "api_error" : "validation_error", err.message, err.retryable);
+        }
+        if (err instanceof DockerCommandError)
+            return formatError("api_error", err.message, true);
+        return handleApiError(err);
+    }
+}
+export const nameArg = {
+    name: {
+        type: "string",
+        description: "Box name when running more than one (default: the single default box)",
+    },
+};

package/dist/commands/device/testbox/result.test.d.ts

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

package/dist/commands/device/testbox/result.test.js

@@ -0,0 +1,34 @@
+import { describe, expect, it } from "vitest";
+import { DockerCommandError } from "./docker.js";
+import { TestboxError } from "./errors.js";
+import { toEnvelope } from "./result.js";
+describe("toEnvelope", () => {
+    it("wraps a result in the success envelope", async () => {
+        expect(await toEnvelope(async () => ({ name: "default" }))).toEqual({
+            ok: true,
+            data: { name: "default" },
+        });
+    });
+    it("maps testbox, Docker and API failures to the CLI's error codes", async () => {
+        expect(await toEnvelope(async () => {
+            throw new TestboxError("Invalid testbox name");
+        })).toMatchObject({ ok: false, error: { code: "validation_error", retryable: false } });
+        expect(await toEnvelope(async () => {
+            throw new TestboxError("Could not pull", true);
+        })).toEqual({
+            ok: false,
+            error: { code: "api_error", message: "Could not pull", retryable: true },
+        });
+        expect(await toEnvelope(async () => {
+            throw new DockerCommandError(["rm", "-f", "x"], {
+                code: 1,
+                stdout: "",
+                stderr: "busy",
+                timedOut: false,
+            });
+        })).toMatchObject({ ok: false, error: { code: "api_error", retryable: true } });
+        expect(await toEnvelope(async () => {
+            throw Object.assign(new Error("Unauthorized"), { status: 401 });
+        })).toMatchObject({ ok: false, error: { code: "unauthorized" } });
+    });
+});

package/dist/commands/device/testbox/self-command.d.ts

@@ -0,0 +1,12 @@
+export interface SelfCommand {
+    file: string;
+    prefix: string[];
+}
+export declare function selfCommand(env?: {
+    execPath: string;
+    execArgv: string[];
+    argv: string[];
+    sea: boolean;
+}): SelfCommand;
+export type DetachedSpawner = (args: string[], logPath: string, self?: SelfCommand) => number;
+export declare const spawnDetached: DetachedSpawner;

package/dist/commands/device/testbox/self-command.js

@@ -0,0 +1,36 @@
+import { spawn } from "node:child_process";
+import { closeSync, mkdirSync, openSync } from "node:fs";
+import { dirname } from "node:path";
+import { isSea } from "node:sea";
+// `aximo` is rarely on PATH where the MCP server runs (`npx … mcp`), and in the
+// single-executable build argv[1] is the executable itself, not a script.
+export function selfCommand(env = {
+    execPath: process.execPath,
+    execArgv: process.execArgv,
+    argv: process.argv,
+    sea: isSea(),
+}) {
+    if (env.sea)
+        return { file: env.execPath, prefix: [] };
+    return { file: env.execPath, prefix: [...env.execArgv, env.argv[1] ?? ""] };
+}
+// The child outlives the MCP server (a Docker pull dies with its client) and
+// must never touch the server's stdio, which carries JSON-RPC.
+export const spawnDetached = (args, logPath, self = selfCommand()) => {
+    mkdirSync(dirname(logPath), { recursive: true });
+    // The log carries the up envelope, live-view password included.
+    const fd = openSync(logPath, "a", 0o600);
+    try {
+        const child = spawn(self.file, [...self.prefix, ...args], {
+            detached: true,
+            stdio: ["ignore", fd, fd],
+            windowsHide: true,
+            env: process.env,
+        });
+        child.unref();
+        return child.pid ?? -1;
+    }
+    finally {
+        closeSync(fd);
+    }
+};

package/dist/commands/device/testbox/self-command.test.d.ts

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

package/dist/commands/device/testbox/self-command.test.js

@@ -0,0 +1,58 @@
+import { mkdtempSync, readFileSync, rmSync, statSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { selfCommand, spawnDetached } from "./self-command.js";
+describe("selfCommand", () => {
+    it("re-runs the entry script through the same node, keeping loader flags", () => {
+        expect(selfCommand({
+            execPath: "/usr/bin/node",
+            execArgv: ["--import", "tsx"],
+            argv: ["/usr/bin/node", "/repo/dist/cli.js", "mcp"],
+            sea: false,
+        })).toEqual({ file: "/usr/bin/node", prefix: ["--import", "tsx", "/repo/dist/cli.js"] });
+    });
+    it("runs the single executable directly, where argv[1] is not a script", () => {
+        expect(selfCommand({
+            execPath: "C:\\aximo\\aximo.exe",
+            execArgv: [],
+            argv: ["C:\\aximo\\aximo.exe", "C:\\aximo\\aximo.exe", "mcp"],
+            sea: true,
+        })).toEqual({ file: "C:\\aximo\\aximo.exe", prefix: [] });
+    });
+    it("reads the live process by default", () => {
+        const cmd = selfCommand();
+        expect(cmd.file).toBe(process.execPath);
+        expect(cmd.prefix.at(-1)).toBe(process.argv[1]);
+    });
+});
+describe("spawnDetached", () => {
+    it("runs the command in the background with the log file as its only output", async () => {
+        const dir = mkdtempSync(join(tmpdir(), "aximo-spawn-"));
+        const logPath = join(dir, "nested", "box.log");
+        try {
+            const pid = spawnDetached(["device", "testbox", "up"], logPath, {
+                file: process.execPath,
+                prefix: ["-e", "console.log(process.argv.slice(1).join(' ')); console.error('done')"],
+            });
+            expect(pid).toBeGreaterThan(0);
+            let log = "";
+            for (let i = 0; i < 50 && !log.includes("done"); i++) {
+                await new Promise((r) => setTimeout(r, 100));
+                try {
+                    log = readFileSync(logPath, "utf-8");
+                }
+                catch {
+                    // not written yet
+                }
+            }
+            expect(log).toContain("device testbox up");
+            expect(log).toContain("done");
+            if (process.platform !== "win32")
+                expect(statSync(logPath).mode & 0o777).toBe(0o600);
+        }
+        finally {
+            rmSync(dir, { recursive: true, force: true });
+        }
+    });
+});

package/dist/commands/device/testbox/status.d.ts

@@ -0,0 +1,7 @@
+declare const _default: import("citty").CommandDef<{
+    readonly name: {
+        readonly type: "string";
+        readonly description: "Box name when running more than one (default: the single default box)";
+    };
+}>;
+export default _default;

package/dist/commands/device/testbox/status.js

@@ -0,0 +1,11 @@
+import { defineCommand } from "citty";
+import { printResult } from "../../../output.js";
+import { statusTestbox } from "./box.js";
+import { nameArg, toEnvelope } from "./result.js";
+export default defineCommand({
+    meta: { name: "status", description: "Container, agent and device state of the box" },
+    args: { ...nameArg },
+    async run({ args }) {
+        printResult(await toEnvelope(() => statusTestbox(args.name)));
+    },
+});

package/dist/commands/device/testbox/up.d.ts

@@ -0,0 +1,47 @@
+import { type UpOptions } from "./box.js";
+export declare function upOptionsFromArgs(args: {
+    name?: string | undefined;
+    ports?: string | undefined;
+    "block-hosts"?: string | undefined;
+    "start-url"?: string | undefined;
+    "novnc-port"?: string | undefined;
+    screen?: string | undefined;
+    image?: string | undefined;
+    wait?: boolean | undefined;
+}): UpOptions;
+declare const _default: import("citty").CommandDef<{
+    readonly ports: {
+        readonly type: "string";
+        readonly description: "Host ports to mirror into the box, e.g. 3000 or 3000,5173-5180 (default 3000)";
+    };
+    readonly "block-hosts": {
+        readonly type: "string";
+        readonly description: "Comma-separated hosts the browser must refuse, e.g. your production domain (a browser rule matched by name, not a network boundary)";
+    };
+    readonly "start-url": {
+        readonly type: "string";
+        readonly description: "Page the browser opens on start";
+    };
+    readonly "novnc-port": {
+        readonly type: "string";
+        readonly description: "Host port for the live view (default 6080, next free for extra boxes)";
+    };
+    readonly screen: {
+        readonly type: "string";
+        readonly description: "Virtual screen size WIDTHxHEIGHT (default 1280x720, the same as Aximo's cloud desktop)";
+    };
+    readonly image: {
+        readonly type: "string";
+        readonly description: "Image to run instead of the published one";
+    };
+    readonly wait: {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly description: "Wait until the device reports online (up to 2 minutes)";
+    };
+    readonly name: {
+        readonly type: "string";
+        readonly description: "Box name when running more than one (default: the single default box)";
+    };
+}>;
+export default _default;

package/dist/commands/device/testbox/up.js

@@ -0,0 +1,76 @@
+import { defineCommand } from "citty";
+import { printResult } from "../../../output.js";
+import { upTestbox } from "./box.js";
+import { nameArg, toEnvelope } from "./result.js";
+function envDefault(flag, env) {
+    return flag ?? process.env[env];
+}
+export function upOptionsFromArgs(args) {
+    const options = { wait: args.wait !== false };
+    if (args.name !== undefined)
+        options.name = args.name;
+    const ports = envDefault(args.ports, "AXIMO_TESTBOX_PORTS");
+    if (ports !== undefined)
+        options.ports = ports;
+    const blockHosts = envDefault(args["block-hosts"], "AXIMO_TESTBOX_BLOCK_HOSTS");
+    if (blockHosts !== undefined) {
+        options.blockHosts = blockHosts
+            .split(",")
+            .map((h) => h.trim())
+            .filter(Boolean);
+    }
+    const startUrl = envDefault(args["start-url"], "AXIMO_TESTBOX_START_URL");
+    if (startUrl !== undefined)
+        options.startUrl = startUrl;
+    const novnc = envDefault(args["novnc-port"], "AXIMO_TESTBOX_NOVNC_PORT");
+    if (novnc !== undefined)
+        options.novncPort = Number(novnc);
+    const screen = envDefault(args.screen, "AXIMO_TESTBOX_SCREEN");
+    if (screen !== undefined)
+        options.screen = screen;
+    if (args.image !== undefined)
+        options.image = args.image;
+    return options;
+}
+export default defineCommand({
+    meta: {
+        name: "up",
+        description: "Pull the image, register the box as a local device, start it and connect it. Safe to re-run; a setting comes from the flag, else the same-named AXIMO_TESTBOX_* variable, else the running box.",
+    },
+    args: {
+        ...nameArg,
+        ports: {
+            type: "string",
+            description: "Host ports to mirror into the box, e.g. 3000 or 3000,5173-5180 (default 3000)",
+        },
+        "block-hosts": {
+            type: "string",
+            description: "Comma-separated hosts the browser must refuse, e.g. your production domain (a browser rule matched by name, not a network boundary)",
+        },
+        "start-url": { type: "string", description: "Page the browser opens on start" },
+        "novnc-port": {
+            type: "string",
+            description: "Host port for the live view (default 6080, next free for extra boxes)",
+        },
+        screen: {
+            type: "string",
+            description: "Virtual screen size WIDTHxHEIGHT (default 1280x720, the same as Aximo's cloud desktop)",
+        },
+        image: { type: "string", description: "Image to run instead of the published one" },
+        wait: {
+            type: "boolean",
+            default: true,
+            description: "Wait until the device reports online (up to 2 minutes)",
+        },
+    },
+    async run({ args }) {
+        const result = await toEnvelope(() => upTestbox(upOptionsFromArgs(args)));
+        printResult(result);
+        if (result.ok) {
+            for (const note of result.data.notes)
+                console.error(`\nNote: ${note}`);
+            if (result.data.liveViewUrl)
+                console.error(`\nLive view: ${result.data.liveViewUrl}`);
+        }
+    },
+});

package/dist/commands/device/testbox/up.test.d.ts

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

package/dist/commands/device/testbox/up.test.js

@@ -0,0 +1,52 @@
+import { afterEach, describe, expect, it } from "vitest";
+import { upOptionsFromArgs } from "./up.js";
+const ENV = [
+    "AXIMO_TESTBOX_PORTS",
+    "AXIMO_TESTBOX_BLOCK_HOSTS",
+    "AXIMO_TESTBOX_START_URL",
+    "AXIMO_TESTBOX_NOVNC_PORT",
+    "AXIMO_TESTBOX_SCREEN",
+];
+afterEach(() => {
+    for (const key of ENV)
+        delete process.env[key];
+});
+describe("upOptionsFromArgs", () => {
+    it("passes only the flags that were given, with wait on by default", () => {
+        expect(upOptionsFromArgs({})).toEqual({ wait: true });
+        expect(upOptionsFromArgs({ name: "qa", ports: "5173", image: "x:1", wait: false })).toEqual({
+            wait: false,
+            name: "qa",
+            ports: "5173",
+            image: "x:1",
+        });
+    });
+    it("splits block hosts and parses the noVNC port", () => {
+        expect(upOptionsFromArgs({
+            "block-hosts": "a.com, b.com,",
+            "novnc-port": "6090",
+            "start-url": "http://x",
+            screen: "1920x1080",
+        })).toMatchObject({
+            blockHosts: ["a.com", "b.com"],
+            novncPort: 6090,
+            startUrl: "http://x",
+            screen: "1920x1080",
+        });
+    });
+    it("falls back to the AXIMO_TESTBOX_* variables the Power's script used", () => {
+        process.env["AXIMO_TESTBOX_PORTS"] = "8080";
+        process.env["AXIMO_TESTBOX_BLOCK_HOSTS"] = "prod.example.com";
+        process.env["AXIMO_TESTBOX_START_URL"] = "http://localhost:8080/";
+        process.env["AXIMO_TESTBOX_NOVNC_PORT"] = "6081";
+        process.env["AXIMO_TESTBOX_SCREEN"] = "1600x900";
+        expect(upOptionsFromArgs({ ports: "3000" })).toEqual({
+            wait: true,
+            ports: "3000",
+            blockHosts: ["prod.example.com"],
+            startUrl: "http://localhost:8080/",
+            novncPort: 6081,
+            screen: "1600x900",
+        });
+    });
+});

package/dist/commands/device/testbox/url.d.ts

@@ -0,0 +1,7 @@
+declare const _default: import("citty").CommandDef<{
+    readonly name: {
+        readonly type: "string";
+        readonly description: "Box name when running more than one (default: the single default box)";
+    };
+}>;
+export default _default;

package/dist/commands/device/testbox/url.js

@@ -0,0 +1,20 @@
+import { defineCommand } from "citty";
+import { printResult } from "../../../output.js";
+import { statusTestbox } from "./box.js";
+import { TestboxError } from "./errors.js";
+import { nameArg, toEnvelope } from "./result.js";
+export default defineCommand({
+    meta: { name: "url", description: "The live-view (noVNC) link, password included" },
+    args: { ...nameArg },
+    async run({ args }) {
+        printResult(await toEnvelope(async () => {
+            const status = await statusTestbox(args.name);
+            if (!status.liveViewUrl) {
+                throw new TestboxError(status.container === "running"
+                    ? "The live view is not ready yet; try again in a moment"
+                    : "The box is not running; start it with: aximo device testbox up");
+            }
+            return { liveViewUrl: status.liveViewUrl };
+        }));
+    },
+});

package/dist/commands/device/user-devices.d.ts

@@ -0,0 +1,4 @@
+import { type ClientDeps } from "../../client.js";
+import type { UserDevice } from "../../types.js";
+/** The BYOD devices registered by this API key's owner. */
+export declare function listUserDevices(deps?: ClientDeps): Promise<UserDevice[]>;

package/dist/commands/device/user-devices.js

@@ -0,0 +1,18 @@
+import { request } from "../../client.js";
+/** The BYOD devices registered by this API key's owner. */
+export async function listUserDevices(deps = {}) {
+    try {
+        const res = await request("/api/devices/user", {}, deps);
+        return res.devices ?? [];
+    }
+    catch (err) {
+        // The route answers a bare 404 when the org has no BYOD feature.
+        if (err.status === 404) {
+            throw Object.assign(new Error("BYOD is not enabled for this organization"), {
+                status: 403,
+                details: { feature: "byodEnabled" },
+            });
+        }
+        throw err;
+    }
+}

package/dist/commands/mcp/server.d.ts

@@ -1,3 +1,3 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import type { ClientDeps } from "../../client.js";
-export declare function createMcpServer(deps?: ClientDeps): McpServer;
+import { type ToolDeps } from "./tools.js";
+export declare function createMcpServer(deps?: ToolDeps): McpServer;