speqs 0.3.0 → 0.4.0

package/README.md

@@ -2,26 +2,18 @@
 
 CLI tool to expose your localhost to [Speqs](https://speqs.io) for simulation testing.
 
-## Prerequisites
-
-[cloudflared](https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/downloads/) must be installed:
-
-- **macOS**: `brew install cloudflare/cloudflare/cloudflared`
-- **Debian/Ubuntu**: `sudo apt install cloudflared`
-- **Windows**: `scoop install cloudflared` or [download](https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/downloads/)
-
 ## Install
 
 ### Quick install (recommended)
 
 **macOS / Linux:**
 ```bash
-curl -fsSL https://raw.githubusercontent.com/speqs-io/speqs-cli/main/install.sh | sh
+curl -fsSL https://speqs.io/install.sh | sh
 ```
 
 **Windows (PowerShell):**
 ```powershell
-irm https://raw.githubusercontent.com/speqs-io/speqs-cli/main/install.ps1 | iex
+irm https://speqs.io/install.ps1 | iex
 ```
 
 ### npm (all platforms)
@@ -40,7 +32,7 @@ brew install speqs
 ## Usage
 
 ```bash
-speqs tunnel <port>
+speqs connect <port>
 ```
 
 ### Options
@@ -57,22 +49,19 @@ The CLI resolves your auth token in this order:
 
 1. `--token` CLI argument
 2. `SPEQS_TOKEN` environment variable
-3. Saved token in `~/.speqs/config.json`
-4. Interactive prompt (token is saved for future use)
-
-Find your token in the Speqs app under **Settings**.
+3. Saved token from `speqs login` (stored in `~/.speqs/config.json`)
 
 ## Examples
 
 ```bash
 # Expose port 3000
-speqs tunnel 3000
+speqs connect 3000
 
 # With explicit token
-speqs tunnel 3000 --token YOUR_TOKEN
+speqs connect 3000 --token YOUR_TOKEN
 
 # Using environment variable
-SPEQS_TOKEN=YOUR_TOKEN speqs tunnel 8080
+SPEQS_TOKEN=YOUR_TOKEN speqs connect 8080
 ```
 
 ## License

package/dist/{tunnel.d.ts → connect.d.ts}

@@ -1,4 +1,4 @@
 /**
- * Localhost tunnel CLI — wraps cloudflared and registers with Speqs backend.
+ * Localhost connect CLI — wraps cloudflared and registers with Speqs backend.
  */
 export declare function runTunnel(port: number, tokenArg?: string, apiUrlArg?: string): Promise<void>;

package/dist/{tunnel.js → connect.js}

@@ -1,5 +1,5 @@
 /**
- * Localhost tunnel CLI — wraps cloudflared and registers with Speqs backend.
+ * Localhost connect CLI — wraps cloudflared and registers with Speqs backend.
  */
 import { spawn, execSync } from "node:child_process";
 import { homedir } from "node:os";
@@ -8,21 +8,181 @@ import { existsSync, mkdirSync, chmodSync, writeFileSync } from "node:fs";
 import { loadConfig, saveConfig } from "./config.js";
 import { refreshTokens, isTokenExpired, decodeJwtExp } from "./auth.js";
 const TUNNEL_URL_PATTERN = /https:\/\/[a-z0-9-]+\.trycloudflare\.com/;
-const HEARTBEAT_INTERVAL = 30_000;
+const HEARTBEAT_INTERVAL = 10_000;
 const MAX_HEARTBEAT_FAILURES = 3;
 const CLOUDFLARED_STARTUP_TIMEOUT = 30_000;
 const DEFAULT_API_URL = "https://api.speqs.io";
 const API_BASE = "/api/v1";
 const SPEQS_DIR = join(homedir(), ".speqs");
 const CLOUDFLARED_BIN = join(SPEQS_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";
+    }
+}
+function sentimentColor(sentiment) {
+    switch (sentiment) {
+        case "Excited":
+        case "Satisfied": return GREEN;
+        case "Frustrated":
+        case "Unsure": return RED;
+        default: return DIM; // Neutral
+    }
+}
+function padVisible(str, len) {
+    const visible = str.replace(/\x1b\[[0-9;]*m/g, "").length;
+    return visible >= len ? str : str + " ".repeat(len - visible);
+}
+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`;
+}
+function renderCard(sim) {
+    const inner = CARD_WIDTH - 4;
+    const name = truncate(sim.tester_name ?? sim.instance_name ?? sim.tester_id.slice(0, 8), inner - 2);
+    // 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 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 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));
+        }
+        else {
+            const pad = inner - badgePlain.length;
+            lines.push(row(`${" ".repeat(Math.max(0, pad))}${badge}`, inner));
+        }
+        // Comment (dim, italic quotes — up to 3 lines)
+        if (li.comment) {
+            const maxChars = inner - 3;
+            const words = li.comment.split(" ");
+            const commentLines = [];
+            let current = "";
+            for (const word of words) {
+                const next = current ? `${current} ${word}` : word;
+                if (next.length > maxChars && current) {
+                    commentLines.push(current);
+                    current = word;
+                }
+                else {
+                    current = next;
+                }
+                if (commentLines.length === 3)
+                    break;
+            }
+            if (current && commentLines.length < 3)
+                commentLines.push(current);
+            if (commentLines.length > 0) {
+                commentLines[0] = `"${commentLines[0]}`;
+                const lastIdx = commentLines.length - 1;
+                commentLines[lastIdx] = `${commentLines[lastIdx]}"`;
+            }
+            for (const cl of commentLines) {
+                lines.push(row(`${DIM}${truncate(cl, inner)}${RESET}`, inner));
+            }
+        }
+        // Action rows — one per action, action_type in cyan
+        for (const action of li.actions) {
+            if (!action.action_type)
+                continue;
+            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));
+        }
+        // Sentiment badge
+        if (li.sentiment) {
+            const sc = sentimentColor(li.sentiment);
+            lines.push(row(`${sc}${li.sentiment}${RESET}`, inner));
+        }
+    }
+    else {
+        // No interaction — just show status badge
+        const pad = inner - badgePlain.length;
+        lines.push(row(`${" ".repeat(Math.max(0, pad))}${badge}`, inner));
+    }
+    // Bottom border
+    lines.push(`\x1b[2m└${"─".repeat(CARD_WIDTH - 2)}┘\x1b[0m`);
+    return lines;
+}
+function renderAllCards(simulations) {
+    if (simulations.length === 0)
+        return [];
+    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("");
+    for (const sim of simulations) {
+        lines.push(...renderCard(sim));
+        lines.push("");
+    }
+    return lines;
+}
+let cardLineCount = 0;
+function clearCards() {
+    if (cardLineCount > 0) {
+        process.stdout.write(`\x1b[${cardLineCount}A`);
+        for (let i = 0; i < cardLineCount; i++) {
+            process.stdout.write("\x1b[2K\n");
+        }
+        process.stdout.write(`\x1b[${cardLineCount}A`);
+    }
+}
+function renderSimulationCards(simulations) {
+    clearCards();
+    const lines = renderAllCards(simulations);
+    cardLineCount = lines.length;
+    if (lines.length > 0) {
+        process.stdout.write(lines.join("\n") + "\n");
+    }
+}
+// --- Local storage for completed simulations ---
+const SIMULATIONS_DIR = join(SPEQS_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 entry = {
+        tester_id: sim.tester_id,
+        instance_name: sim.instance_name,
+        status: sim.status,
+        study_name: sim.study_name,
+        interaction_count: sim.interaction_count,
+        last_interaction: sim.last_interaction,
+        completed_at: new Date().toISOString(),
+    };
+    writeFileSync(logFile, JSON.stringify(entry) + "\n", { flag: "a" });
+}
 // --- Token resolution ---
 async function verifyToken(token, apiUrl) {
     try {
-        const resp = await fetch(`${apiUrl}${API_BASE}/tunnel/active`, {
+        const resp = await fetch(`${apiUrl}${API_BASE}/connect/active`, {
             headers: { Authorization: `Bearer ${token}` },
             signal: AbortSignal.timeout(10_000),
         });
-        // 404 = valid token, no tunnel (expected). 401/403 = bad token.
+        // 404 = valid token, no connection (expected). 401/403 = bad token.
         return resp.status !== 401 && resp.status !== 403;
     }
     catch {
@@ -55,16 +215,15 @@ async function resolveToken(tokenArg, apiUrl) {
         // Refresh if expired or close to expiry
         if (isTokenExpired(accessToken)) {
             try {
-                console.log("Refreshing access token...");
                 const tokens = await refreshTokens(config.refresh_token);
                 accessToken = tokens.accessToken;
                 config.access_token = tokens.accessToken;
                 config.refresh_token = tokens.refreshToken;
                 saveConfig(config);
             }
-            catch (e) {
-                console.error(`Token refresh failed: ${e instanceof Error ? e.message : e}`);
-                console.error('Run "speqs login" to re-authenticate.\n');
+            catch {
+                console.error('Session expired. Run "speqs login" to re-authenticate.');
+                process.exit(1);
             }
         }
         if (await verifyToken(accessToken, apiUrl)) {
@@ -81,14 +240,16 @@ async function resolveToken(tokenArg, apiUrl) {
             };
             return { token: accessToken, refresh: doRefresh };
         }
-        console.error('Saved token is invalid. Run "speqs login" to re-authenticate.\n');
+        console.error('Saved token is invalid. Run "speqs login" to re-authenticate.');
+        process.exit(1);
     }
     // 4. 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 or expired.\n");
+        console.error('Saved token is invalid. Run "speqs login" to re-authenticate.');
+        process.exit(1);
     }
     // 5. No valid token found — direct user to login
     console.error('No valid token found. Run "speqs login" to authenticate.');
@@ -98,6 +259,11 @@ async function resolveToken(tokenArg, apiUrl) {
 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}   ███████╗██████╗ ███████╗ ██████╗ ███████╗
@@ -107,7 +273,7 @@ ${ORANGE}${BOLD}   ███████╗██████╗ █████
    ███████║██║     ███████╗╚██████╔╝███████║
    ╚══════╝╚═╝     ╚══════╝ ╚══▀▀═╝ ╚══════╝${RESET}
 
-   Tunnel active
+   Connected
 `);
 }
 // --- Cloudflared ---
@@ -175,7 +341,7 @@ function printManualInstallInstructions() {
 }
 function startCloudflared(port, binPath) {
     return new Promise((resolve, reject) => {
-        console.log(`Starting tunnel to localhost:${port}...`);
+        console.log(`Connecting to localhost:${port}...`);
         const proc = spawn(binPath, ["tunnel", "--url", `http://localhost:${port}`], {
             stdio: ["ignore", "pipe", "pipe"],
         });
@@ -211,7 +377,7 @@ function startCloudflared(port, binPath) {
 // --- API calls ---
 async function registerTunnel(apiUrl, token, tunnelUrl, port) {
     try {
-        const resp = await fetch(`${apiUrl}${API_BASE}/tunnel`, {
+        const resp = await fetch(`${apiUrl}${API_BASE}/connect`, {
             method: "POST",
             headers: {
                 Authorization: `Bearer ${token}`,
@@ -225,25 +391,39 @@ async function registerTunnel(apiUrl, token, tunnelUrl, port) {
         // Registration successful — banner already shown
     }
     catch (e) {
-        console.error(`Warning: Failed to register tunnel: ${e}`);
-        console.error("Tunnel is still active — you can retry manually.");
+        console.error(`Warning: Failed to register connection: ${e}`);
+        console.error("Connection is still active — you can retry manually.");
     }
 }
 async function deregisterTunnel(apiUrl, token) {
     try {
-        const resp = await fetch(`${apiUrl}${API_BASE}/tunnel`, {
+        const resp = await fetch(`${apiUrl}${API_BASE}/connect`, {
             method: "DELETE",
             headers: { Authorization: `Bearer ${token}` },
             signal: AbortSignal.timeout(2_000),
         });
         if (!resp.ok)
             throw new Error(`HTTP ${resp.status}`);
-        console.log("Tunnel deregistered");
+        console.log("Disconnected");
     }
     catch (e) {
-        console.error(`Warning: Failed to deregister tunnel: ${e}`);
+        console.error(`Warning: Failed to deregister connection: ${e}`);
     }
 }
+function processHeartbeatResponse(resp) {
+    resp.json().then((data) => {
+        const sims = data.simulations ?? [];
+        renderSimulationCards(sims);
+        // Store completed simulations locally
+        for (const sim of sims) {
+            if (sim.status === "completed" || sim.status === "failed" || sim.status === "cancelled") {
+                storeCompletedSimulation(sim);
+            }
+        }
+    }).catch(() => {
+        // Non-fatal: response parsing failed, silently continue
+    });
+}
 function startHeartbeat(apiUrl, getToken, doRefresh, onTokenRefreshed, onFatal) {
     let consecutiveFailures = 0;
     let stopped = false;
@@ -251,7 +431,7 @@ function startHeartbeat(apiUrl, getToken, doRefresh, onTokenRefreshed, onFatal)
         if (stopped)
             return;
         try {
-            const resp = await fetch(`${apiUrl}${API_BASE}/tunnel/heartbeat`, {
+            const resp = await fetch(`${apiUrl}${API_BASE}/connect/heartbeat`, {
                 method: "POST",
                 headers: { Authorization: `Bearer ${getToken()}` },
                 signal: AbortSignal.timeout(10_000),
@@ -263,7 +443,7 @@ function startHeartbeat(apiUrl, getToken, doRefresh, onTokenRefreshed, onFatal)
                     onTokenRefreshed(newToken);
                     console.log("Token refreshed.");
                     // Retry heartbeat with new token
-                    const retry = await fetch(`${apiUrl}${API_BASE}/tunnel/heartbeat`, {
+                    const retry = await fetch(`${apiUrl}${API_BASE}/connect/heartbeat`, {
                         method: "POST",
                         headers: { Authorization: `Bearer ${newToken}` },
                         signal: AbortSignal.timeout(10_000),
@@ -271,6 +451,7 @@ function startHeartbeat(apiUrl, getToken, doRefresh, onTokenRefreshed, onFatal)
                     if (!retry.ok)
                         throw new Error(`HTTP ${retry.status}`);
                     consecutiveFailures = 0;
+                    processHeartbeatResponse(retry);
                     return;
                 }
                 catch (refreshErr) {
@@ -280,6 +461,7 @@ function startHeartbeat(apiUrl, getToken, doRefresh, onTokenRefreshed, onFatal)
             if (!resp.ok)
                 throw new Error(`HTTP ${resp.status}`);
             consecutiveFailures = 0;
+            processHeartbeatResponse(resp);
         }
         catch (e) {
             consecutiveFailures++;

package/dist/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { program, Option } from "commander";
-import { runTunnel } from "./tunnel.js";
+import { runTunnel } from "./connect.js";
 import { login, getAppUrl } from "./auth.js";
 import { loadConfig, saveConfig } from "./config.js";
 import { upgrade } from "./upgrade.js";
@@ -39,9 +39,9 @@ program
     console.log("Logged out.");
 });
 program
-    .command("tunnel")
+    .command("connect")
     .description("Expose your localhost to Speqs via a Cloudflare tunnel")
-    .argument("<port>", "Local port to tunnel (e.g. 3000)")
+    .argument("<port>", "Local port to connect (e.g. 3000)")
     .option("-t, --token <token>", "Auth token (or set SPEQS_TOKEN, or save via interactive prompt)")
     .option("--api-url <url>", "Backend API URL (default: SPEQS_API_URL or https://api.speqs.io)")
     .addOption(new Option("--dev", "Use local dev API (http://localhost:8000)").hideHelp())

package/dist/upgrade.js

@@ -2,7 +2,7 @@ import { createWriteStream, renameSync, unlinkSync, chmodSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { pipeline } from "node:stream/promises";
 import { Readable } from "node:stream";
-const GITHUB_REPO = "speqs-io/speqs-cli";
+const BASE_URL = "https://speqs.io";
 function getPlatformTarget() {
     const platform = process.platform;
     const arch = process.arch;
@@ -18,11 +18,11 @@ function getPlatformTarget() {
     return target;
 }
 async function getLatestVersion() {
-    const res = await fetch(`https://api.github.com/repos/${GITHUB_REPO}/releases/latest`, { headers: { Accept: "application/vnd.github.v3+json" } });
+    const res = await fetch(`${BASE_URL}/api/releases/latest`);
     if (!res.ok)
         throw new Error(`Failed to fetch latest version: ${res.statusText}`);
     const data = (await res.json());
-    return data.tag_name.replace(/^v/, "");
+    return data.version;
 }
 export async function upgrade(currentVersion, targetVersion) {
     if (targetVersion && !/^\d+\.\d+\.\d+/.test(targetVersion)) {
@@ -37,7 +37,7 @@ export async function upgrade(currentVersion, targetVersion) {
     const target = getPlatformTarget();
     const ext = process.platform === "win32" ? ".exe" : "";
     const assetName = `speqs-${target}${ext}`;
-    const url = `https://github.com/${GITHUB_REPO}/releases/download/v${latest}/${assetName}`;
+    const url = `${BASE_URL}/api/releases/v${latest}/${assetName}`;
     const res = await fetch(url, { redirect: "follow" });
     if (!res.ok) {
         throw new Error(`Download failed: ${res.statusText} (${url})`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "speqs",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "The command-line interface for Speqs",
   "type": "module",
   "bin": {
@@ -22,7 +22,7 @@
   ],
   "keywords": [
     "speqs",
-    "tunnel",
+    "connect",
     "localhost",
     "testing"
   ],