@ishlabs/cli 0.8.1 → 0.8.3

package/dist/connect.js

@@ -2,37 +2,36 @@
  * Localhost connect CLI — wraps cloudflared and registers with Ish backend.
  */
 import { spawn, execSync } from "node:child_process";
-import { homedir } from "node:os";
-import { join } from "node:path";
 import { existsSync, mkdirSync, chmodSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
 import { loadConfig, saveConfig } from "./config.js";
 import { refreshTokens, isTokenExpired, decodeJwtExp } from "./auth.js";
+import { binDir, cloudflaredBin, simulationsDir } from "./lib/paths.js";
+import { c } from "./lib/colors.js";
 const TUNNEL_URL_PATTERN = /https:\/\/[a-z0-9-]+\.trycloudflare\.com/;
 const HEARTBEAT_INTERVAL = 10_000;
 const MAX_HEARTBEAT_FAILURES = 3;
 const CLOUDFLARED_STARTUP_TIMEOUT = 30_000;
 const DEFAULT_API_URL = "https://api.ishlabs.io";
 const API_BASE = "/api/v1";
-const ISH_DIR = join(homedir(), ".ish");
-const CLOUDFLARED_BIN = join(ISH_DIR, "bin", process.platform === "win32" ? "cloudflared.exe" : "cloudflared");
 // --- Simulation card rendering ---
 const CARD_WIDTH = 64;
 function statusColor(status) {
     switch (status) {
-        case "running": return "\x1b[32m";
-        case "pending": return "\x1b[33m";
-        case "completed": return "\x1b[32m";
-        case "failed": return "\x1b[31m";
-        default: return "\x1b[2m";
+        case "running": return c.green;
+        case "pending": return c.yellow;
+        case "completed": return c.green;
+        case "failed": return c.red;
+        default: return c.dim;
     }
 }
 function sentimentColor(sentiment) {
     switch (sentiment) {
         case "Excited":
-        case "Satisfied": return GREEN;
+        case "Satisfied": return c.green;
         case "Frustrated":
-        case "Unsure": return RED;
-        default: return DIM; // Neutral
+        case "Unsure": return c.red;
+        default: return c.dim; // Neutral
     }
 }
 function padVisible(str, len) {
@@ -43,7 +42,7 @@ function truncate(str, maxLen) {
     return str.length > maxLen ? str.slice(0, maxLen - 1) + "…" : str;
 }
 function row(content, inner) {
-    return `\x1b[2m│\x1b[0m  ${padVisible(content, inner)}\x1b[2m│\x1b[0m`;
+    return `${c.dim}│${c.reset}  ${padVisible(content, inner)}${c.dim}│${c.reset}`;
 }
 function renderCard(sim) {
     const inner = CARD_WIDTH - 4;
@@ -51,20 +50,20 @@ function renderCard(sim) {
     // Top border with name
     const nameSegment = `─ ${name} `;
     const topPad = CARD_WIDTH - 2 - nameSegment.length;
-    const top = `\x1b[2m┌\x1b[0m${ORANGE}${BOLD}${nameSegment}${RESET}\x1b[2m${"─".repeat(Math.max(0, topPad))}┐\x1b[0m`;
+    const top = `${c.dim}┌${c.reset}${c.orange}${c.bold}${nameSegment}${c.reset}${c.dim}${"─".repeat(Math.max(0, topPad))}┐${c.reset}`;
     const li = sim.last_interaction;
     const lines = [top];
     // Status badge: ● Status (N steps) — right-aligned
     const titleStatus = sim.status.charAt(0).toUpperCase() + sim.status.slice(1);
     const steps = `${sim.interaction_count} step${sim.interaction_count !== 1 ? "s" : ""}`;
-    const badge = `${statusColor(sim.status)}●${RESET} ${titleStatus} ${DIM}(${steps})${RESET}`;
+    const badge = `${statusColor(sim.status)}●${c.reset} ${titleStatus} ${c.dim}(${steps})${c.reset}`;
     const badgePlain = `● ${titleStatus} (${steps})`;
     if (li) {
         // Frame name (bold) + status badge right-aligned
         if (li.current_frame_name) {
             const frameStr = truncate(li.current_frame_name, inner - badgePlain.length - 2);
             const gap = inner - frameStr.length - badgePlain.length;
-            lines.push(row(`${BOLD}${frameStr}${RESET}${" ".repeat(Math.max(1, gap))}${badge}`, inner));
+            lines.push(row(`${c.bold}${frameStr}${c.reset}${" ".repeat(Math.max(1, gap))}${badge}`, inner));
         }
         else {
             const pad = inner - badgePlain.length;
@@ -96,7 +95,7 @@ function renderCard(sim) {
                 commentLines[lastIdx] = `${commentLines[lastIdx]}"`;
             }
             for (const cl of commentLines) {
-                lines.push(row(`${DIM}${truncate(cl, inner)}${RESET}`, inner));
+                lines.push(row(`${c.dim}${truncate(cl, inner)}${c.reset}`, inner));
             }
         }
         // Action rows — one per action, action_type in cyan
@@ -106,12 +105,12 @@ function renderCard(sim) {
             const label = action.element_label
                 ? ` ${truncate(action.element_label, inner - action.action_type.length - 2)}`
                 : "";
-            lines.push(row(`${CYAN}${action.action_type}${RESET}${label}`, inner));
+            lines.push(row(`${c.cyan}${action.action_type}${c.reset}${label}`, inner));
         }
         // Sentiment badge
         if (li.sentiment) {
             const sc = sentimentColor(li.sentiment);
-            lines.push(row(`${sc}${li.sentiment}${RESET}`, inner));
+            lines.push(row(`${sc}${li.sentiment}${c.reset}`, inner));
         }
     }
     else {
@@ -120,7 +119,7 @@ function renderCard(sim) {
         lines.push(row(`${" ".repeat(Math.max(0, pad))}${badge}`, inner));
     }
     // Bottom border
-    lines.push(`\x1b[2m└${"─".repeat(CARD_WIDTH - 2)}┘\x1b[0m`);
+    lines.push(`${c.dim}└${"─".repeat(CARD_WIDTH - 2)}┘${c.reset}`);
     return lines;
 }
 function renderAllCards(simulations) {
@@ -129,7 +128,7 @@ function renderAllCards(simulations) {
     const lines = [];
     const ts = new Date().toLocaleTimeString("en-GB", { hour12: false });
     const study = simulations[0]?.study_name;
-    lines.push(`\x1b[2m${study ? `${study} · ` : ""}Updated ${ts}\x1b[0m`);
+    lines.push(`${c.dim}${study ? `${study} · ` : ""}Updated ${ts}${c.reset}`);
     lines.push("");
     for (const sim of simulations) {
         lines.push(...renderCard(sim));
@@ -140,6 +139,11 @@ function renderAllCards(simulations) {
 let cardLineCount = 0;
 function clearCards() {
     if (cardLineCount > 0) {
+        // Cursor manipulation only meaningful when colors/escapes are enabled.
+        // When disabled (NO_COLOR, piped output, --no-color), skip the redraw
+        // dance — the heartbeat will just append.
+        if (!c.reset)
+            return;
         process.stdout.write(`\x1b[${cardLineCount}A`);
         for (let i = 0; i < cardLineCount; i++) {
             process.stdout.write("\x1b[2K\n");
@@ -156,14 +160,14 @@ function renderSimulationCards(simulations) {
     }
 }
 // --- Local storage for completed simulations ---
-const SIMULATIONS_DIR = join(ISH_DIR, "simulations");
 const storedTesterIds = new Set();
 function storeCompletedSimulation(sim) {
     if (storedTesterIds.has(sim.tester_id))
         return;
     storedTesterIds.add(sim.tester_id);
-    mkdirSync(SIMULATIONS_DIR, { recursive: true });
-    const logFile = join(SIMULATIONS_DIR, "history.jsonl");
+    const dir = simulationsDir();
+    mkdirSync(dir, { recursive: true });
+    const logFile = join(dir, "history.jsonl");
     const entry = {
         tester_id: sim.tester_id,
         instance_name: sim.instance_name,
@@ -200,15 +204,30 @@ function resolveApiUrl(apiUrlArg) {
  * Resolve an access token, refreshing if needed.
  * Returns both the token and a mutable holder for runtime refresh.
  */
-async function resolveToken(tokenArg, apiUrl) {
+async function resolveToken(tokenArg, apiUrl, tokenFileArg) {
     // 1. Explicit token argument
     if (tokenArg)
         return { token: tokenArg, refresh: null };
-    // 2. Environment variable
+    // 2. Token file
+    if (tokenFileArg) {
+        const { readFileSync } = await import("node:fs");
+        let content;
+        try {
+            content = readFileSync(tokenFileArg, "utf-8");
+        }
+        catch {
+            throw new Error(`Cannot read --token-file: ${tokenFileArg}`);
+        }
+        const token = content.trim();
+        if (!token)
+            throw new Error(`--token-file is empty: ${tokenFileArg}`);
+        return { token, refresh: null };
+    }
+    // 3. Environment variable
     const envToken = process.env.ISH_TOKEN;
     if (envToken)
         return { token: envToken, refresh: null };
-    // 3. Saved config with refresh token
+    // 4. Saved config with refresh token
     const config = loadConfig();
     if (config.access_token && config.refresh_token) {
         let accessToken = config.access_token;
@@ -222,8 +241,7 @@ async function resolveToken(tokenArg, apiUrl) {
                 saveConfig(config);
             }
             catch {
-                console.error('Session expired. Run "ish login" to re-authenticate.');
-                process.exit(1);
+                throw new Error('Session expired. Run "ish login" to re-authenticate.');
             }
         }
         if (await verifyToken(accessToken, apiUrl)) {
@@ -240,38 +258,27 @@ async function resolveToken(tokenArg, apiUrl) {
             };
             return { token: accessToken, refresh: doRefresh };
         }
-        console.error('Saved token is invalid. Run "ish login" to re-authenticate.');
-        process.exit(1);
+        throw new Error('Saved token is invalid. Run "ish login" to re-authenticate.');
     }
-    // 4. Legacy saved token (no refresh token)
+    // 5. Legacy saved token (no refresh token)
     if (config.token) {
         if (await verifyToken(config.token, apiUrl)) {
             return { token: config.token, refresh: null };
         }
-        console.error('Saved token is invalid. Run "ish login" to re-authenticate.');
-        process.exit(1);
+        throw new Error('Saved token is invalid. Run "ish login" to re-authenticate.');
     }
-    // 5. No valid token found — direct user to login
-    console.error('No valid token found. Run "ish login" to authenticate.');
-    process.exit(1);
+    // 6. No valid token found — direct user to login
+    throw new Error('No valid token found. Run "ish login" to authenticate.');
 }
 // --- Branding ---
-const RESET = "\x1b[0m";
-const ORANGE = "\x1b[38;2;212;117;78m";
-const BOLD = "\x1b[1m";
-const DIM = "\x1b[2m";
-const GREEN = "\x1b[32m";
-const RED = "\x1b[31m";
-const YELLOW = "\x1b[33m";
-const CYAN = "\x1b[36m";
 function printBanner() {
     console.log(`
-${ORANGE}${BOLD}   ██╗███████╗██╗  ██╗
+${c.orange}${c.bold}   ██╗███████╗██╗  ██╗
    ██║██╔════╝██║  ██║
    ██║███████╗███████║
    ██║╚════██║██╔══██║
    ██║███████║██║  ██║
-   ╚═╝╚══════╝╚═╝  ╚═╝${RESET}
+   ╚═╝╚══════╝╚═╝  ╚═╝${c.reset}
 
    Connected
 `);
@@ -286,35 +293,34 @@ async function resolveCloudflaredBin() {
     catch {
         // Not on PATH
     }
-    // 2. Check ~/.ish/bin/cloudflared
-    if (existsSync(CLOUDFLARED_BIN))
-        return CLOUDFLARED_BIN;
+    // 2. Check the local ish bin dir
+    const localBin = cloudflaredBin();
+    if (existsSync(localBin))
+        return localBin;
     // 3. Download from Cloudflare releases
-    console.log("cloudflared not found. Installing...");
+    console.error("cloudflared not found. Installing...");
     const url = getCloudflaredDownloadUrl();
     if (!url) {
-        printManualInstallInstructions();
-        process.exit(1);
+        throw new Error(manualInstallInstructions());
     }
     try {
-        const binDir = join(ISH_DIR, "bin");
-        mkdirSync(binDir, { recursive: true, mode: 0o755 });
+        const dir = binDir();
+        mkdirSync(dir, { recursive: true, mode: 0o755 });
         if (url.endsWith(".tgz")) {
-            execSync(`curl -fsSL "${url}" | tar xz -C "${binDir}" cloudflared`, { stdio: "ignore" });
+            execSync(`curl -fsSL "${url}" | tar xz -C "${dir}" cloudflared`, { stdio: "ignore" });
         }
         else {
             const resp = await fetch(url);
             if (!resp.ok)
                 throw new Error(`HTTP ${resp.status}`);
-            writeFileSync(CLOUDFLARED_BIN, Buffer.from(await resp.arrayBuffer()));
+            writeFileSync(localBin, Buffer.from(await resp.arrayBuffer()));
         }
-        chmodSync(CLOUDFLARED_BIN, 0o755);
-        return CLOUDFLARED_BIN;
+        chmodSync(localBin, 0o755);
+        return localBin;
     }
     catch (e) {
-        console.error(`Failed to install cloudflared: ${e instanceof Error ? e.message : e}\n`);
-        printManualInstallInstructions();
-        process.exit(1);
+        const reason = e instanceof Error ? e.message : String(e);
+        throw new Error(`Failed to install cloudflared: ${reason}\n${manualInstallInstructions()}`);
     }
 }
 function getCloudflaredDownloadUrl() {
@@ -333,15 +339,16 @@ function getCloudflaredDownloadUrl() {
         return `${base}/cloudflared-windows-amd64.exe`;
     return null;
 }
-function printManualInstallInstructions() {
-    console.error("You can install it manually:\n" +
+function manualInstallInstructions() {
+    return ("You can install it manually:\n" +
         "  brew install cloudflare/cloudflare/cloudflared   # macOS\n" +
         "  sudo apt install cloudflared                     # Debian/Ubuntu\n" +
         "\n  Or: https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/downloads/");
 }
-function startCloudflared(port, binPath) {
+function startCloudflared(port, binPath, json) {
     return new Promise((resolve, reject) => {
-        console.log(`Connecting to localhost:${port}...`);
+        if (!json)
+            console.log(`Connecting to localhost:${port}...`);
         const proc = spawn(binPath, ["tunnel", "--url", `http://localhost:${port}`], {
             stdio: ["ignore", "pipe", "pipe"],
         });
@@ -358,7 +365,6 @@ function startCloudflared(port, binPath) {
             if (match && !tunnelUrl) {
                 tunnelUrl = match[0];
                 clearTimeout(timeout);
-                printBanner();
                 resolve({ process: proc, tunnelUrl });
             }
         });
@@ -388,14 +394,15 @@ async function registerTunnel(apiUrl, token, tunnelUrl, port) {
         });
         if (!resp.ok)
             throw new Error(`HTTP ${resp.status}`);
-        // Registration successful — banner already shown
+        return true;
     }
     catch (e) {
         console.error(`Warning: Failed to register connection: ${e}`);
         console.error("Connection is still active — you can retry manually.");
+        return false;
     }
 }
-async function deregisterTunnel(apiUrl, token) {
+async function deregisterTunnel(apiUrl, token, json) {
     try {
         const resp = await fetch(`${apiUrl}${API_BASE}/connect`, {
             method: "DELETE",
@@ -404,16 +411,22 @@ async function deregisterTunnel(apiUrl, token) {
         });
         if (!resp.ok)
             throw new Error(`HTTP ${resp.status}`);
-        console.log("Disconnected");
+        if (json) {
+            console.log(JSON.stringify({ status: "disconnected" }));
+        }
+        else {
+            console.log("Disconnected");
+        }
     }
     catch (e) {
         console.error(`Warning: Failed to deregister connection: ${e}`);
     }
 }
-function processHeartbeatResponse(resp) {
+function processHeartbeatResponse(resp, renderCards) {
     resp.json().then((data) => {
         const sims = data.simulations ?? [];
-        renderSimulationCards(sims);
+        if (renderCards)
+            renderSimulationCards(sims);
         // Store completed simulations locally
         for (const sim of sims) {
             if (sim.status === "completed" || sim.status === "failed" || sim.status === "cancelled") {
@@ -424,7 +437,7 @@ function processHeartbeatResponse(resp) {
         // Non-fatal: response parsing failed, silently continue
     });
 }
-function startHeartbeat(apiUrl, getToken, doRefresh, onTokenRefreshed, onFatal) {
+function startHeartbeat(apiUrl, getToken, doRefresh, onTokenRefreshed, onFatal, json) {
     let consecutiveFailures = 0;
     let stopped = false;
     const interval = setInterval(async () => {
@@ -441,7 +454,8 @@ function startHeartbeat(apiUrl, getToken, doRefresh, onTokenRefreshed, onFatal)
                 try {
                     const newToken = await doRefresh();
                     onTokenRefreshed(newToken);
-                    console.log("Token refreshed.");
+                    if (!json)
+                        console.log("Token refreshed.");
                     // Retry heartbeat with new token
                     const retry = await fetch(`${apiUrl}${API_BASE}/connect/heartbeat`, {
                         method: "POST",
@@ -451,7 +465,7 @@ function startHeartbeat(apiUrl, getToken, doRefresh, onTokenRefreshed, onFatal)
                     if (!retry.ok)
                         throw new Error(`HTTP ${retry.status}`);
                     consecutiveFailures = 0;
-                    processHeartbeatResponse(retry);
+                    processHeartbeatResponse(retry, !json);
                     return;
                 }
                 catch (refreshErr) {
@@ -461,7 +475,7 @@ function startHeartbeat(apiUrl, getToken, doRefresh, onTokenRefreshed, onFatal)
             if (!resp.ok)
                 throw new Error(`HTTP ${resp.status}`);
             consecutiveFailures = 0;
-            processHeartbeatResponse(resp);
+            processHeartbeatResponse(resp, !json);
         }
         catch (e) {
             consecutiveFailures++;
@@ -485,7 +499,7 @@ function startHeartbeat(apiUrl, getToken, doRefresh, onTokenRefreshed, onFatal)
  * Schedule a proactive token refresh before the JWT expires.
  * Refreshes 10 minutes before expiry.
  */
-function scheduleProactiveRefresh(token, doRefresh, onTokenRefreshed) {
+function scheduleProactiveRefresh(token, doRefresh, onTokenRefreshed, json) {
     if (!doRefresh)
         return { stop: () => { } };
     const exp = decodeJwtExp(token);
@@ -499,9 +513,10 @@ function scheduleProactiveRefresh(token, doRefresh, onTokenRefreshed) {
         try {
             const newToken = await doRefresh();
             onTokenRefreshed(newToken);
-            console.log("Token proactively refreshed.");
+            if (!json)
+                console.log("Token proactively refreshed.");
             // Schedule next refresh for the new token
-            scheduleProactiveRefresh(newToken, doRefresh, onTokenRefreshed);
+            scheduleProactiveRefresh(newToken, doRefresh, onTokenRefreshed, json);
         }
         catch (e) {
             console.error(`Proactive token refresh failed: ${e}`);
@@ -510,12 +525,14 @@ function scheduleProactiveRefresh(token, doRefresh, onTokenRefreshed) {
     return { stop: () => clearTimeout(timer) };
 }
 // --- Main ---
-export async function runTunnel(port, tokenArg, apiUrlArg) {
+export async function runTunnel(port, tokenArg, apiUrlArg, tokenFileArg, outputOpts = {}) {
+    const json = outputOpts.json ?? false;
+    const quiet = outputOpts.quiet ?? false;
     const apiUrl = resolveApiUrl(apiUrlArg);
-    if (apiUrl !== DEFAULT_API_URL) {
-        console.log(`Using API: ${apiUrl}`);
+    if (apiUrl !== DEFAULT_API_URL && !json) {
+        console.error(`Using API: ${apiUrl}`);
     }
-    const resolved = await resolveToken(tokenArg, apiUrl);
+    const resolved = await resolveToken(tokenArg, apiUrl, tokenFileArg);
     let currentToken = resolved.token;
     const onTokenRefreshed = (newToken) => {
         currentToken = newToken;
@@ -533,40 +550,56 @@ export async function runTunnel(port, tokenArg, apiUrlArg) {
     const cloudflaredPath = await resolveCloudflaredBin();
     let cfResult;
     try {
-        cfResult = await startCloudflared(port, cloudflaredPath);
+        cfResult = await startCloudflared(port, cloudflaredPath, json);
     }
     catch (e) {
-        console.error(`Failed to start cloudflared: ${e}`);
-        process.exit(1);
+        throw new Error(`Failed to start cloudflared: ${e instanceof Error ? e.message : e}`);
     }
     const { process: cfProcess, tunnelUrl } = cfResult;
-    await registerTunnel(apiUrl, currentToken, tunnelUrl, port);
+    const registered = await registerTunnel(apiUrl, currentToken, tunnelUrl, port);
+    // Announce the tunnel URL — this is the load-bearing output of `ish connect`.
+    if (json) {
+        console.log(JSON.stringify({
+            status: "connected",
+            tunnel_url: tunnelUrl,
+            local_port: port,
+            registered,
+        }));
+    }
+    else {
+        if (!quiet)
+            printBanner();
+        console.log(`Tunnel URL: ${tunnelUrl} → http://localhost:${port}\n`);
+    }
     let shuttingDown = false;
     const heartbeat = startHeartbeat(apiUrl, () => currentToken, serializedRefresh, onTokenRefreshed, async () => {
-        await deregisterTunnel(apiUrl, currentToken);
+        await deregisterTunnel(apiUrl, currentToken, json);
         cfProcess.kill();
         process.exit(1);
-    });
-    const proactiveRefresh = scheduleProactiveRefresh(currentToken, serializedRefresh, onTokenRefreshed);
+    }, json);
+    const proactiveRefresh = scheduleProactiveRefresh(currentToken, serializedRefresh, onTokenRefreshed, json);
     const shutdown = async () => {
         if (shuttingDown)
             process.exit(1);
         shuttingDown = true;
-        console.log("\nShutting down...");
+        if (!json)
+            console.log("\nShutting down...");
         heartbeat.stop();
         proactiveRefresh.stop();
         cfProcess.kill();
-        await deregisterTunnel(apiUrl, currentToken);
+        await deregisterTunnel(apiUrl, currentToken, json);
         process.exit(0);
     };
     process.on("SIGINT", shutdown);
     process.on("SIGTERM", shutdown);
-    console.log("\nPress Ctrl+C to disconnect.\n");
+    if (!json && !quiet) {
+        console.log("Press Ctrl+C to disconnect.\n");
+    }
     cfProcess.on("exit", async () => {
         if (!shuttingDown) {
             heartbeat.stop();
             proactiveRefresh.stop();
-            await deregisterTunnel(apiUrl, currentToken);
+            await deregisterTunnel(apiUrl, currentToken, json);
             process.exit(0);
         }
     });