@voxli/cli 0.1.0

package/README.md

@@ -0,0 +1 @@
+# voxli

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { authCommand } from "./commands/auth.js";
+import { listenCommand } from "./commands/listen.js";
+const program = new Command();
+program
+    .name("voxli")
+    .description("CLI agent for running Voxli test scenarios locally")
+    .version("0.1.0");
+program
+    .command("auth")
+    .description("Authenticate with your Voxli API key")
+    .action(authCommand);
+program
+    .command("listen")
+    .description("Poll for pending test work and run it locally")
+    .requiredOption("--command <cmd>", "Shell command to run per batch")
+    .action(listenCommand);
+program.parse();

package/dist/commands/auth.d.ts

@@ -0,0 +1 @@
+export declare function authCommand(): Promise<void>;

package/dist/commands/auth.js

@@ -0,0 +1,39 @@
+import { createInterface } from "node:readline/promises";
+import { stdin, stdout } from "node:process";
+import { writeConfig } from "../lib/config.js";
+import { register, ApiError } from "../lib/api.js";
+import { getStableHostname } from "../lib/hostname.js";
+export async function authCommand() {
+    const rl = createInterface({ input: stdin, output: stdout });
+    try {
+        const apiKey = await rl.question("Enter your Voxli API key: ");
+        if (!apiKey.trim()) {
+            console.error("API key cannot be empty.");
+            process.exit(1);
+        }
+        const key = apiKey.trim();
+        // Validate by calling /agents/register
+        console.log("Validating...");
+        try {
+            const hostname = getStableHostname();
+            await register(key, {
+                name: hostname,
+                unique_identifier: hostname,
+            });
+            console.log("API key is valid.");
+        }
+        catch (err) {
+            if (err instanceof ApiError && (err.status === 401 || err.status === 403)) {
+                console.error(`Authentication failed (${err.status}). Check your API key.`);
+                process.exit(1);
+            }
+            // Network error or other — warn but still save
+            console.warn("Warning: could not validate key (network error). Saving anyway.");
+        }
+        await writeConfig({ apiKey: key });
+        console.log("API key saved to ~/.voxli/config.json");
+    }
+    finally {
+        rl.close();
+    }
+}

package/dist/commands/listen.d.ts

@@ -0,0 +1,3 @@
+export declare function listenCommand(options: {
+    command: string;
+}): Promise<void>;

package/dist/commands/listen.js

@@ -0,0 +1,76 @@
+import { spawn } from "node:child_process";
+import { resolveApiKeyAsync } from "../lib/config.js";
+import { getStableHostname } from "../lib/hostname.js";
+import { register, ApiError } from "../lib/api.js";
+const POLL_INTERVAL = 5_000;
+export async function listenCommand(options) {
+    const apiKey = await resolveApiKeyAsync();
+    if (!apiKey) {
+        console.error("Error: No API key found. Set VOXLI_API_KEY or run `voxli auth`.");
+        process.exit(1);
+    }
+    const hostname = getStableHostname();
+    const children = new Set();
+    // Graceful shutdown
+    const shutdown = () => {
+        console.log("\nShutting down...");
+        for (const child of children) {
+            child.kill("SIGTERM");
+        }
+        process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    console.log(`Listening as ${hostname}...`);
+    while (true) {
+        try {
+            const data = await register(apiKey, {
+                name: hostname,
+                unique_identifier: hostname,
+            });
+            const testResultIds = data.test_result_ids ?? [];
+            if (testResultIds.length > 0) {
+                const runId = data.run_id;
+                const label = runId ? `run ${runId}` : "standalone";
+                console.log(`Spawning subprocess for ${testResultIds.length} test(s) (${label})`);
+                const env = {
+                    ...process.env,
+                    TEST_RESULT_IDS: JSON.stringify(testResultIds),
+                };
+                if (runId) {
+                    env.RUN_ID = runId;
+                }
+                const child = spawn(options.command, {
+                    stdio: "inherit",
+                    env,
+                    shell: true,
+                });
+                children.add(child);
+                child.on("error", (err) => {
+                    children.delete(child);
+                    console.error(`Subprocess (${label}) failed to start: ${err.message}`);
+                });
+                child.on("close", (code) => {
+                    children.delete(child);
+                    if (code !== 0 && code !== null) {
+                        console.log(`Subprocess (${label}) exited with code ${code}`);
+                    }
+                });
+                // Don't sleep when work was received — poll again immediately
+                continue;
+            }
+        }
+        catch (err) {
+            if (err instanceof ApiError) {
+                console.error(`Poll error: API ${err.status}`);
+            }
+            else {
+                console.error(`Poll error: ${err}`);
+            }
+        }
+        await sleep(POLL_INTERVAL);
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/lib/api.d.ts

@@ -0,0 +1,7 @@
+import type { RegisterPayload, RegisterResponse } from "../types.js";
+export declare function register(apiKey: string, payload: RegisterPayload): Promise<RegisterResponse>;
+export declare class ApiError extends Error {
+    status: number;
+    body: string;
+    constructor(status: number, body: string);
+}

package/dist/lib/api.js

@@ -0,0 +1,29 @@
+const DEFAULT_BASE_URL = "https://api.voxli.io";
+function getBaseUrl() {
+    return process.env.VOXLI_API_URL || DEFAULT_BASE_URL;
+}
+export async function register(apiKey, payload) {
+    const url = `${getBaseUrl()}/agents/register`;
+    const res = await fetch(url, {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${apiKey}`,
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify(payload),
+    });
+    if (!res.ok) {
+        throw new ApiError(res.status, await res.text());
+    }
+    return (await res.json());
+}
+export class ApiError extends Error {
+    status;
+    body;
+    constructor(status, body) {
+        super(`API error ${status}: ${body}`);
+        this.status = status;
+        this.body = body;
+        this.name = "ApiError";
+    }
+}

package/dist/lib/config.d.ts

@@ -0,0 +1,5 @@
+import type { VoxliConfig } from "../types.js";
+export declare function readConfig(): Promise<VoxliConfig | null>;
+export declare function writeConfig(config: VoxliConfig): Promise<void>;
+export declare function resolveApiKey(): string | null;
+export declare function resolveApiKeyAsync(): Promise<string | null>;

package/dist/lib/config.js

@@ -0,0 +1,35 @@
+import { readFile, writeFile, mkdir, chmod } from "node:fs/promises";
+import { join } from "node:path";
+import { homedir } from "node:os";
+const CONFIG_DIR = join(homedir(), ".voxli");
+const CONFIG_PATH = join(CONFIG_DIR, "config.json");
+export async function readConfig() {
+    try {
+        const raw = await readFile(CONFIG_PATH, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeConfig(config) {
+    await mkdir(CONFIG_DIR, { recursive: true });
+    await writeFile(CONFIG_PATH, JSON.stringify(config, null, 2) + "\n", {
+        mode: 0o600,
+    });
+    await chmod(CONFIG_PATH, 0o600);
+}
+export function resolveApiKey() {
+    const envKey = process.env.VOXLI_API_KEY;
+    if (envKey)
+        return envKey;
+    // Caller should await readConfig() for the file-based key
+    return null;
+}
+export async function resolveApiKeyAsync() {
+    const envKey = resolveApiKey();
+    if (envKey)
+        return envKey;
+    const config = await readConfig();
+    return config?.apiKey ?? null;
+}

package/dist/lib/hostname.d.ts

@@ -0,0 +1 @@
+export declare function getStableHostname(): string;

package/dist/lib/hostname.js

@@ -0,0 +1,16 @@
+import { execFileSync } from "node:child_process";
+import { hostname } from "node:os";
+export function getStableHostname() {
+    if (process.platform === "darwin") {
+        try {
+            const result = execFileSync("scutil", ["--get", "LocalHostName"], {
+                encoding: "utf-8",
+            });
+            return result.trim();
+        }
+        catch {
+            // fall through to os.hostname()
+        }
+    }
+    return hostname();
+}

package/dist/types.d.ts

@@ -0,0 +1,11 @@
+export interface VoxliConfig {
+    apiKey: string;
+}
+export interface RegisterPayload {
+    name: string;
+    unique_identifier: string;
+}
+export interface RegisterResponse {
+    test_result_ids?: string[];
+    run_id?: string;
+}

package/dist/types.js

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

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@voxli/cli",
+  "version": "0.1.0",
+  "description": "CLI agent for running Voxli test scenarios locally",
+  "type": "module",
+  "bin": {
+    "voxli": "./dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "commander": "^13.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.7.0"
+  }
+}