@autifyhq/aximo-cli 0.1.0

package/dist/commands/device/logs.js

@@ -0,0 +1,160 @@
+import { defineCommand } from "citty";
+import { closeSync, existsSync, openSync, readSync, statSync, truncateSync, unwatchFile, watchFile, } from "node:fs";
+import { StringDecoder } from "node:string_decoder";
+import { formatError, formatSuccess, printResult } from "../../output.js";
+import { getRemoteLogPath } from "./paths.js";
+const DEFAULT_LINES = 50;
+const MAX_TAIL_BYTES = 1_024 * 1_024; // 1MB — enough for many hundreds of log lines
+function readTail(logPath, lines) {
+    const size = statSync(logPath).size;
+    if (size === 0)
+        return { lines: [], truncated: false };
+    const bytesToRead = Math.min(size, MAX_TAIL_BYTES);
+    const start = size - bytesToRead;
+    const buffer = Buffer.alloc(bytesToRead);
+    const fd = openSync(logPath, "r");
+    try {
+        readSync(fd, buffer, 0, bytesToRead, start);
+    }
+    finally {
+        closeSync(fd);
+    }
+    const text = buffer.toString("utf-8");
+    const all = text.split(/\r?\n/);
+    if (start > 0 && all.length > 0)
+        all.shift(); // drop partial first line
+    while (all.length > 0 && all[all.length - 1] === "")
+        all.pop();
+    const tail = all.slice(-lines);
+    return { lines: tail, truncated: start > 0 || all.length > lines };
+}
+export function runDeviceLogs(options = {}) {
+    const path = getRemoteLogPath();
+    if (options.path) {
+        return formatSuccess({ path });
+    }
+    if (options.clear) {
+        if (!existsSync(path)) {
+            return formatSuccess({ path, cleared: true });
+        }
+        try {
+            truncateSync(path, 0);
+            return formatSuccess({ path, cleared: true });
+        }
+        catch (err) {
+            return formatError("api_error", `Failed to clear log: ${err instanceof Error ? err.message : String(err)}`, false);
+        }
+    }
+    if (!existsSync(path)) {
+        return formatError("not_found", `Log file does not exist yet: ${path}`, false, "Start the agent with: aximo device connect");
+    }
+    const count = options.lines ?? DEFAULT_LINES;
+    if (!Number.isInteger(count) || count <= 0) {
+        return formatError("validation_error", "--lines must be a positive integer", false);
+    }
+    try {
+        const { lines, truncated } = readTail(path, count);
+        return formatSuccess({ path, lines, truncated });
+    }
+    catch (err) {
+        return formatError("api_error", `Failed to read log: ${err instanceof Error ? err.message : String(err)}`, false);
+    }
+}
+async function followLog() {
+    const path = getRemoteLogPath();
+    if (!existsSync(path)) {
+        console.error(`Waiting for log file: ${path}`);
+    }
+    let lastSize = existsSync(path) ? statSync(path).size : 0;
+    const decoder = new StringDecoder("utf8");
+    let carry = "";
+    const emit = (chunk) => {
+        if (!chunk)
+            return;
+        const combined = carry + chunk;
+        const lastNewline = combined.lastIndexOf("\n");
+        if (lastNewline === -1) {
+            carry = combined;
+            return;
+        }
+        const complete = combined.slice(0, lastNewline + 1);
+        carry = combined.slice(lastNewline + 1);
+        process.stdout.write(complete);
+    };
+    if (lastSize > 0) {
+        const { lines } = readTail(path, DEFAULT_LINES);
+        if (lines.length > 0)
+            process.stdout.write(`${lines.join("\n")}\n`);
+    }
+    return new Promise((_, reject) => {
+        const onChange = (curr) => {
+            if (curr.size < lastSize) {
+                lastSize = 0;
+                carry = "";
+                decoder.end();
+            }
+            if (curr.size <= lastSize)
+                return;
+            const toRead = curr.size - lastSize;
+            const buffer = Buffer.alloc(toRead);
+            let fd = null;
+            try {
+                fd = openSync(path, "r");
+                readSync(fd, buffer, 0, toRead, lastSize);
+                lastSize = curr.size;
+                emit(decoder.write(buffer));
+            }
+            catch (err) {
+                unwatchFile(path);
+                reject(err);
+            }
+            finally {
+                if (fd !== null)
+                    closeSync(fd);
+            }
+        };
+        watchFile(path, { interval: 500 }, onChange);
+        const cleanup = () => {
+            const tail = decoder.end() + carry;
+            if (tail)
+                process.stdout.write(tail);
+            unwatchFile(path);
+            process.exit(0);
+        };
+        process.on("SIGINT", cleanup);
+        process.on("SIGTERM", cleanup);
+    });
+}
+export default defineCommand({
+    meta: {
+        name: "logs",
+        description: "Show the BYOD remote agent log",
+    },
+    args: {
+        follow: {
+            type: "boolean",
+            alias: "f",
+            description: "Stream new log lines as they are written",
+        },
+        lines: {
+            type: "string",
+            alias: "n",
+            description: `Number of lines to show (default ${DEFAULT_LINES})`,
+        },
+        path: { type: "boolean", description: "Print log file path and exit" },
+        clear: { type: "boolean", description: "Truncate the log file" },
+    },
+    async run({ args }) {
+        if (args.follow) {
+            await followLog();
+            return;
+        }
+        const options = {
+            path: Boolean(args.path),
+            clear: Boolean(args.clear),
+        };
+        if (args.lines !== undefined)
+            options.lines = Number(args.lines);
+        printResult(runDeviceLogs(options));
+    },
+});

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

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

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

@@ -0,0 +1,70 @@
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from "vitest";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { runDeviceLogs } from "./logs.js";
+let tempHome;
+beforeAll(() => {
+    tempHome = mkdtempSync(join(tmpdir(), "aximo-logs-"));
+    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 });
+});
+describe("runDeviceLogs", () => {
+    it("--path returns the log file path without requiring the file to exist", () => {
+        const result = runDeviceLogs({ path: true });
+        expect(result.ok).toBe(true);
+        if (result.ok)
+            expect(result.data.path).toBe(join(tempHome, "remote.log"));
+    });
+    it("returns not_found when the log doesn't exist", () => {
+        const result = runDeviceLogs();
+        expect(result.ok).toBe(false);
+        if (!result.ok)
+            expect(result.error.code).toBe("not_found");
+    });
+    it("returns last N lines of the log", () => {
+        const logPath = join(tempHome, "remote.log");
+        writeFileSync(logPath, "a\nb\nc\nd\ne\n");
+        const result = runDeviceLogs({ lines: 3 });
+        expect(result.ok).toBe(true);
+        if (result.ok) {
+            expect(result.data.lines).toEqual(["c", "d", "e"]);
+            expect(result.data.truncated).toBe(true);
+        }
+    });
+    it("marks truncated=false when all lines fit", () => {
+        const logPath = join(tempHome, "remote.log");
+        writeFileSync(logPath, "a\nb\nc\n");
+        const result = runDeviceLogs({ lines: 5 });
+        expect(result.ok).toBe(true);
+        if (result.ok) {
+            expect(result.data.lines).toEqual(["a", "b", "c"]);
+            expect(result.data.truncated).toBe(false);
+        }
+    });
+    it("--clear truncates the log", () => {
+        const logPath = join(tempHome, "remote.log");
+        writeFileSync(logPath, "content");
+        const result = runDeviceLogs({ clear: true });
+        expect(result.ok).toBe(true);
+        expect(existsSync(logPath)).toBe(true);
+        expect(readFileSync(logPath, "utf-8")).toBe("");
+    });
+    it("rejects invalid --lines with validation_error", () => {
+        writeFileSync(join(tempHome, "remote.log"), "x\n");
+        const result = runDeviceLogs({ lines: 0 });
+        expect(result.ok).toBe(false);
+        if (!result.ok)
+            expect(result.error.code).toBe("validation_error");
+    });
+});

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

@@ -0,0 +1,12 @@
+export declare function getAximoDir(): string;
+export declare function getDeviceConfigPath(): string;
+export declare function getPythonDir(): string;
+export declare function getPythonMarkerPath(): string;
+export declare function getDepsMarkerPath(): string;
+export declare function getCacheDir(): string;
+export declare function getRemoteLogPath(): string;
+export declare function getAgentDir(): string;
+export declare function getAgentScriptPath(): string;
+export declare function getAgentRequirementsPath(): string;
+export declare function getAgentManifestPath(): string;
+export declare function getEmbeddedPythonBinary(): string;

package/dist/commands/device/paths.js

@@ -0,0 +1,40 @@
+import { homedir, platform } from "node:os";
+import { join } from "node:path";
+export function getAximoDir() {
+    return process.env["AXIMO_HOME"] ?? join(homedir(), ".aximo");
+}
+export function getDeviceConfigPath() {
+    return join(getAximoDir(), "device.json");
+}
+export function getPythonDir() {
+    return join(getAximoDir(), "python");
+}
+export function getPythonMarkerPath() {
+    return join(getAximoDir(), "python.version");
+}
+export function getDepsMarkerPath() {
+    return join(getAximoDir(), "python.deps.sha256");
+}
+export function getCacheDir() {
+    return join(getAximoDir(), "cache");
+}
+export function getRemoteLogPath() {
+    return join(getAximoDir(), "remote.log");
+}
+export function getAgentDir() {
+    return join(getAximoDir(), "agent");
+}
+export function getAgentScriptPath() {
+    return join(getAgentDir(), "remote.py");
+}
+export function getAgentRequirementsPath() {
+    return join(getAgentDir(), "requirements.txt");
+}
+export function getAgentManifestPath() {
+    return join(getAgentDir(), "manifest.json");
+}
+export function getEmbeddedPythonBinary() {
+    return platform() === "win32"
+        ? join(getPythonDir(), "python.exe")
+        : join(getPythonDir(), "bin", "python3");
+}

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

@@ -0,0 +1,21 @@
+import { type ClientDeps } from "../../client.js";
+import type { Envelope } from "../../types.js";
+export interface PingResult {
+    deviceId: string;
+    name: string;
+    status: "online" | "offline" | string;
+    lastSeenAt?: string;
+    lastSeenAgoSeconds?: number;
+    latencyMs: number;
+}
+export interface RunDevicePingOptions {
+    deviceId?: string;
+}
+export declare function runDevicePing(options?: RunDevicePingOptions, deps?: ClientDeps): Promise<Envelope<PingResult>>;
+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/ping.js

@@ -0,0 +1,66 @@
+import { defineCommand } from "citty";
+import { existsSync, readFileSync } from "node:fs";
+import { request } from "../../client.js";
+import { handleApiError } from "../../errors.js";
+import { formatError, formatSuccess, printResult } from "../../output.js";
+import { getDeviceConfigPath } from "./paths.js";
+function resolveDeviceId(explicit) {
+    if (explicit)
+        return explicit;
+    const configPath = getDeviceConfigPath();
+    if (!existsSync(configPath))
+        return null;
+    try {
+        const config = JSON.parse(readFileSync(configPath, "utf-8"));
+        return typeof config.deviceId === "string" ? config.deviceId : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function runDevicePing(options = {}, deps) {
+    const deviceId = resolveDeviceId(options.deviceId);
+    if (!deviceId) {
+        return formatError("validation_error", "No device ID provided and no local device config found", false, 'Register first: aximo device register --name "My PC", or pass --device-id');
+    }
+    const start = Date.now();
+    try {
+        const res = await request("/api/devices/user", {}, deps ?? {});
+        const latencyMs = Date.now() - start;
+        const device = res.devices?.find((d) => d.id === deviceId);
+        if (!device) {
+            return formatError("not_found", `Device ${deviceId} not visible for the current API key`, false, "Token may belong to another account, or the device was deleted server-side");
+        }
+        const lastSeenAgoSeconds = device.lastSeenAt
+            ? Math.max(0, Math.round((Date.now() - Date.parse(device.lastSeenAt)) / 1000))
+            : undefined;
+        return formatSuccess({
+            deviceId: device.id,
+            name: device.name,
+            status: device.status,
+            ...(device.lastSeenAt !== undefined ? { lastSeenAt: device.lastSeenAt } : {}),
+            ...(lastSeenAgoSeconds !== undefined ? { lastSeenAgoSeconds } : {}),
+            latencyMs,
+        });
+    }
+    catch (err) {
+        return handleApiError(err);
+    }
+}
+export default defineCommand({
+    meta: {
+        name: "ping",
+        description: "Check the current online status of your device from Aximo",
+    },
+    args: {
+        "device-id": { type: "string", description: "Device ID (defaults to local device)" },
+    },
+    async run({ args }) {
+        const deviceId = args["device-id"];
+        const result = await runDevicePing(deviceId ? { deviceId } : {});
+        printResult(result);
+        if (result.ok && result.data.status !== "online") {
+            process.exitCode = 1;
+        }
+    },
+});

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

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

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

@@ -0,0 +1,68 @@
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from "vitest";
+import { 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 { runDevicePing } from "./ping.js";
+let tempHome;
+beforeAll(() => {
+    tempHome = mkdtempSync(join(tmpdir(), "aximo-ping-"));
+    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());
+function seedDeviceConfig(deviceId) {
+    writeFileSync(join(tempHome, "device.json"), JSON.stringify({ deviceId, deviceToken: "t", name: "Test PC" }));
+}
+describe("runDevicePing", () => {
+    it("errors when no device config and no deviceId flag", async () => {
+        const result = await runDevicePing();
+        expect(result.ok).toBe(false);
+        if (!result.ok)
+            expect(result.error.code).toBe("validation_error");
+    });
+    it("reports online status with latency when device is found", async () => {
+        const deviceId = "550e8400-e29b-41d4-a716-446655440000";
+        seedDeviceConfig(deviceId);
+        const now = new Date().toISOString();
+        server.use(http.get(`${TEST_BASE_URL}/api/devices/user`, () => HttpResponse.json({
+            devices: [{ id: deviceId, name: "Test PC", status: "online", lastSeenAt: now }],
+        })));
+        const result = await runDevicePing();
+        expect(result.ok).toBe(true);
+        if (result.ok) {
+            expect(result.data.status).toBe("online");
+            expect(result.data.deviceId).toBe(deviceId);
+            expect(result.data.latencyMs).toBeGreaterThanOrEqual(0);
+        }
+    });
+    it("returns not_found when device isn't in the response", async () => {
+        seedDeviceConfig("550e8400-e29b-41d4-a716-446655440000");
+        server.use(http.get(`${TEST_BASE_URL}/api/devices/user`, () => HttpResponse.json({ devices: [] })));
+        const result = await runDevicePing();
+        expect(result.ok).toBe(false);
+        if (!result.ok)
+            expect(result.error.code).toBe("not_found");
+    });
+    it("accepts an explicit --device-id", async () => {
+        const deviceId = "aaaa-bbbb";
+        server.use(http.get(`${TEST_BASE_URL}/api/devices/user`, () => HttpResponse.json({
+            devices: [{ id: deviceId, name: "Other", status: "offline" }],
+        })));
+        const result = await runDevicePing({ deviceId });
+        expect(result.ok).toBe(true);
+        if (result.ok)
+            expect(result.data.status).toBe("offline");
+    });
+});

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

@@ -0,0 +1,23 @@
+import { type ClientDeps } from "../../client.js";
+import type { Envelope } from "../../types.js";
+export interface RegisterResult {
+    deviceId: string;
+    name: string;
+    registeredAt: string;
+}
+export declare function runDeviceRegister(options: {
+    name: string;
+    force?: boolean;
+}, deps?: ClientDeps): Promise<Envelope<RegisterResult>>;
+declare const _default: import("citty").CommandDef<{
+    readonly name: {
+        readonly type: "string";
+        readonly description: "Device name";
+        readonly required: true;
+    };
+    readonly force: {
+        readonly type: "boolean";
+        readonly description: "Overwrite an existing local registration (orphans the previous device)";
+    };
+}>;
+export default _default;

package/dist/commands/device/register.js

@@ -0,0 +1,83 @@
+import { defineCommand } from "citty";
+import { chmodSync, existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { platform, release } from "node:os";
+import { request } from "../../client.js";
+import { handleApiError } from "../../errors.js";
+import { formatError, formatSuccess, printResult } from "../../output.js";
+import { getAximoDir, getDeviceConfigPath } from "./paths.js";
+function detectPlatform() {
+    const p = platform();
+    if (p === "win32")
+        return "windows";
+    if (p === "darwin")
+        return "macos";
+    return "linux";
+}
+function detectOs() {
+    const p = platform();
+    const r = release();
+    if (p === "win32")
+        return `Windows ${r}`;
+    if (p === "darwin")
+        return `macOS ${r}`;
+    return `Linux ${r}`;
+}
+export async function runDeviceRegister(options, deps) {
+    try {
+        const configPath = getDeviceConfigPath();
+        if (existsSync(configPath) && !options.force) {
+            return formatError("validation_error", "A device is already registered on this machine. Run 'aximo device unregister' first, or pass --force to overwrite (this orphans the previous server-side device).", false);
+        }
+        const res = await request("/api/devices/register", {
+            method: "POST",
+            body: {
+                name: options.name,
+                platform: detectPlatform(),
+                os: detectOs(),
+            },
+        }, deps ?? {});
+        const aximoDir = getAximoDir();
+        if (!existsSync(aximoDir)) {
+            mkdirSync(aximoDir, { recursive: true });
+        }
+        const registeredAt = new Date().toISOString();
+        const config = {
+            deviceId: res.deviceId,
+            deviceToken: res.deviceToken,
+            name: options.name,
+            registeredAt,
+        };
+        writeFileSync(configPath, JSON.stringify(config, null, 2), { mode: 0o600 });
+        try {
+            chmodSync(configPath, 0o600);
+        }
+        catch {
+            // chmod may fail on Windows, file-level ACLs apply instead
+        }
+        return formatSuccess({
+            deviceId: res.deviceId,
+            name: options.name,
+            registeredAt,
+        });
+    }
+    catch (err) {
+        return handleApiError(err);
+    }
+}
+export default defineCommand({
+    meta: { name: "register", description: "Register this machine as an Aximo device" },
+    args: {
+        name: {
+            type: "string",
+            description: "Device name",
+            required: true,
+        },
+        force: {
+            type: "boolean",
+            description: "Overwrite an existing local registration (orphans the previous device)",
+        },
+    },
+    async run({ args }) {
+        printResult(await runDeviceRegister({ name: args.name, force: Boolean(args.force) }));
+    },
+});

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

@@ -0,0 +1,30 @@
+import type { Envelope } from "../../types.js";
+export interface ResetResult {
+    removed: string[];
+}
+export interface RunDeviceResetOptions {
+    python?: boolean;
+    deps?: boolean;
+    device?: boolean;
+    all?: boolean;
+}
+export declare function runDeviceReset(options?: RunDeviceResetOptions): Envelope<ResetResult>;
+declare const _default: import("citty").CommandDef<{
+    readonly python: {
+        readonly type: "boolean";
+        readonly description: "Remove embedded Python and markers";
+    };
+    readonly deps: {
+        readonly type: "boolean";
+        readonly description: "Remove deps marker so the next setup reinstalls packages";
+    };
+    readonly device: {
+        readonly type: "boolean";
+        readonly description: "Remove local device credentials and agent log";
+    };
+    readonly all: {
+        readonly type: "boolean";
+        readonly description: "Remove the entire ~/.aximo directory";
+    };
+}>;
+export default _default;

package/dist/commands/device/reset.js

@@ -0,0 +1,67 @@
+import { defineCommand } from "citty";
+import { existsSync, rmSync } from "node:fs";
+import { formatError, formatSuccess, printResult } from "../../output.js";
+import { getAximoDir, getCacheDir, getDepsMarkerPath, getDeviceConfigPath, getPythonDir, getPythonMarkerPath, getRemoteLogPath, } from "./paths.js";
+function removeIfExists(path, removed, opts = {}) {
+    if (!existsSync(path))
+        return;
+    rmSync(path, { recursive: opts.recursive ?? false, force: true });
+    removed.push(path);
+}
+export function runDeviceReset(options = {}) {
+    const { python, deps, device, all } = options;
+    if (!python && !deps && !device && !all) {
+        return formatError("validation_error", "Pass at least one of --python, --deps, --device, or --all", false);
+    }
+    const removed = [];
+    try {
+        if (all) {
+            removeIfExists(getAximoDir(), removed, { recursive: true });
+            return formatSuccess({ removed });
+        }
+        if (python) {
+            removeIfExists(getPythonDir(), removed, { recursive: true });
+            removeIfExists(getPythonMarkerPath(), removed);
+            removeIfExists(getDepsMarkerPath(), removed);
+            removeIfExists(getCacheDir(), removed, { recursive: true });
+        }
+        else if (deps) {
+            removeIfExists(getDepsMarkerPath(), removed);
+        }
+        if (device) {
+            removeIfExists(getDeviceConfigPath(), removed);
+            removeIfExists(getRemoteLogPath(), removed);
+        }
+        return formatSuccess({ removed });
+    }
+    catch (err) {
+        return formatError("api_error", `Reset failed: ${err instanceof Error ? err.message : String(err)}`, false);
+    }
+}
+export default defineCommand({
+    meta: {
+        name: "reset",
+        description: "Remove BYOD local state (Python install, deps, device credentials)",
+    },
+    args: {
+        python: { type: "boolean", description: "Remove embedded Python and markers" },
+        deps: {
+            type: "boolean",
+            description: "Remove deps marker so the next setup reinstalls packages",
+        },
+        device: { type: "boolean", description: "Remove local device credentials and agent log" },
+        all: { type: "boolean", description: "Remove the entire ~/.aximo directory" },
+    },
+    async run({ args }) {
+        const result = runDeviceReset({
+            python: Boolean(args.python),
+            deps: Boolean(args.deps),
+            device: Boolean(args.device),
+            all: Boolean(args.all),
+        });
+        printResult(result);
+        if (result.ok && args.device) {
+            console.error("\nNote: this only removed local credentials. The device row on the Aximo server still exists —\nrun `aximo device unregister` first if you want to delete it server-side.");
+        }
+    },
+});

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

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