@voxli/cli 0.5.0 → 0.6.0

package/dist/cli.js

@@ -20,5 +20,6 @@ program
     .command("listen")
     .description("Poll for pending test work and run it locally")
     .requiredOption("--command <cmd>", "Shell command to run per batch")
+    .option("--name <name>", "Display name for this agent (defaults to hostname)")
     .action(listenCommand);
 program.parse();

package/dist/commands/listen.d.ts

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

package/dist/commands/listen.js

@@ -1,7 +1,7 @@
 import { join } from "node:path";
 import { spawn } from "node:child_process";
 import { resolveApiKey, resolveConfig, attemptTokenRefresh, } from "../lib/config.js";
-import { getStableHostname } from "../lib/hostname.js";
+import { buildAgentIdentifier, getStableHostname } from "../lib/hostname.js";
 import { register, ApiError } from "../lib/api.js";
 const POLL_INTERVAL = 5_000;
 export async function listenCommand(options) {
@@ -24,7 +24,8 @@ export async function listenCommand(options) {
         console.error("Error: No API key found. Set VOXLI_API_TOKEN or run `voxli auth`.");
         process.exit(1);
     }
-    const hostname = getStableHostname();
+    const displayName = options.name ?? getStableHostname();
+    const uniqueIdentifier = buildAgentIdentifier(options.name);
     const children = new Set();
     // Graceful shutdown
     const shutdown = () => {
@@ -36,12 +37,12 @@ export async function listenCommand(options) {
     };
     process.on("SIGINT", shutdown);
     process.on("SIGTERM", shutdown);
-    console.log(`Listening as ${hostname} using credentials from ${credentialSource}`);
+    console.log(`Listening as ${displayName} (${uniqueIdentifier}) using credentials from ${credentialSource}`);
     while (true) {
         try {
             const data = await register(apiKey, {
-                name: hostname,
-                unique_identifier: hostname,
+                name: displayName,
+                unique_identifier: uniqueIdentifier,
             });
             const testResultIds = data.test_result_ids ?? [];
             if (testResultIds.length > 0) {
@@ -86,7 +87,7 @@ export async function listenCommand(options) {
                     process.exit(1);
                 }
                 console.log("Access token expired, attempting refresh...");
-                const newToken = await attemptTokenRefresh();
+                const newToken = await attemptTokenRefresh(apiKey ?? undefined);
                 if (newToken) {
                     apiKey = newToken;
                     console.log("Token refreshed successfully.");

package/dist/lib/auth.d.ts

@@ -0,0 +1,12 @@
+export interface Credentials {
+    apiKey: string;
+    source: string;
+    isEnvToken: boolean;
+}
+export declare function isTokenExpiringSoon(token: string): boolean;
+export declare function resolveCredentials(): Promise<Credentials>;
+/**
+ * Wraps an API call with automatic token refresh on 401/403.
+ * Proactively refreshes the token if it expires within 15 minutes.
+ */
+export declare function withAuth<T>(fn: (apiKey: string) => Promise<T>): Promise<T>;

package/dist/lib/auth.js

@@ -0,0 +1,73 @@
+import { join } from "node:path";
+import { resolveApiKey, resolveConfig, attemptTokenRefresh, } from "./config.js";
+import { ApiError } from "./api.js";
+const REFRESH_THRESHOLD_SECONDS = 15 * 60;
+export function isTokenExpiringSoon(token) {
+    try {
+        const parts = token.split(".");
+        if (parts.length !== 3)
+            return false;
+        const payload = JSON.parse(Buffer.from(parts[1], "base64url").toString("utf-8"));
+        if (!payload.exp)
+            return false;
+        return payload.exp - Date.now() / 1000 < REFRESH_THRESHOLD_SECONDS;
+    }
+    catch {
+        return false;
+    }
+}
+export async function resolveCredentials() {
+    const isEnvToken = !!resolveApiKey();
+    if (isEnvToken) {
+        const apiKey = resolveApiKey();
+        if (apiKey) {
+            return { apiKey, source: "VOXLI_API_TOKEN", isEnvToken: true };
+        }
+    }
+    const resolved = await resolveConfig();
+    if (resolved) {
+        const { config, configDir } = resolved;
+        const apiKey = config.accessToken ?? config.apiKey ?? null;
+        if (apiKey) {
+            return {
+                apiKey,
+                source: join(configDir, "config.json"),
+                isEnvToken: false,
+            };
+        }
+    }
+    console.error("Error: No API key found. Set VOXLI_API_TOKEN or run `voxli auth`.");
+    process.exit(1);
+}
+/**
+ * Wraps an API call with automatic token refresh on 401/403.
+ * Proactively refreshes the token if it expires within 15 minutes.
+ */
+export async function withAuth(fn) {
+    let credentials = await resolveCredentials();
+    if (!credentials.isEnvToken && isTokenExpiringSoon(credentials.apiKey)) {
+        const newToken = await attemptTokenRefresh();
+        if (newToken) {
+            credentials = { ...credentials, apiKey: newToken };
+        }
+    }
+    try {
+        return await fn(credentials.apiKey);
+    }
+    catch (err) {
+        if (!(err instanceof ApiError))
+            throw err;
+        if (err.status !== 401 && err.status !== 403)
+            throw err;
+        if (credentials.isEnvToken) {
+            console.error(`Error: Authentication failed (${err.status}). Your VOXLI_API_TOKEN may be expired or invalid.`);
+            process.exit(1);
+        }
+        const newToken = await attemptTokenRefresh();
+        if (newToken) {
+            return await fn(newToken);
+        }
+        console.error("Error: Could not refresh access token. Please re-authenticate with `voxli auth`.");
+        process.exit(1);
+    }
+}

package/dist/lib/config.d.ts

@@ -23,4 +23,4 @@ export declare function writeConfig(config: {
 }): Promise<string>;
 export declare function resolveApiKey(): string | null;
 export declare function resolveApiKeyAsync(): Promise<string | null>;
-export declare function attemptTokenRefresh(): Promise<string | null>;
+export declare function attemptTokenRefresh(expiredToken?: string): Promise<string | null>;

package/dist/lib/config.js

@@ -98,22 +98,45 @@ export async function resolveApiKeyAsync() {
     const config = resolved?.config;
     return config?.accessToken ?? config?.apiKey ?? null;
 }
-export async function attemptTokenRefresh() {
+export async function attemptTokenRefresh(expiredToken) {
     try {
         const resolved = await resolveConfig();
         if (!resolved)
             return null;
         const { config, configDir } = resolved;
+        // Another listener may have already refreshed — adopt that token.
+        if (expiredToken &&
+            config.accessToken &&
+            config.accessToken !== expiredToken) {
+            return config.accessToken;
+        }
         if (!config.refreshToken || !config.clientId)
             return null;
         const baseUrl = getApiBaseUrl();
-        const result = await refreshAccessToken(baseUrl, config.refreshToken, config.clientId);
-        await writeConfig({
-            accessToken: result.accessToken,
-            refreshToken: result.refreshToken ?? config.refreshToken,
-            clientId: config.clientId,
-        }, { configDir });
-        return result.accessToken;
+        try {
+            const result = await refreshAccessToken(baseUrl, config.refreshToken, config.clientId);
+            await writeConfig({
+                accessToken: result.accessToken,
+                refreshToken: result.refreshToken ?? config.refreshToken,
+                clientId: config.clientId,
+            }, { configDir });
+            return result.accessToken;
+        }
+        catch {
+            // Refresh failed (likely because a sibling listener already used the
+            // refresh token). Retry-read the config briefly in case the winner is
+            // still flushing its write to disk.
+            if (!expiredToken)
+                return null;
+            for (let i = 0; i < 5; i++) {
+                await new Promise((r) => setTimeout(r, 100));
+                const recheck = await resolveConfig();
+                const fresh = recheck?.config.accessToken;
+                if (fresh && fresh !== expiredToken)
+                    return fresh;
+            }
+            return null;
+        }
     }
     catch {
         return null;

package/dist/lib/hostname.d.ts

@@ -1 +1,2 @@
 export declare function getStableHostname(): string;
+export declare function buildAgentIdentifier(name: string | undefined): string;

package/dist/lib/hostname.js

@@ -14,3 +14,10 @@ export function getStableHostname() {
     }
     return hostname();
 }
+export function buildAgentIdentifier(name) {
+    const host = getStableHostname();
+    if (!name)
+        return host;
+    const trimmed = name.replace(/\s+/g, "");
+    return trimmed ? `${trimmed}-${host}` : host;
+}

package/package.json

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