@autifyhq/aximo-cli 0.1.0

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

@@ -0,0 +1,69 @@
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from "vitest";
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { runDeviceReset } from "./reset.js";
+let tempHome;
+beforeAll(() => {
+    tempHome = mkdtempSync(join(tmpdir(), "aximo-reset-"));
+    process.env["AXIMO_HOME"] = tempHome;
+});
+afterAll(() => {
+    delete process.env["AXIMO_HOME"];
+    rmSync(tempHome, { recursive: true, force: true });
+});
+beforeEach(() => {
+    rmSync(tempHome, { recursive: true, force: true });
+    mkdirSync(tempHome, { recursive: true });
+});
+afterEach(() => {
+    rmSync(tempHome, { recursive: true, force: true });
+});
+function seedAll() {
+    mkdirSync(join(tempHome, "python", "bin"), { recursive: true });
+    mkdirSync(join(tempHome, "cache"), { recursive: true });
+    writeFileSync(join(tempHome, "python.version"), "tag", { mode: 0o644 });
+    writeFileSync(join(tempHome, "python.deps.sha256"), "hash", { mode: 0o644 });
+    writeFileSync(join(tempHome, "device.json"), "{}", { mode: 0o600 });
+    writeFileSync(join(tempHome, "remote.log"), "log", { mode: 0o644 });
+}
+describe("runDeviceReset", () => {
+    it("rejects when no flags are passed", () => {
+        const result = runDeviceReset();
+        expect(result.ok).toBe(false);
+        if (!result.ok)
+            expect(result.error.code).toBe("validation_error");
+    });
+    it("--python removes python dir, markers, and cache, leaves device config", () => {
+        seedAll();
+        const result = runDeviceReset({ python: true });
+        expect(result.ok).toBe(true);
+        expect(existsSync(join(tempHome, "python"))).toBe(false);
+        expect(existsSync(join(tempHome, "python.version"))).toBe(false);
+        expect(existsSync(join(tempHome, "python.deps.sha256"))).toBe(false);
+        expect(existsSync(join(tempHome, "cache"))).toBe(false);
+        expect(existsSync(join(tempHome, "device.json"))).toBe(true);
+    });
+    it("--deps removes only the deps marker", () => {
+        seedAll();
+        const result = runDeviceReset({ deps: true });
+        expect(result.ok).toBe(true);
+        expect(existsSync(join(tempHome, "python.deps.sha256"))).toBe(false);
+        expect(existsSync(join(tempHome, "python"))).toBe(true);
+        expect(existsSync(join(tempHome, "python.version"))).toBe(true);
+    });
+    it("--device removes device.json and log, leaves python", () => {
+        seedAll();
+        const result = runDeviceReset({ device: true });
+        expect(result.ok).toBe(true);
+        expect(existsSync(join(tempHome, "device.json"))).toBe(false);
+        expect(existsSync(join(tempHome, "remote.log"))).toBe(false);
+        expect(existsSync(join(tempHome, "python"))).toBe(true);
+    });
+    it("--all wipes ~/.aximo entirely", () => {
+        seedAll();
+        const result = runDeviceReset({ all: true });
+        expect(result.ok).toBe(true);
+        expect(existsSync(tempHome)).toBe(false);
+    });
+});

package/dist/commands/device/setup.d.ts

@@ -0,0 +1,25 @@
+import { type ClientDeps } from "../../client.js";
+import type { Envelope } from "../../types.js";
+export interface SetupResult {
+    apiReachable: boolean;
+    pythonInstalled: boolean;
+    deviceRegistered: boolean;
+    deviceId?: string;
+    deviceName?: string;
+    alreadyRegistered: boolean;
+}
+export interface RunDeviceSetupOptions {
+    name?: string;
+}
+interface SetupDeps extends ClientDeps {
+    ensurePython?: () => Promise<unknown>;
+    promptName?: () => Promise<string | null>;
+}
+export declare function runDeviceSetup(options?: RunDeviceSetupOptions, deps?: SetupDeps): Promise<Envelope<SetupResult>>;
+declare const _default: import("citty").CommandDef<{
+    readonly name: {
+        readonly type: "string";
+        readonly description: "Device name (skipped if already registered)";
+    };
+}>;
+export default _default;

package/dist/commands/device/setup.js

@@ -0,0 +1,105 @@
+import { defineCommand } from "citty";
+import { existsSync, readFileSync } from "node:fs";
+import { createInterface } from "node:readline/promises";
+import { request } from "../../client.js";
+import { handleApiError } from "../../errors.js";
+import { formatError, formatSuccess, printResult } from "../../output.js";
+import { runDeviceRegister } from "./register.js";
+import { getDeviceConfigPath } from "./paths.js";
+function loadExistingDevice() {
+    const configPath = getDeviceConfigPath();
+    if (!existsSync(configPath))
+        return null;
+    try {
+        const parsed = JSON.parse(readFileSync(configPath, "utf-8"));
+        if (typeof parsed.deviceId === "string" && typeof parsed.name === "string") {
+            return { deviceId: parsed.deviceId, name: parsed.name };
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+async function promptDeviceName() {
+    if (!process.stdin.isTTY)
+        return null;
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const answer = (await rl.question("Device name: ")).trim();
+        return answer || null;
+    }
+    finally {
+        rl.close();
+    }
+}
+export async function runDeviceSetup(options = {}, deps) {
+    try {
+        await request("/api/health", {}, deps ?? {});
+    }
+    catch (err) {
+        return handleApiError(err);
+    }
+    try {
+        if (deps?.ensurePython) {
+            await deps.ensurePython();
+        }
+        else {
+            const mod = await import("../../desktop-server/setup.js");
+            await mod.ensurePythonReady();
+        }
+    }
+    catch (err) {
+        return formatError("api_error", `Python setup failed: ${err instanceof Error ? err.message : String(err)}`, true);
+    }
+    const existing = loadExistingDevice();
+    if (existing) {
+        return formatSuccess({
+            apiReachable: true,
+            pythonInstalled: true,
+            deviceRegistered: true,
+            alreadyRegistered: true,
+            deviceId: existing.deviceId,
+            deviceName: existing.name,
+        });
+    }
+    let name = options.name?.trim();
+    if (!name) {
+        const prompted = deps?.promptName ? await deps.promptName() : await promptDeviceName();
+        if (prompted)
+            name = prompted;
+    }
+    if (!name) {
+        return formatError("validation_error", "Device name required: pass --name, or run in an interactive terminal", false);
+    }
+    const registered = await runDeviceRegister({ name }, deps);
+    if (!registered.ok)
+        return registered;
+    return formatSuccess({
+        apiReachable: true,
+        pythonInstalled: true,
+        deviceRegistered: true,
+        alreadyRegistered: false,
+        deviceId: registered.data.deviceId,
+        deviceName: name,
+    });
+}
+export default defineCommand({
+    meta: {
+        name: "setup",
+        description: "First-time onboarding: checks API, installs Python, registers device",
+    },
+    args: {
+        name: { type: "string", description: "Device name (skipped if already registered)" },
+    },
+    async run({ args }) {
+        const options = {};
+        if (args.name !== undefined)
+            options.name = args.name;
+        const result = await runDeviceSetup(options);
+        printResult(result);
+        if (result.ok) {
+            console.error("\nNext: aximo device connect");
+        }
+    },
+});

package/dist/commands/device/setup.test.d.ts

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

package/dist/commands/device/setup.test.js

@@ -0,0 +1,64 @@
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from "vitest";
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { server, http, HttpResponse, TEST_BASE_URL } from "../../test-utils.js";
+import { runDeviceSetup } from "./setup.js";
+let tempHome;
+beforeAll(() => {
+    tempHome = mkdtempSync(join(tmpdir(), "aximo-setup-"));
+    process.env["AXIMO_HOME"] = tempHome;
+    process.env["AXIMO_API_KEY"] = "test-key";
+    process.env["AXIMO_BASE_URL"] = TEST_BASE_URL;
+    server.listen();
+});
+afterAll(() => {
+    delete process.env["AXIMO_HOME"];
+    server.close();
+    rmSync(tempHome, { recursive: true, force: true });
+});
+beforeEach(() => {
+    rmSync(tempHome, { recursive: true, force: true });
+    mkdirSync(tempHome, { recursive: true });
+});
+afterEach(() => server.resetHandlers());
+const noopPython = async () => {
+    // no-op: skip real Python install in tests
+};
+describe("runDeviceSetup", () => {
+    it("fails with validation_error if no name and stdin is not a TTY", async () => {
+        server.use(http.get(`${TEST_BASE_URL}/api/health`, () => HttpResponse.json({ status: "ok" })));
+        const result = await runDeviceSetup({}, { ensurePython: noopPython, promptName: async () => null });
+        expect(result.ok).toBe(false);
+        if (!result.ok)
+            expect(result.error.code).toBe("validation_error");
+    });
+    it("registers a new device and writes config", async () => {
+        server.use(http.get(`${TEST_BASE_URL}/api/health`, () => HttpResponse.json({ status: "ok" })), http.post(`${TEST_BASE_URL}/api/devices/register`, () => HttpResponse.json({ deviceId: "dev-1", deviceToken: "tok-1" })));
+        const result = await runDeviceSetup({ name: "My PC" }, { ensurePython: noopPython });
+        expect(result.ok).toBe(true);
+        if (!result.ok)
+            return;
+        expect(result.data.deviceId).toBe("dev-1");
+        expect(result.data.alreadyRegistered).toBe(false);
+        expect(existsSync(join(tempHome, "device.json"))).toBe(true);
+    });
+    it("reports alreadyRegistered and skips re-registration", async () => {
+        writeFileSync(join(tempHome, "device.json"), JSON.stringify({ deviceId: "existing-id", deviceToken: "t", name: "Old PC" }));
+        server.use(http.get(`${TEST_BASE_URL}/api/health`, () => HttpResponse.json({ status: "ok" })));
+        const result = await runDeviceSetup({ name: "Ignored" }, { ensurePython: noopPython });
+        expect(result.ok).toBe(true);
+        if (!result.ok)
+            return;
+        expect(result.data.alreadyRegistered).toBe(true);
+        expect(result.data.deviceId).toBe("existing-id");
+        expect(result.data.deviceName).toBe("Old PC");
+    });
+    it("propagates a health check failure", async () => {
+        server.use(http.get(`${TEST_BASE_URL}/api/health`, () => HttpResponse.json({ error: "boom" }, { status: 503 })));
+        const result = await runDeviceSetup({ name: "My PC" }, { ensurePython: noopPython });
+        expect(result.ok).toBe(false);
+        if (!result.ok)
+            expect(result.error.retryable).toBe(true);
+    });
+});

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

@@ -0,0 +1,16 @@
+import { type ClientDeps } from "../../client.js";
+import type { Envelope } from "../../types.js";
+interface UserDevice {
+    id: string;
+    name: string;
+    platform: string;
+    os?: string;
+    status: string;
+    lastSeenAt?: string;
+    createdAt: string;
+}
+export declare function runDeviceStatus(deps?: ClientDeps): Promise<Envelope<{
+    devices: UserDevice[];
+}>>;
+declare const _default: import("citty").CommandDef<import("citty").ArgsDef>;
+export default _default;

package/dist/commands/device/status.js

@@ -0,0 +1,20 @@
+import { defineCommand } from "citty";
+import { request } from "../../client.js";
+import { handleApiError } from "../../errors.js";
+import { formatSuccess, printResult } from "../../output.js";
+export async function runDeviceStatus(deps) {
+    try {
+        const res = await request("/api/devices/user", {}, deps ?? {});
+        const devices = res.devices ?? [];
+        return formatSuccess({ devices }, { total: devices.length });
+    }
+    catch (err) {
+        return handleApiError(err);
+    }
+}
+export default defineCommand({
+    meta: { name: "status", description: "List your registered devices" },
+    async run() {
+        printResult(await runDeviceStatus());
+    },
+});

package/dist/commands/device/unregister.d.ts

@@ -0,0 +1,14 @@
+import { type ClientDeps } from "../../client.js";
+import type { Envelope } from "../../types.js";
+export declare function runDeviceUnregister(options: {
+    deviceId?: string;
+}, deps?: ClientDeps): Promise<Envelope<{
+    success: boolean;
+}>>;
+declare const _default: import("citty").CommandDef<{
+    readonly "device-id": {
+        readonly type: "string";
+        readonly description: "Device ID (defaults to local device)";
+    };
+}>;
+export default _default;

package/dist/commands/device/unregister.js

@@ -0,0 +1,60 @@
+import { defineCommand } from "citty";
+import { existsSync, unlinkSync, readFileSync } from "node:fs";
+import { request } from "../../client.js";
+import { handleApiError } from "../../errors.js";
+import { formatSuccess, formatError, printResult } from "../../output.js";
+import { getDeviceConfigPath } from "./paths.js";
+export async function runDeviceUnregister(options, deps) {
+    let deviceId = options.deviceId;
+    if (!deviceId && existsSync(getDeviceConfigPath())) {
+        try {
+            const config = JSON.parse(readFileSync(getDeviceConfigPath(), "utf-8"));
+            if (config &&
+                typeof config === "object" &&
+                typeof config.deviceId === "string") {
+                deviceId = config.deviceId;
+            }
+            else {
+                return formatError("validation_error", "Device config is malformed: missing deviceId", false);
+            }
+        }
+        catch {
+            return formatError("validation_error", "Failed to read device config", false);
+        }
+    }
+    if (!deviceId) {
+        return formatError("validation_error", "No device ID provided and no local device config found. " +
+            "Pass a device ID or register first with: aximo device register", false);
+    }
+    try {
+        await request(`/api/devices/user/${deviceId}`, { method: "DELETE" }, deps ?? {});
+        if (existsSync(getDeviceConfigPath())) {
+            try {
+                const config = JSON.parse(readFileSync(getDeviceConfigPath(), "utf-8"));
+                if (config.deviceId === deviceId) {
+                    unlinkSync(getDeviceConfigPath());
+                }
+            }
+            catch {
+                // non-fatal
+            }
+        }
+        return formatSuccess({ success: true });
+    }
+    catch (err) {
+        return handleApiError(err);
+    }
+}
+export default defineCommand({
+    meta: { name: "unregister", description: "Unregister a device" },
+    args: {
+        "device-id": {
+            type: "string",
+            description: "Device ID (defaults to local device)",
+        },
+    },
+    async run({ args }) {
+        const deviceId = args["device-id"];
+        printResult(await runDeviceUnregister(deviceId ? { deviceId } : {}));
+    },
+});

package/dist/commands/health/check.d.ts

@@ -0,0 +1,5 @@
+import type { Envelope, HealthStatus } from "../../types.js";
+import { type ClientDeps } from "../../client.js";
+export declare function runHealthCheck(deps?: ClientDeps): Promise<Envelope<HealthStatus>>;
+declare const _default: import("citty").CommandDef<import("citty").ArgsDef>;
+export default _default;

package/dist/commands/health/check.js

@@ -0,0 +1,20 @@
+import { defineCommand } from "citty";
+import { formatSuccess, printResult } from "../../output.js";
+import { handleApiError } from "../../errors.js";
+import { request } from "../../client.js";
+export async function runHealthCheck(deps) {
+    try {
+        // /api/health may return empty body; we normalize to { status: "ok" }
+        await request("/api/health", {}, deps ?? {});
+        return formatSuccess({ status: "ok" });
+    }
+    catch (err) {
+        return handleApiError(err);
+    }
+}
+export default defineCommand({
+    meta: { name: "check", description: "Check Aximo API health" },
+    async run() {
+        printResult(await runHealthCheck());
+    },
+});

package/dist/commands/health/check.test.d.ts

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

package/dist/commands/health/check.test.js

@@ -0,0 +1,26 @@
+import { afterAll, afterEach, beforeAll, describe, expect, it } from "vitest";
+import { server, http, HttpResponse, TEST_BASE_URL } from "../../test-utils.js";
+import { runHealthCheck } from "./check.js";
+beforeAll(() => {
+    process.env["AXIMO_API_KEY"] = "test-key";
+    process.env["AXIMO_BASE_URL"] = TEST_BASE_URL;
+    server.listen();
+});
+afterEach(() => server.resetHandlers());
+afterAll(() => server.close());
+describe("runHealthCheck", () => {
+    it("returns ok envelope on 200", async () => {
+        server.use(http.get(`${TEST_BASE_URL}/api/health`, () => new HttpResponse(null, { status: 200 })));
+        const result = await runHealthCheck();
+        expect(result).toEqual({ ok: true, data: { status: "ok" } });
+    });
+    it("maps 500 to api_error retryable", async () => {
+        server.use(http.get(`${TEST_BASE_URL}/api/health`, () => HttpResponse.json({ error: "Internal" }, { status: 500 })));
+        const result = await runHealthCheck();
+        expect(result.ok).toBe(false);
+        if (!result.ok) {
+            expect(result.error.code).toBe("api_error");
+            expect(result.error.retryable).toBe(true);
+        }
+    });
+});

package/dist/commands/health/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("citty").CommandDef<import("citty").ArgsDef>;
+export default _default;

package/dist/commands/health/index.js

@@ -0,0 +1,7 @@
+import { defineCommand } from "citty";
+export default defineCommand({
+    meta: { name: "health", description: "Health check commands" },
+    subCommands: {
+        check: () => import("./check.js").then((m) => m.default),
+    },
+});

package/dist/commands/project/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("citty").CommandDef<import("citty").ArgsDef>;
+export default _default;

package/dist/commands/project/index.js

@@ -0,0 +1,7 @@
+import { defineCommand } from "citty";
+export default defineCommand({
+    meta: { name: "project", description: "Project (workspace) commands" },
+    subCommands: {
+        list: () => import("./list.js").then((m) => m.default),
+    },
+});

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

@@ -0,0 +1,7 @@
+import type { Envelope, Project } from "../../types.js";
+import { type ClientDeps } from "../../client.js";
+export declare function runProjectList(deps?: ClientDeps): Promise<Envelope<{
+    projects: Project[];
+}>>;
+declare const _default: import("citty").CommandDef<import("citty").ArgsDef>;
+export default _default;

package/dist/commands/project/list.js

@@ -0,0 +1,20 @@
+import { defineCommand } from "citty";
+import { formatSuccess, printResult } from "../../output.js";
+import { handleApiError } from "../../errors.js";
+import { request } from "../../client.js";
+export async function runProjectList(deps) {
+    try {
+        const res = await request("/api/organizations/projects", {}, deps ?? {});
+        const projects = res.projects ?? [];
+        return formatSuccess({ projects }, { total: projects.length });
+    }
+    catch (err) {
+        return handleApiError(err);
+    }
+}
+export default defineCommand({
+    meta: { name: "list", description: "List accessible Aximo projects" },
+    async run() {
+        printResult(await runProjectList());
+    },
+});

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

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

package/dist/commands/project/list.test.js

@@ -0,0 +1,28 @@
+import { afterAll, afterEach, beforeAll, describe, expect, it } from "vitest";
+import { server, http, HttpResponse, TEST_BASE_URL } from "../../test-utils.js";
+import { runProjectList } from "./list.js";
+beforeAll(() => {
+    process.env["AXIMO_API_KEY"] = "test-key";
+    process.env["AXIMO_BASE_URL"] = TEST_BASE_URL;
+    server.listen();
+});
+afterEach(() => server.resetHandlers());
+afterAll(() => server.close());
+describe("runProjectList", () => {
+    it("returns projects + total meta", async () => {
+        server.use(http.get(`${TEST_BASE_URL}/api/organizations/projects`, () => HttpResponse.json({ projects: [{ id: "p1", name: "Foo" }] })));
+        const result = await runProjectList();
+        expect(result.ok).toBe(true);
+        if (result.ok) {
+            expect(result.data.projects).toHaveLength(1);
+            expect(result.meta?.total).toBe(1);
+        }
+    });
+    it("maps 401 to unauthorized", async () => {
+        server.use(http.get(`${TEST_BASE_URL}/api/organizations/projects`, () => HttpResponse.json({ error: "Unauthorized" }, { status: 401 })));
+        const result = await runProjectList();
+        expect(result.ok).toBe(false);
+        if (!result.ok)
+            expect(result.error.code).toBe("unauthorized");
+    });
+});

package/dist/commands/schema.d.ts

@@ -0,0 +1,27 @@
+interface ArgSchema {
+    name: string;
+    type: string;
+    description: string;
+    required: boolean;
+}
+interface CommandSchema {
+    name: string;
+    description: string;
+    args: ArgSchema[];
+    subCommands?: CommandSchema[];
+}
+interface Schema {
+    name: string;
+    version: string;
+    commands: CommandSchema[];
+}
+export declare function getSchema(): Schema;
+export declare function lookupCommand(path: string): CommandSchema | undefined;
+declare const _default: import("citty").CommandDef<{
+    readonly command: {
+        readonly type: "positional";
+        readonly description: "Command path (e.g. session.create)";
+        readonly required: false;
+    };
+}>;
+export default _default;