@autifyhq/aximo-cli 0.1.0

package/dist/commands/configure.d.ts

@@ -0,0 +1,24 @@
+import type { Envelope } from "../types.js";
+export interface ConfigureResult {
+    path: string;
+    baseUrl: string;
+    apiKeyConfigured: boolean;
+}
+export interface RunConfigureOptions {
+    baseUrl?: string;
+    apiKey?: string;
+    promptBaseUrl?: (currentOrDefault: string) => Promise<string>;
+    promptApiKey?: (currentRedacted: string | null) => Promise<string>;
+}
+export declare function runConfigure(options?: RunConfigureOptions): Promise<Envelope<ConfigureResult>>;
+declare const _default: import("citty").CommandDef<{
+    readonly "base-url": {
+        readonly type: "string";
+        readonly description: "Set base URL without prompting";
+    };
+    readonly "api-key": {
+        readonly type: "string";
+        readonly description: "Set API key without prompting";
+    };
+}>;
+export default _default;

package/dist/commands/configure.js

@@ -0,0 +1,103 @@
+import { defineCommand } from "citty";
+import { createInterface } from "node:readline/promises";
+import { DEFAULT_BASE_URL } from "../client.js";
+import { getConfigPath, loadConfig, saveConfig } from "../config.js";
+import { formatError, formatSuccess, printResult } from "../output.js";
+function redactKey(value) {
+    if (value.length <= 8)
+        return "***";
+    return `${value.slice(0, 4)}…${value.slice(-4)}`;
+}
+async function resolveBaseUrl(explicit, fallback, prompt) {
+    if (explicit !== undefined) {
+        const trimmed = explicit.trim();
+        return trimmed === "" ? fallback : trimmed;
+    }
+    if (prompt) {
+        const answer = (await prompt(fallback)).trim();
+        return answer === "" ? fallback : answer;
+    }
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const answer = (await rl.question(`Aximo base URL [${fallback}]: `)).trim();
+        return answer === "" ? fallback : answer;
+    }
+    finally {
+        rl.close();
+    }
+}
+async function resolveApiKey(explicit, existing, prompt) {
+    const hasExisting = typeof existing === "string" && existing.length > 0;
+    const hint = hasExisting ? redactKey(existing) : null;
+    if (explicit !== undefined) {
+        const trimmed = explicit.trim();
+        if (trimmed === "") {
+            if (!hasExisting)
+                return { error: "API key cannot be empty" };
+            return { apiKey: existing };
+        }
+        return { apiKey: trimmed };
+    }
+    const answer = prompt
+        ? (await prompt(hint)).trim()
+        : await askTTY(`API key [${hint ?? "required"}]: `);
+    if (answer === "") {
+        if (!hasExisting)
+            return { error: "API key is required" };
+        return { apiKey: existing };
+    }
+    return { apiKey: answer };
+}
+async function askTTY(prompt) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        return (await rl.question(prompt)).trim();
+    }
+    finally {
+        rl.close();
+    }
+}
+export async function runConfigure(options = {}) {
+    const existing = loadConfig();
+    const baseFallback = existing.baseUrl ?? DEFAULT_BASE_URL;
+    const needsPrompt = options.baseUrl === undefined || options.apiKey === undefined;
+    const hasPromptFns = Boolean(options.promptBaseUrl || options.promptApiKey);
+    if (needsPrompt && !hasPromptFns && !process.stdin.isTTY) {
+        return formatError("validation_error", "Non-interactive shell: pass --base-url and --api-key", false);
+    }
+    const baseUrl = await resolveBaseUrl(options.baseUrl, baseFallback, options.promptBaseUrl);
+    const apiKeyResult = await resolveApiKey(options.apiKey, existing.apiKey, options.promptApiKey);
+    if ("error" in apiKeyResult) {
+        return formatError("validation_error", apiKeyResult.error, false);
+    }
+    const normalizedBase = baseUrl.replace(/\/+$/, "");
+    const config = { baseUrl: normalizedBase, apiKey: apiKeyResult.apiKey };
+    saveConfig(config);
+    return formatSuccess({
+        path: getConfigPath(),
+        baseUrl: normalizedBase,
+        apiKeyConfigured: true,
+    });
+}
+export default defineCommand({
+    meta: {
+        name: "configure",
+        description: "Store API key and base URL in $AXIMO_HOME/config.json (mode 0600)",
+    },
+    args: {
+        "base-url": { type: "string", description: "Set base URL without prompting" },
+        "api-key": { type: "string", description: "Set API key without prompting" },
+    },
+    async run({ args }) {
+        const options = {};
+        if (args["base-url"] !== undefined)
+            options.baseUrl = args["base-url"];
+        if (args["api-key"] !== undefined)
+            options.apiKey = args["api-key"];
+        const result = await runConfigure(options);
+        printResult(result);
+        if (result.ok) {
+            console.error(`\nConfig saved to ${result.data.path} (mode 0600). Keep this file secret — it contains your API key in plain text.`);
+        }
+    },
+});

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

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

package/dist/commands/configure.test.js

@@ -0,0 +1,96 @@
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from "vitest";
+import { runConfigure } from "./configure.js";
+let tempHome;
+beforeAll(() => {
+    tempHome = mkdtempSync(join(tmpdir(), "aximo-configure-"));
+    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 });
+});
+function readSavedConfig() {
+    return JSON.parse(readFileSync(join(tempHome, "config.json"), "utf-8"));
+}
+describe("runConfigure", () => {
+    it("writes both base URL and API key from flags", async () => {
+        const result = await runConfigure({
+            baseUrl: "https://custom.example.com/",
+            apiKey: "sk-test-123",
+        });
+        expect(result.ok).toBe(true);
+        if (!result.ok)
+            return;
+        expect(result.data.baseUrl).toBe("https://custom.example.com");
+        expect(result.data.apiKeyConfigured).toBe(true);
+        const saved = readSavedConfig();
+        expect(saved.apiKey).toBe("sk-test-123");
+        expect(saved.baseUrl).toBe("https://custom.example.com");
+    });
+    it("defaults empty URL prompt to the Aximo default when no prior config", async () => {
+        const result = await runConfigure({
+            promptBaseUrl: async () => "",
+            promptApiKey: async () => "sk-new",
+        });
+        expect(result.ok).toBe(true);
+        if (!result.ok)
+            return;
+        expect(result.data.baseUrl).toBe("https://aximo.autify.com");
+        expect(readSavedConfig().baseUrl).toBe("https://aximo.autify.com");
+    });
+    it("keeps the saved base URL when prompt is left empty", async () => {
+        writeFileSync(join(tempHome, "config.json"), JSON.stringify({ baseUrl: "https://saved.example.com", apiKey: "sk-old" }));
+        const result = await runConfigure({
+            promptBaseUrl: async () => "",
+            promptApiKey: async () => "",
+        });
+        expect(result.ok).toBe(true);
+        if (!result.ok)
+            return;
+        expect(result.data.baseUrl).toBe("https://saved.example.com");
+        const saved = readSavedConfig();
+        expect(saved.baseUrl).toBe("https://saved.example.com");
+        expect(saved.apiKey).toBe("sk-old");
+    });
+    it("fails when API key is empty and nothing is saved", async () => {
+        const result = await runConfigure({
+            promptBaseUrl: async () => "https://x.example.com",
+            promptApiKey: async () => "",
+        });
+        expect(result.ok).toBe(false);
+        if (!result.ok)
+            expect(result.error.code).toBe("validation_error");
+        expect(existsSync(join(tempHome, "config.json"))).toBe(false);
+    });
+    it("passes a redacted existing key hint to the prompt", async () => {
+        writeFileSync(join(tempHome, "config.json"), JSON.stringify({ baseUrl: "https://saved.example.com", apiKey: "sk-secretvalue-xyz" }));
+        let seenHint = "unset";
+        await runConfigure({
+            baseUrl: "https://saved.example.com",
+            promptApiKey: async (hint) => {
+                seenHint = hint;
+                return "";
+            },
+        });
+        expect(seenHint).not.toBeNull();
+        expect(seenHint).toContain("sk-s");
+        expect(seenHint).not.toContain("secretvalue");
+    });
+    it("normalizes trailing slashes on the base URL", async () => {
+        const result = await runConfigure({
+            baseUrl: "https://example.com////",
+            apiKey: "sk-1",
+        });
+        expect(result.ok).toBe(true);
+        if (!result.ok)
+            return;
+        expect(result.data.baseUrl).toBe("https://example.com");
+    });
+});

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

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

package/dist/commands/device/connect.js

@@ -0,0 +1,84 @@
+import { defineCommand } from "citty";
+import { existsSync, readFileSync } from "node:fs";
+import { getBaseUrl } from "../../client.js";
+import { formatError, printResult } from "../../output.js";
+import { getDeviceConfigPath } from "./paths.js";
+function loadConfig() {
+    const configPath = getDeviceConfigPath();
+    if (!existsSync(configPath))
+        return null;
+    try {
+        const parsed = JSON.parse(readFileSync(configPath, "utf-8"));
+        if (!parsed || typeof parsed !== "object")
+            return null;
+        const raw = parsed;
+        if (typeof raw.deviceId !== "string" ||
+            typeof raw.deviceToken !== "string" ||
+            typeof raw.name !== "string") {
+            return null;
+        }
+        return { deviceId: raw.deviceId, deviceToken: raw.deviceToken, name: raw.name };
+    }
+    catch {
+        return null;
+    }
+}
+function getRelayUrl() {
+    const base = getBaseUrl();
+    return `${base.replace(/^http/, "ws")}/devices/tunnel`;
+}
+async function connectToRelay(config) {
+    const { ensurePythonReady, startDesktopRemote } = await import("../../desktop-server/setup.js");
+    console.log("Preparing Python environment...");
+    const { pythonPath, scriptPath, agentVersion } = await ensurePythonReady();
+    console.log(`Python ready: ${pythonPath}`);
+    console.log(`Agent version: ${agentVersion}`);
+    const relayUrl = getRelayUrl();
+    console.log(`Starting desktop agent, relay: ${relayUrl}`);
+    let remoteProcess = startDesktopRemote(pythonPath, scriptPath, {
+        relayUrl,
+        deviceToken: config.deviceToken,
+        deviceName: config.name,
+    });
+    let shuttingDown = false;
+    const cleanup = () => {
+        shuttingDown = true;
+        if (remoteProcess) {
+            remoteProcess.kill();
+            remoteProcess = null;
+        }
+    };
+    process.on("SIGINT", () => {
+        console.log("\nDisconnecting...");
+        cleanup();
+        process.exit(0);
+    });
+    process.on("SIGTERM", () => {
+        cleanup();
+        process.exit(0);
+    });
+    remoteProcess.on("exit", (code) => {
+        if (!shuttingDown) {
+            console.error(`Desktop agent exited with code ${code}`);
+            process.exit(code ?? 1);
+        }
+    });
+    await new Promise(() => { });
+}
+export default defineCommand({
+    meta: { name: "connect", description: "Connect this device to Aximo for test execution" },
+    args: {},
+    async run() {
+        const config = loadConfig();
+        if (!config) {
+            printResult(formatError("validation_error", 'No device registered. Run: aximo device register --name "My PC"', false));
+            return;
+        }
+        try {
+            await connectToRelay(config);
+        }
+        catch (error) {
+            printResult(formatError("api_error", error instanceof Error ? error.message : String(error), true));
+        }
+    },
+});

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

@@ -0,0 +1,34 @@
+import { type ClientDeps } from "../../client.js";
+import type { Envelope } from "../../types.js";
+export type CheckStatus = "pass" | "warn" | "fail" | "info";
+export interface Check {
+    name: string;
+    status: CheckStatus;
+    message: string;
+    hint?: string;
+}
+export interface DoctorReport {
+    checks: Check[];
+    summary: {
+        pass: number;
+        warn: number;
+        fail: number;
+        info: number;
+    };
+}
+export interface RunDoctorOptions {
+    skipRelay?: boolean;
+    skipApi?: boolean;
+}
+export declare function runDeviceDoctor(options?: RunDoctorOptions, deps?: ClientDeps): Promise<Envelope<DoctorReport>>;
+declare const _default: import("citty").CommandDef<{
+    readonly "skip-relay": {
+        readonly type: "boolean";
+        readonly description: "Skip WebSocket reachability check";
+    };
+    readonly "skip-api": {
+        readonly type: "boolean";
+        readonly description: "Skip Aximo API calls (offline check only)";
+    };
+}>;
+export default _default;