@voxli/cli 0.4.0 → 0.5.1

package/dist/cli.js

@@ -14,6 +14,7 @@ program
     .command("auth")
     .description("Authenticate with your Voxli API key")
     .option("--manual", "Enter API key manually instead of browser auth")
+    .option("--local", "Save credentials in the current directory")
     .action(authCommand);
 program
     .command("listen")

package/dist/commands/auth.d.ts

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

package/dist/commands/auth.js

@@ -18,7 +18,7 @@ async function promptForToken() {
         rl.close();
     }
 }
-async function validateAndSave(token, extra) {
+async function validateAndSave(token, extra, opts) {
     const label = extra ? "Access token" : "API key";
     console.log("Validating...");
     try {
@@ -37,12 +37,13 @@ async function validateAndSave(token, extra) {
         // Network error or other — warn but still save
         console.warn("Warning: could not validate token (network error). Saving anyway.");
     }
-    await writeConfig({
+    const target = opts?.local ? "local" : "global";
+    const savedPath = await writeConfig({
         accessToken: token,
         refreshToken: extra?.refreshToken,
         clientId: extra?.clientId,
-    });
-    console.log(`${label} saved to ~/.voxli/config.json`);
+    }, { target });
+    console.log(`${label} saved to ${savedPath}`);
 }
 export async function authCommand(opts) {
     if (!opts.manual) {
@@ -51,7 +52,7 @@ export async function authCommand(opts) {
             await validateAndSave(result.accessToken, {
                 refreshToken: result.refreshToken,
                 clientId: result.clientId,
-            });
+            }, { local: opts.local });
             return;
         }
         catch (err) {
@@ -61,5 +62,5 @@ export async function authCommand(opts) {
         }
     }
     const token = await promptForToken();
-    await validateAndSave(token);
+    await validateAndSave(token, undefined, { local: opts.local });
 }

package/dist/commands/listen.js

@@ -1,11 +1,25 @@
+import { join } from "node:path";
 import { spawn } from "node:child_process";
-import { resolveApiKeyAsync, resolveApiKey, attemptTokenRefresh, } from "../lib/config.js";
+import { resolveApiKey, resolveConfig, attemptTokenRefresh, } 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 isEnvToken = !!resolveApiKey();
-    let apiKey = await resolveApiKeyAsync();
+    let apiKey = null;
+    let credentialSource = null;
+    if (isEnvToken) {
+        apiKey = resolveApiKey();
+        credentialSource = "VOXLI_API_TOKEN";
+    }
+    else {
+        const resolved = await resolveConfig();
+        if (resolved) {
+            const { config, configDir } = resolved;
+            apiKey = config.accessToken ?? config.apiKey ?? null;
+            credentialSource = join(configDir, "config.json");
+        }
+    }
     if (!apiKey) {
         console.error("Error: No API key found. Set VOXLI_API_TOKEN or run `voxli auth`.");
         process.exit(1);
@@ -22,7 +36,7 @@ export async function listenCommand(options) {
     };
     process.on("SIGINT", shutdown);
     process.on("SIGTERM", shutdown);
-    console.log(`Listening as ${hostname}...`);
+    console.log(`Listening as ${hostname} using credentials from ${credentialSource}`);
     while (true) {
         try {
             const data = await register(apiKey, {

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/browser-auth.js

@@ -81,6 +81,7 @@ export async function browserAuth() {
         }, AUTH_TIMEOUT_MS);
         function cleanup() {
             clearTimeout(timeout);
+            server.closeAllConnections();
             server.close();
         }
         server.listen(0, "127.0.0.1", async () => {

package/dist/lib/config.d.ts

@@ -1,10 +1,26 @@
 import type { VoxliConfig } from "../types.js";
+/**
+ * Walk up from CWD looking for a `.voxli/config.json` file.
+ * Returns the `.voxli` directory path if found, or null.
+ */
+export declare function findLocalConfigDir(): Promise<string | null>;
 export declare function readConfig(): Promise<VoxliConfig | null>;
+/**
+ * Resolve config checking local first, then global.
+ * Returns the config and the directory it was found in.
+ */
+export declare function resolveConfig(): Promise<{
+    config: VoxliConfig;
+    configDir: string;
+} | null>;
 export declare function writeConfig(config: {
     accessToken: string;
     refreshToken?: string;
     clientId?: string;
-}): Promise<void>;
+}, opts?: {
+    target?: "global" | "local";
+    configDir?: string;
+}): Promise<string>;
 export declare function resolveApiKey(): string | null;
 export declare function resolveApiKeyAsync(): Promise<string | null>;
 export declare function attemptTokenRefresh(): Promise<string | null>;

package/dist/lib/config.js

@@ -1,47 +1,110 @@
-import { readFile, writeFile, mkdir, chmod } from "node:fs/promises";
-import { join } from "node:path";
+import { readFile, writeFile, mkdir, chmod, access } from "node:fs/promises";
+import { join, dirname } from "node:path";
 import { homedir } from "node:os";
 import { refreshAccessToken } from "./oauth.js";
 import { getApiBaseUrl } from "./api.js";
-const CONFIG_DIR = join(homedir(), ".voxli");
-const CONFIG_PATH = join(CONFIG_DIR, "config.json");
-export async function readConfig() {
+const GLOBAL_CONFIG_DIR = join(homedir(), ".voxli");
+const GLOBAL_CONFIG_PATH = join(GLOBAL_CONFIG_DIR, "config.json");
+async function fileExists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Walk up from CWD looking for a `.voxli/config.json` file.
+ * Returns the `.voxli` directory path if found, or null.
+ */
+export async function findLocalConfigDir() {
+    let dir = process.cwd();
+    while (true) {
+        const candidate = join(dir, ".voxli", "config.json");
+        if (await fileExists(candidate)) {
+            return join(dir, ".voxli");
+        }
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return null;
+}
+async function readConfigFrom(configPath) {
     try {
-        const raw = await readFile(CONFIG_PATH, "utf-8");
+        const raw = await readFile(configPath, "utf-8");
         return JSON.parse(raw);
     }
     catch {
         return null;
     }
 }
-export async function writeConfig(config) {
+export async function readConfig() {
+    return readConfigFrom(GLOBAL_CONFIG_PATH);
+}
+/**
+ * Resolve config checking local first, then global.
+ * Returns the config and the directory it was found in.
+ */
+export async function resolveConfig() {
+    const localDir = await findLocalConfigDir();
+    if (localDir) {
+        const config = await readConfigFrom(join(localDir, "config.json"));
+        if (config)
+            return { config, configDir: localDir };
+    }
+    const config = await readConfigFrom(GLOBAL_CONFIG_PATH);
+    if (config)
+        return { config, configDir: GLOBAL_CONFIG_DIR };
+    return null;
+}
+export async function writeConfig(config, opts) {
+    let targetDir;
+    if (opts?.configDir) {
+        targetDir = opts.configDir;
+    }
+    else if (opts?.target === "local") {
+        targetDir = join(process.cwd(), ".voxli");
+    }
+    else {
+        targetDir = GLOBAL_CONFIG_DIR;
+    }
+    const targetPath = join(targetDir, "config.json");
     const data = { accessToken: config.accessToken };
     if (config.refreshToken)
         data.refreshToken = config.refreshToken;
     if (config.clientId)
         data.clientId = config.clientId;
-    await mkdir(CONFIG_DIR, { recursive: true });
-    await writeFile(CONFIG_PATH, JSON.stringify(data, null, 2) + "\n", { mode: 0o600 });
-    await chmod(CONFIG_PATH, 0o600);
+    await mkdir(targetDir, { recursive: true });
+    await writeFile(targetPath, JSON.stringify(data, null, 2) + "\n", {
+        mode: 0o600,
+    });
+    await chmod(targetPath, 0o600);
+    return targetPath;
 }
 export function resolveApiKey() {
     const envKey = process.env.VOXLI_API_TOKEN;
     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();
+    const resolved = await resolveConfig();
+    const config = resolved?.config;
     return config?.accessToken ?? config?.apiKey ?? null;
 }
 export async function attemptTokenRefresh() {
     try {
-        const config = await readConfig();
-        if (!config?.refreshToken || !config?.clientId)
+        const resolved = await resolveConfig();
+        if (!resolved)
+            return null;
+        const { config, configDir } = resolved;
+        if (!config.refreshToken || !config.clientId)
             return null;
         const baseUrl = getApiBaseUrl();
         const result = await refreshAccessToken(baseUrl, config.refreshToken, config.clientId);
@@ -49,7 +112,7 @@ export async function attemptTokenRefresh() {
             accessToken: result.accessToken,
             refreshToken: result.refreshToken ?? config.refreshToken,
             clientId: config.clientId,
-        });
+        }, { configDir });
         return result.accessToken;
     }
     catch {

package/package.json

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