@voxli/cli 0.2.1 → 0.3.0

package/README.md

@@ -1 +1,44 @@
-# voxli
+# @voxli/cli
+
+CLI agent for running [Voxli](https://voxli.io) test scenarios locally.
+
+## Install
+
+```sh
+npm install -g @voxli/cli
+```
+
+Requires Node.js 18+.
+
+## Setup
+
+Authenticate with your Voxli API key:
+
+```sh
+voxli auth
+```
+
+This saves your key to `~/.voxli/config.json`. You can also set the `VOXLI_API_KEY` environment variable instead.
+
+## Usage
+
+Start listening for test work:
+
+```sh
+voxli listen --command "<your test command>"
+```
+
+The CLI polls the Voxli API for pending test batches. When work arrives, it spawns your command as a subprocess with these environment variables:
+
+| Variable | Description |
+|---|---|
+| `VOXLI_API_KEY` | Your API key |
+| `TEST_RESULT_IDS` | JSON array of test result IDs to run |
+| `RUN_ID` | The run ID (if part of a run) |
+
+## Commands
+
+| Command | Description |
+|---|---|
+| `voxli auth` | Authenticate with your API key |
+| `voxli listen --command <cmd>` | Poll for pending test work and run it locally |

package/dist/cli.js

@@ -10,6 +10,7 @@ program
 program
     .command("auth")
     .description("Authenticate with your Voxli API key")
+    .option("--manual", "Enter API key manually instead of browser auth")
     .action(authCommand);
 program
     .command("listen")

package/dist/commands/auth.d.ts

@@ -1 +1,3 @@
-export declare function authCommand(): Promise<void>;
+export declare function authCommand(opts: {
+    manual?: boolean;
+}): Promise<void>;

package/dist/commands/auth.js

@@ -3,7 +3,8 @@ 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() {
+import { browserAuth } from "../lib/browser-auth.js";
+async function promptForKey() {
     const rl = createInterface({ input: stdin, output: stdout });
     try {
         const apiKey = await rl.question("Enter your Voxli API key: ");
@@ -11,29 +12,46 @@ export async function authCommand() {
             console.error("API key cannot be empty.");
             process.exit(1);
         }
-        const key = apiKey.trim();
-        // Validate by calling /agents/register
-        console.log("Validating...");
+        return apiKey.trim();
+    }
+    finally {
+        rl.close();
+    }
+}
+async function validateAndSave(key) {
+    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");
+}
+export async function authCommand(opts) {
+    if (!opts.manual) {
         try {
-            const hostname = getStableHostname();
-            await register(key, {
-                name: hostname,
-                unique_identifier: hostname,
-            });
-            console.log("API key is valid.");
+            const key = await browserAuth();
+            await validateAndSave(key);
+            return;
         }
         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.");
+            const msg = err instanceof Error ? err.message : String(err);
+            console.log(`\nBrowser auth failed: ${msg}`);
+            console.log("Falling back to manual key entry.\n");
         }
-        await writeConfig({ apiKey: key });
-        console.log("API key saved to ~/.voxli/config.json");
-    }
-    finally {
-        rl.close();
     }
+    const key = await promptForKey();
+    await validateAndSave(key);
 }

package/dist/commands/listen.js

@@ -36,6 +36,8 @@ export async function listenCommand(options) {
                 const env = {
                     ...process.env,
                     VOXLI_API_KEY: apiKey,
+                    VOXLI_API_URL: process.env.VOXLI_API_URL,
+                    VOXLI_APP_URL: process.env.VOXLI_APP_URL,
                     TEST_RESULT_IDS: JSON.stringify(testResultIds),
                 };
                 if (runId) {

package/dist/lib/browser-auth.d.ts

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

package/dist/lib/browser-auth.js

@@ -0,0 +1,99 @@
+import { createServer } from "node:http";
+import { randomBytes } from "node:crypto";
+import { execFile } from "node:child_process";
+import { createInterface } from "node:readline/promises";
+import { stdin, stdout } from "node:process";
+import { getStableHostname } from "./hostname.js";
+const AUTH_TIMEOUT_MS = 120_000;
+const DEFAULT_APP_URL = "https://app.voxli.io";
+function getAppUrl() {
+    return process.env.VOXLI_APP_URL || DEFAULT_APP_URL;
+}
+const SUCCESS_HTML = `<!DOCTYPE html>
+<html>
+<head><meta charset="utf-8"><title>Voxli CLI</title>
+<style>body{font-family:system-ui,sans-serif;display:flex;align-items:center;justify-content:center;height:100vh;margin:0;background:#f9fafb}
+.card{text-align:center;padding:2rem;border-radius:12px;background:#fff;box-shadow:0 1px 3px rgba(0,0,0,.1)}
+h1{color:#0a3b29;margin:0 0 .5rem}p{color:#6b7280;margin:0}</style></head>
+<body><div class="card"><h1>Authenticated!</h1><p>You can close this tab and return to the terminal.</p></div></body>
+</html>`;
+const ERROR_HTML = `<!DOCTYPE html>
+<html>
+<head><meta charset="utf-8"><title>Voxli CLI</title>
+<style>body{font-family:system-ui,sans-serif;display:flex;align-items:center;justify-content:center;height:100vh;margin:0;background:#f9fafb}
+.card{text-align:center;padding:2rem;border-radius:12px;background:#fff;box-shadow:0 1px 3px rgba(0,0,0,.1)}
+h1{color:#dc2626;margin:0 0 .5rem}p{color:#6b7280;margin:0}</style></head>
+<body><div class="card"><h1>Authentication failed</h1><p>State mismatch. Please try again.</p></div></body>
+</html>`;
+function openBrowser(url) {
+    const cmd = process.platform === "darwin"
+        ? "open"
+        : process.platform === "win32"
+            ? "cmd"
+            : "xdg-open";
+    const args = process.platform === "win32" ? ["/c", "start", url] : [url];
+    execFile(cmd, args, (err) => {
+        if (err) {
+            console.log(`\nOpen this URL in your browser:\n  ${url}\n`);
+        }
+    });
+}
+export async function browserAuth() {
+    const rl = createInterface({ input: stdin, output: stdout });
+    try {
+        await rl.question("Press Enter to open the browser to authenticate...");
+    }
+    finally {
+        rl.close();
+    }
+    return new Promise((resolve, reject) => {
+        const state = randomBytes(32).toString("hex");
+        const server = createServer((req, res) => {
+            const url = new URL(req.url ?? "/", `http://${req.headers.host}`);
+            if (url.pathname !== "/callback") {
+                res.writeHead(404);
+                res.end("Not found");
+                return;
+            }
+            const returnedKey = url.searchParams.get("key");
+            const returnedState = url.searchParams.get("state");
+            if (returnedState !== state) {
+                res.writeHead(403, { "Content-Type": "text/html" });
+                res.end(ERROR_HTML);
+                return;
+            }
+            if (!returnedKey) {
+                res.writeHead(400, { "Content-Type": "text/html" });
+                res.end(ERROR_HTML);
+                return;
+            }
+            res.writeHead(200, { "Content-Type": "text/html" });
+            res.end(SUCCESS_HTML);
+            cleanup();
+            resolve(returnedKey);
+        });
+        const timeout = setTimeout(() => {
+            cleanup();
+            reject(new Error("Browser authentication timed out after 2 minutes."));
+        }, AUTH_TIMEOUT_MS);
+        function cleanup() {
+            clearTimeout(timeout);
+            server.close();
+        }
+        server.listen(0, "127.0.0.1", () => {
+            const addr = server.address();
+            if (!addr || typeof addr === "string") {
+                cleanup();
+                reject(new Error("Failed to start local server."));
+                return;
+            }
+            const port = addr.port;
+            const hostname = encodeURIComponent(getStableHostname());
+            const authUrl = `${getAppUrl()}/cli-auth?port=${port}&state=${state}&hostname=${hostname}`;
+            console.log("Opening browser to authenticate...");
+            openBrowser(authUrl);
+            console.log(`Waiting for authentication (timeout: 2 min)...`);
+            console.log(`\nIf the browser didn't open, visit:\n  ${authUrl}\n`);
+        });
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voxli/cli",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "CLI agent for running Voxli test scenarios locally",
   "type": "module",
   "bin": {