audiencemeter 0.1.0

package/dist/index.js

@@ -0,0 +1,2195 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/lib/config.ts
+var config_exports = {};
+__export(config_exports, {
+  clearAuthToken: () => clearAuthToken,
+  getApiUrl: () => getApiUrl,
+  getAuthToken: () => getAuthToken,
+  getConfig: () => getConfig,
+  getRefreshToken: () => getRefreshToken,
+  setApiUrl: () => setApiUrl,
+  setAuthToken: () => setAuthToken,
+  setRefreshToken: () => setRefreshToken
+});
+import Conf from "conf";
+function getConfig() {
+  return config;
+}
+function getAuthToken() {
+  const token = config.get("authToken");
+  if (!token) {
+    throw new Error("Not authenticated. Run: audiencemeter login");
+  }
+  return token;
+}
+function setAuthToken(token) {
+  config.set("authToken", token);
+}
+function clearAuthToken() {
+  config.set("authToken", "");
+  config.set("refreshToken", "");
+}
+function getRefreshToken() {
+  return config.get("refreshToken");
+}
+function setRefreshToken(token) {
+  config.set("refreshToken", token);
+}
+function getApiUrl() {
+  return config.get("apiUrl");
+}
+function setApiUrl(url) {
+  config.set("apiUrl", url);
+}
+var config;
+var init_config = __esm({
+  "src/lib/config.ts"() {
+    "use strict";
+    config = new Conf({
+      projectName: "audiencemeter",
+      schema: {
+        apiUrl: {
+          type: "string",
+          default: "https://api.audiencemeter.pro/v1"
+        },
+        authToken: {
+          type: "string",
+          default: ""
+        },
+        refreshToken: {
+          type: "string",
+          default: ""
+        }
+      }
+    });
+  }
+});
+
+// src/lib/theme.ts
+import { rgbColor } from "terminui";
+var BRAND_COLORS, icon, BRAND;
+var init_theme = __esm({
+  "src/lib/theme.ts"() {
+    "use strict";
+    BRAND_COLORS = {
+      purple: rgbColor(175, 95, 255),
+      // Brand purple
+      cyan: rgbColor(80, 220, 220),
+      // Info/borders
+      green: rgbColor(80, 220, 120),
+      // Success/gauges
+      yellow: rgbColor(255, 200, 60),
+      // PINs
+      dimCyan: rgbColor(60, 160, 170),
+      // Borders, labels
+      red: rgbColor(255, 100, 100),
+      // Errors
+      dim: rgbColor(128, 128, 128),
+      // Dimmed text
+      white: rgbColor(230, 230, 230)
+      // Primary text
+    };
+    icon = {
+      session: "\u25CF",
+      // ●
+      live: "\u25CF",
+      // ●
+      ended: "\u25CB",
+      // ○
+      upcoming: "\u25D4",
+      // ◔
+      check: "\u2714",
+      // ✔
+      cross: "\u2718",
+      // ✘
+      arrow: "\u276F",
+      // ❯
+      dot: "\xB7",
+      // ·
+      bar: "\u2503",
+      // ┃
+      dash: "\u2500",
+      // ─
+      star: "\u2605",
+      // ★
+      sparkle: "\u2728"
+      // ✨
+    };
+    BRAND = {
+      name: "AudienceMeter",
+      tagline: "Speaker feedback, beautifully managed",
+      version: "0.1.0"
+    };
+  }
+});
+
+// src/lib/render.ts
+import {
+  createTestBackendState,
+  createTestBackend,
+  createTerminal,
+  testBackendCellAt
+} from "terminui";
+import { terminalDrawJsx } from "terminui/jsx";
+function fgAnsi(c) {
+  if (!c || c.type === "reset") return "";
+  if (c.type === "rgb") return `\x1B[38;2;${c.r};${c.g};${c.b}m`;
+  if (c.type === "indexed") return `\x1B[38;5;${c.index}m`;
+  return NAMED_FG[c.type] ? `\x1B[${NAMED_FG[c.type]}m` : "";
+}
+function bgAnsi(c) {
+  if (!c || c.type === "reset") return "";
+  if (c.type === "rgb") return `\x1B[48;2;${c.r};${c.g};${c.b}m`;
+  if (c.type === "indexed") return `\x1B[48;5;${c.index}m`;
+  return NAMED_BG[c.type] ? `\x1B[${NAMED_BG[c.type]}m` : "";
+}
+function modAnsi(mod) {
+  if (!mod) return "";
+  let s = "";
+  if (mod & 1) s += "\x1B[1m";
+  if (mod & 2) s += "\x1B[2m";
+  if (mod & 4) s += "\x1B[3m";
+  if (mod & 8) s += "\x1B[4m";
+  if (mod & 64) s += "\x1B[7m";
+  return s;
+}
+function cellToAnsi(cell) {
+  const fg = fgAnsi(cell.fg);
+  const bg = bgAnsi(cell.bg);
+  const mod = modAnsi(cell.modifier);
+  const style = fg + bg + mod;
+  if (style) {
+    return style + cell.symbol + RESET;
+  }
+  return cell.symbol;
+}
+function renderJsxToString(width, height, node) {
+  const state = createTestBackendState(width, height);
+  const terminal = createTerminal(createTestBackend(state));
+  terminalDrawJsx(terminal, node);
+  const lines = [];
+  for (let y = 0; y < height; y++) {
+    let line = "";
+    let hasStyle = false;
+    for (let x = 0; x < width; x++) {
+      const cell = testBackendCellAt(state, x, y);
+      if (!cell) {
+        if (hasStyle) {
+          line += RESET;
+          hasStyle = false;
+        }
+        line += " ";
+        continue;
+      }
+      const style = fgAnsi(cell.fg) + bgAnsi(cell.bg) + modAnsi(cell.modifier);
+      if (style) {
+        if (hasStyle) line += RESET;
+        line += style + cell.symbol;
+        hasStyle = true;
+      } else {
+        if (hasStyle) {
+          line += RESET;
+          hasStyle = false;
+        }
+        line += cell.symbol;
+      }
+    }
+    if (hasStyle) line += RESET;
+    lines.push(line.trimEnd());
+  }
+  while (lines.length > 0 && stripAnsi(lines[lines.length - 1]).trim() === "") {
+    lines.pop();
+  }
+  return lines.join("\n");
+}
+function getTermWidth() {
+  return Math.min(process.stdout.columns || 80, 120);
+}
+function stripAnsi(s) {
+  return s.replace(/\x1b\[[0-9;]*m/g, "");
+}
+var NAMED_FG, NAMED_BG, RESET;
+var init_render = __esm({
+  "src/lib/render.ts"() {
+    "use strict";
+    NAMED_FG = {
+      black: "30",
+      red: "31",
+      green: "32",
+      yellow: "33",
+      blue: "34",
+      magenta: "35",
+      cyan: "36",
+      gray: "37",
+      white: "97",
+      "dark-gray": "90",
+      "light-red": "91",
+      "light-green": "92",
+      "light-yellow": "93",
+      "light-blue": "94",
+      "light-magenta": "95",
+      "light-cyan": "96"
+    };
+    NAMED_BG = {
+      black: "40",
+      red: "41",
+      green: "42",
+      yellow: "43",
+      blue: "44",
+      magenta: "45",
+      cyan: "46",
+      gray: "47",
+      white: "107",
+      "dark-gray": "100",
+      "light-red": "101",
+      "light-green": "102",
+      "light-yellow": "103",
+      "light-blue": "104",
+      "light-magenta": "105",
+      "light-cyan": "106"
+    };
+    RESET = "\x1B[0m";
+  }
+});
+
+// src/components/KeyValue.tsx
+import { VStack, HStack, Text } from "terminui/jsx";
+import { lengthConstraint, fillConstraint } from "terminui";
+import { jsx, jsxs } from "terminui/jsx-runtime";
+function KeyValue({ pairs }) {
+  const maxKeyLen = Math.max(...pairs.map(([k]) => k.length));
+  const constraints = pairs.map(() => lengthConstraint(1));
+  const rows = pairs.map(([key, value]) => {
+    const padded = key.padStart(maxKeyLen);
+    return /* @__PURE__ */ jsxs(HStack, { constraints: [lengthConstraint(maxKeyLen + 2), fillConstraint(1)], children: [
+      /* @__PURE__ */ jsx(Text, { fg: BRAND_COLORS.dim, children: padded + "  " }),
+      /* @__PURE__ */ jsx(Text, { bold: true, fg: BRAND_COLORS.white, children: value })
+    ] });
+  });
+  return /* @__PURE__ */ jsx(VStack, { constraints, children: rows });
+}
+var init_KeyValue = __esm({
+  "src/components/KeyValue.tsx"() {
+    "use strict";
+    init_theme();
+  }
+});
+
+// src/commands/auth.ts
+var auth_exports = {};
+__export(auth_exports, {
+  authCommand: () => authCommand,
+  loginCommand: () => loginCommand,
+  logoutCommand: () => logoutCommand
+});
+import { Command } from "commander";
+import http from "http";
+import { URL } from "url";
+import * as p from "@clack/prompts";
+var SUPABASE_URL, authCommand, loginCommand, logoutCommand;
+var init_auth = __esm({
+  "src/commands/auth.ts"() {
+    "use strict";
+    init_config();
+    init_theme();
+    init_render();
+    init_KeyValue();
+    SUPABASE_URL = "https://gflvvytymdmrbjpmymhb.supabase.co";
+    authCommand = new Command("auth").description(
+      "Manage authentication"
+    );
+    loginCommand = new Command("login").description("Log in via browser (Google OAuth)");
+    loginCommand.action(async () => {
+      p.intro(`${BRAND.name} -- Login`);
+      const s = p.spinner();
+      s.start("Starting local auth server...");
+      try {
+        const token = await new Promise((resolve, reject) => {
+          const server = http.createServer((req, res) => {
+            if (!req.url) {
+              res.writeHead(400);
+              res.end("Bad request");
+              return;
+            }
+            const url = new URL(req.url, "http://localhost");
+            if (url.pathname === "/callback") {
+              res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+              res.end(`<!DOCTYPE html>
+<html><head><meta charset="utf-8"><title>${BRAND.name} \u2014 Login</title>
+<style>body{font-family:system-ui;display:flex;justify-content:center;align-items:center;height:100vh;margin:0;background:#0a0a0a;color:#e5e5e5}
+.card{text-align:center;padding:2rem;border-radius:12px;background:#171717;border:1px solid #333}</style></head>
+<body><div class="card"><p>Processing authentication...</p></div>
+<script>
+const h=window.location.hash.substring(1);const p=new URLSearchParams(h);const t=p.get('access_token');const r=p.get('refresh_token');
+if(t){let u='/token?access_token='+encodeURIComponent(t);if(r)u+='&refresh_token='+encodeURIComponent(r);window.location.href=u}
+else{document.querySelector('.card').innerHTML='<p style="color:#f87171">Authentication failed. No token found.</p><p>You can close this tab.</p>'}
+</script></body></html>`);
+              return;
+            }
+            if (url.pathname === "/token") {
+              const accessToken = url.searchParams.get("access_token");
+              const refreshTokenParam = url.searchParams.get("refresh_token");
+              if (accessToken) {
+                if (refreshTokenParam) {
+                  setRefreshToken(refreshTokenParam);
+                }
+                res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+                res.end(`<!DOCTYPE html>
+<html><head><meta charset="utf-8"><title>${BRAND.name} \u2014 Logged In</title>
+<style>body{font-family:system-ui;display:flex;justify-content:center;align-items:center;height:100vh;margin:0;background:#0a0a0a;color:#e5e5e5}
+.card{text-align:center;padding:2rem;border-radius:12px;background:#171717;border:1px solid #333}
+.check{font-size:3rem;margin-bottom:1rem}</style></head>
+<body><div class="card"><div class="check">&#x2714;</div><h2>Logged in!</h2><p>Return to your terminal.</p></div></body></html>`);
+                resolve(accessToken);
+                server.close();
+              } else {
+                res.writeHead(400, { "Content-Type": "text/html" });
+                res.end("<p>Missing access token.</p>");
+              }
+              return;
+            }
+            res.writeHead(404);
+            res.end("Not found");
+          });
+          server.listen(0, () => {
+            const address = server.address();
+            if (!address || typeof address === "string") {
+              reject(new Error("Failed to start local server"));
+              return;
+            }
+            const port = address.port;
+            const redirectUrl = `http://localhost:${port}/callback`;
+            const authUrl = `${SUPABASE_URL}/auth/v1/authorize?provider=google&redirect_to=${encodeURIComponent(redirectUrl)}`;
+            s.message("Opening browser for authentication...");
+            import("open").then((m) => m.default(authUrl)).catch(() => {
+              s.stop("Could not open browser automatically");
+              p.note(authUrl, "Open this URL manually");
+            });
+          });
+          setTimeout(() => {
+            server.close();
+            reject(new Error("Authentication timed out after 120 seconds"));
+          }, 12e4);
+        });
+        setAuthToken(token);
+        s.stop(`${icon.check} Logged in successfully!`);
+        const payload = JSON.parse(
+          Buffer.from(token.split(".")[1], "base64").toString()
+        );
+        if (payload.email) {
+          p.log.info(`Signed in as ${payload.email}`);
+        }
+        p.outro("Token stored. You can now use AudienceMeter CLI commands.");
+        process.exit(0);
+      } catch (error) {
+        s.stop(
+          `${icon.cross} Login failed: ${error instanceof Error ? error.message : "Unknown error"}`
+        );
+        process.exit(1);
+      }
+    });
+    logoutCommand = new Command("logout").description("Log out and clear stored credentials").action(async () => {
+      clearAuthToken();
+      p.log.success(`${icon.check} Logged out successfully.`);
+    });
+    authCommand.command("whoami").description("Show current authenticated user").action(async () => {
+      try {
+        const { getAuthToken: getAuthToken2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+        const token = getAuthToken2();
+        const apiUrl = getApiUrl();
+        const payload = JSON.parse(
+          Buffer.from(token.split(".")[1], "base64").toString()
+        );
+        const output = renderJsxToString(
+          getTermWidth(),
+          3,
+          KeyValue({
+            pairs: [
+              ["Email", payload.email || "unknown"],
+              ["User ID", payload.sub || "unknown"],
+              ["API URL", apiUrl]
+            ]
+          })
+        );
+        console.log(output);
+      } catch (error) {
+        if (error instanceof Error && error.message.includes("Not authenticated")) {
+          p.log.warn("Not logged in. Run: audiencemeter login");
+        } else {
+          p.log.error(
+            error instanceof Error ? error.message : "Unknown error"
+          );
+        }
+      }
+    });
+    authCommand.command("token").description("Print the current stored auth token").action(async () => {
+      try {
+        const { getAuthToken: getAuthToken2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+        const token = getAuthToken2();
+        console.log(token);
+      } catch (error) {
+        if (error instanceof Error && error.message.includes("Not authenticated")) {
+          p.log.warn("Not logged in. Run: audiencemeter login");
+        } else {
+          p.log.error(
+            error instanceof Error ? error.message : "Unknown error"
+          );
+        }
+      }
+    });
+    authCommand.addCommand(loginCommand);
+    authCommand.addCommand(logoutCommand);
+  }
+});
+
+// src/lib/api-client.ts
+function isTokenExpired(token) {
+  try {
+    const payload = JSON.parse(
+      Buffer.from(token.split(".")[1], "base64").toString()
+    );
+    if (!payload.exp) return false;
+    return Date.now() >= (payload.exp - 60) * 1e3;
+  } catch {
+    return true;
+  }
+}
+async function refreshAccessToken() {
+  const refreshToken = getRefreshToken();
+  if (!refreshToken) return null;
+  try {
+    const response = await fetch(`${SUPABASE_URL2}/auth/v1/token?grant_type=refresh_token`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "apikey": SUPABASE_ANON_KEY
+      },
+      body: JSON.stringify({ refresh_token: refreshToken })
+    });
+    if (!response.ok) return null;
+    const data = await response.json();
+    if (data.access_token) {
+      setAuthToken(data.access_token);
+      if (data.refresh_token) {
+        setRefreshToken(data.refresh_token);
+      }
+      return data.access_token;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function ensureValidToken() {
+  const token = getAuthToken();
+  if (!isTokenExpired(token)) return token;
+  const newToken = await refreshAccessToken();
+  if (newToken) return newToken;
+  throw new Error("Session expired. Run: audiencemeter login");
+}
+function createApiClient() {
+  const baseUrl = getApiUrl();
+  const authToken = getAuthToken();
+  return new ApiClient(baseUrl, authToken);
+}
+async function createApiClientWithRefresh() {
+  const baseUrl = getApiUrl();
+  const authToken = await ensureValidToken();
+  return new ApiClient(baseUrl, authToken);
+}
+function getUserIdFromToken() {
+  const token = getAuthToken();
+  const payload = JSON.parse(
+    Buffer.from(token.split(".")[1], "base64").toString()
+  );
+  return payload.sub;
+}
+function getUserEmailFromToken() {
+  const token = getAuthToken();
+  const payload = JSON.parse(
+    Buffer.from(token.split(".")[1], "base64").toString()
+  );
+  return payload.email || "unknown";
+}
+var SUPABASE_URL2, SUPABASE_ANON_KEY, ApiClient;
+var init_api_client = __esm({
+  "src/lib/api-client.ts"() {
+    "use strict";
+    init_config();
+    SUPABASE_URL2 = "https://gflvvytymdmrbjpmymhb.supabase.co";
+    SUPABASE_ANON_KEY = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImdmbHZ2eXR5bWRtcmJqcG15bWhiIiwicm9sZSI6ImFub24iLCJpYXQiOjE2ODAyNTIwMjIsImV4cCI6MTk5NTgyODAyMn0.1m-3IhFB-87AKk_-UIPzB0O1URgBwl78oKu8sNe8aFU";
+    ApiClient = class {
+      constructor(baseUrl, authToken) {
+        this.baseUrl = baseUrl;
+        this.authToken = authToken;
+      }
+      async request(method, path, body) {
+        const url = `${this.baseUrl}${path}`;
+        const headers = {
+          "Content-Type": "application/json",
+          Authorization: this.authToken
+        };
+        const options = { method, headers };
+        if (body !== void 0) {
+          options.body = JSON.stringify(body);
+        }
+        const response = await fetch(url, options);
+        if (!response.ok) {
+          let errorMessage;
+          try {
+            const errorBody = await response.json();
+            errorMessage = errorBody.message || errorBody.error || response.statusText;
+          } catch {
+            errorMessage = response.statusText;
+          }
+          if (response.status === 401) {
+            throw new Error("Not authenticated. Run: audiencemeter login");
+          }
+          throw new Error(`API error (${response.status}): ${errorMessage}`);
+        }
+        const text2 = await response.text();
+        if (!text2) return void 0;
+        return JSON.parse(text2);
+      }
+      async get(path) {
+        return this.request("GET", path);
+      }
+      async post(path, body) {
+        return this.request("POST", path, body);
+      }
+      async patch(path, body) {
+        return this.request("PATCH", path, body);
+      }
+      async delete(path) {
+        return this.request("DELETE", path);
+      }
+    };
+  }
+});
+
+// src/lib/templates.ts
+function getTemplate(name) {
+  if (!(name in TEMPLATES)) {
+    return null;
+  }
+  return TEMPLATES[name];
+}
+function getTemplateNames() {
+  return Object.keys(TEMPLATES);
+}
+var TEMPLATES;
+var init_templates = __esm({
+  "src/lib/templates.ts"() {
+    "use strict";
+    TEMPLATES = {
+      talk: {
+        description: "Conference talk or presentation (45 min)",
+        durationMinutes: 45,
+        ratings: [
+          { label: "Content Quality", maxValue: 5 },
+          { label: "Delivery", maxValue: 5 },
+          { label: "Clarity", maxValue: 5 }
+        ],
+        links: []
+      },
+      workshop: {
+        description: "Hands-on workshop or lab session (120 min)",
+        durationMinutes: 120,
+        ratings: [
+          { label: "Content Quality", maxValue: 5 },
+          { label: "Hands-on Experience", maxValue: 5 },
+          { label: "Pace", maxValue: 5 },
+          { label: "Clarity", maxValue: 5 }
+        ],
+        links: []
+      },
+      lightning: {
+        description: "Lightning talk (10 min)",
+        durationMinutes: 10,
+        ratings: [
+          { label: "Content Quality", maxValue: 5 },
+          { label: "Delivery", maxValue: 5 }
+        ],
+        links: []
+      },
+      panel: {
+        description: "Panel discussion (60 min)",
+        durationMinutes: 60,
+        ratings: [
+          { label: "Topic Relevance", maxValue: 5 },
+          { label: "Discussion Quality", maxValue: 5 },
+          { label: "Moderation", maxValue: 5 }
+        ],
+        links: []
+      }
+    };
+  }
+});
+
+// src/commands/create.ts
+var create_exports = {};
+__export(create_exports, {
+  createCommand: () => createCommand
+});
+import { Command as Command2 } from "commander";
+import * as p2 from "@clack/prompts";
+import qrcode from "qrcode-terminal";
+function padDate(n) {
+  return String(n).padStart(2, "0");
+}
+function formatLocalDate(d) {
+  return `${d.getFullYear()}-${padDate(d.getMonth() + 1)}-${padDate(d.getDate())}`;
+}
+function formatLocalTime(d) {
+  return `${padDate(d.getHours())}:${padDate(d.getMinutes())}`;
+}
+var createCommand;
+var init_create = __esm({
+  "src/commands/create.ts"() {
+    "use strict";
+    init_api_client();
+    init_templates();
+    init_theme();
+    init_render();
+    init_KeyValue();
+    createCommand = new Command2("create").description("Create a new feedback session").option("--template <type>", "Session template").option("--project <name>", "Project name (optional)").option("--name <name>", "Session name").option("--date <date>", "Session date (YYYY-MM-DD)").option("--time <time>", "Session time (HH:MM, 24h format)").option(
+      "--duration <minutes>",
+      "Duration in minutes",
+      parseInt
+    ).option("--json", "Output as JSON").action(async (options) => {
+      const isInteractive = !options.json && process.stdout.isTTY && !options.template;
+      if (isInteractive) {
+        p2.intro(`${BRAND.name} -- Create Session`);
+      }
+      try {
+        let templateName = options.template;
+        if (!templateName) {
+          if (!isInteractive) {
+            p2.log.error(
+              "Missing --template. Available: " + getTemplateNames().join(", ")
+            );
+            process.exit(1);
+          }
+          const selected = await p2.select({
+            message: "What type of session?",
+            options: Object.entries(TEMPLATES).map(([key, tmpl]) => ({
+              value: key,
+              label: key.charAt(0).toUpperCase() + key.slice(1),
+              hint: tmpl.description
+            }))
+          });
+          if (p2.isCancel(selected)) {
+            p2.cancel("Cancelled.");
+            process.exit(0);
+          }
+          templateName = selected;
+        }
+        const template = getTemplate(templateName);
+        if (!template) {
+          p2.log.error(
+            `Unknown template: "${templateName}". Available: ${getTemplateNames().join(", ")}`
+          );
+          process.exit(1);
+        }
+        let sessionName = options.name;
+        if (!sessionName && isInteractive) {
+          const input = await p2.text({
+            message: "Session name?",
+            placeholder: "My Talk at DevFest 2026",
+            validate: (v) => {
+              if (!v?.trim()) return "Session name is required";
+            }
+          });
+          if (p2.isCancel(input)) {
+            p2.cancel("Cancelled.");
+            process.exit(0);
+          }
+          sessionName = input;
+        }
+        if (!sessionName) {
+          p2.log.error("Missing --name flag.");
+          process.exit(1);
+        }
+        const now = /* @__PURE__ */ new Date();
+        let sessionDate;
+        if (options.date) {
+          const time = options.time || "00:00";
+          sessionDate = (/* @__PURE__ */ new Date(`${options.date}T${time}`)).toISOString();
+        } else if (isInteractive) {
+          const dateInput = await p2.text({
+            message: "Session date? (YYYY-MM-DD)",
+            placeholder: formatLocalDate(now),
+            defaultValue: formatLocalDate(now),
+            validate: (v) => {
+              if (!/^\d{4}-\d{2}-\d{2}$/.test(v || ""))
+                return "Use YYYY-MM-DD format";
+              if (isNaN(new Date(v).getTime()))
+                return "Invalid date";
+            }
+          });
+          if (p2.isCancel(dateInput)) {
+            p2.cancel("Cancelled.");
+            process.exit(0);
+          }
+          const timeInput = await p2.text({
+            message: "Start time? (24h format)",
+            placeholder: formatLocalTime(now),
+            defaultValue: formatLocalTime(now),
+            validate: (v) => {
+              if (!/^\d{1,2}:\d{2}$/.test(v || ""))
+                return "Use HH:MM format (e.g. 14:30)";
+            }
+          });
+          if (p2.isCancel(timeInput)) {
+            p2.cancel("Cancelled.");
+            process.exit(0);
+          }
+          sessionDate = (/* @__PURE__ */ new Date(`${dateInput}T${timeInput}`)).toISOString();
+        } else {
+          sessionDate = now.toISOString();
+        }
+        let duration = options.duration || template.durationMinutes;
+        if (!options.duration && isInteractive) {
+          const input = await p2.text({
+            message: "Duration (minutes)?",
+            defaultValue: String(template.durationMinutes),
+            placeholder: String(template.durationMinutes),
+            validate: (v) => {
+              const n = parseInt(v || "", 10);
+              if (isNaN(n) || n < 1) return "Enter a valid number of minutes";
+            }
+          });
+          if (p2.isCancel(input)) {
+            p2.cancel("Cancelled.");
+            process.exit(0);
+          }
+          duration = parseInt(input, 10);
+        }
+        const s = p2.spinner();
+        s.start("Creating session...");
+        const client = createApiClient();
+        const userId = getUserIdFromToken();
+        let projectId;
+        const projectName = options.project || "";
+        if (projectName) {
+          try {
+            s.message("Resolving project...");
+            const projectsResp = await client.get(
+              `/users/${userId}/projects`
+            );
+            const projects = Array.isArray(projectsResp) ? projectsResp : projectsResp?.data || [];
+            const existing = projects.find(
+              (proj) => proj.name.toLowerCase() === projectName.toLowerCase()
+            );
+            if (existing) {
+              projectId = existing.id;
+            } else {
+              s.message("Creating project...");
+              const newProject = await client.post(
+                `/users/${userId}/projects`,
+                { name: projectName }
+              );
+              projectId = newProject.id;
+            }
+          } catch {
+          }
+        }
+        const sessionBody = {
+          name: sessionName,
+          date: sessionDate,
+          durationMinutes: duration,
+          ratings: [...template.ratings],
+          links: [...template.links],
+          ...projectId && { projectId }
+        };
+        s.message("Creating session...");
+        const session = await client.post("/sessions", sessionBody);
+        s.stop(`${icon.check} Session created!`);
+        if (options.json) {
+          console.log(JSON.stringify(session, null, 2));
+        } else {
+          const pairs = [
+            ["Name", String(session.name || sessionName)],
+            ["PIN", String(session.pin || "")],
+            ["Template", templateName],
+            ["Duration", `${duration} minutes`],
+            ["Date", new Date(sessionDate).toLocaleString()]
+          ];
+          if (session.id) {
+            pairs.push(["ID", String(session.id)]);
+          }
+          console.log();
+          const output = renderJsxToString(
+            getTermWidth(),
+            pairs.length,
+            KeyValue({ pairs })
+          );
+          console.log(output);
+          if (session.pin) {
+            const joinUrl = `https://app.audiencemeter.pro/s/${session.pin}`;
+            console.log();
+            p2.note(joinUrl, "Join URL");
+            console.log();
+            await new Promise((resolve) => {
+              qrcode.generate(joinUrl, { small: true }, (code) => {
+                console.log(code);
+                resolve();
+              });
+            });
+          }
+          p2.outro("Share the PIN, URL, or QR code with your audience!");
+        }
+      } catch (error) {
+        p2.log.error(
+          `Failed to create session: ${error instanceof Error ? error.message : "Unknown error"}`
+        );
+        if (error instanceof Error && error.message.includes("Not authenticated")) {
+          p2.log.warn("Run: audiencemeter login");
+        }
+        process.exit(1);
+      }
+    });
+  }
+});
+
+// src/lib/node-backend.ts
+function createNodeBackend() {
+  const stdout = process.stdout;
+  return {
+    size: () => ({
+      width: stdout.columns || 80,
+      height: stdout.rows || 24
+    }),
+    draw: (content) => {
+      let out = "";
+      for (const { x, y, cell } of content) {
+        out += `${CSI}${y + 1};${x + 1}H`;
+        out += cellToAnsi(cell);
+      }
+      stdout.write(out);
+    },
+    flush: () => {
+    },
+    hideCursor: () => {
+      stdout.write(`${CSI}?25l`);
+    },
+    showCursor: () => {
+      stdout.write(`${CSI}?25h`);
+    },
+    getCursorPosition: () => ({ x: 0, y: 0 }),
+    setCursorPosition: (pos) => {
+      stdout.write(`${CSI}${pos.y + 1};${pos.x + 1}H`);
+    },
+    clear: () => {
+      stdout.write(`${CSI}2J${CSI}H`);
+    }
+  };
+}
+var CSI;
+var init_node_backend = __esm({
+  "src/lib/node-backend.ts"() {
+    "use strict";
+    init_render();
+    CSI = "\x1B[";
+  }
+});
+
+// src/lib/input.ts
+var input_exports = {};
+__export(input_exports, {
+  enterFullScreen: () => enterFullScreen,
+  exitFullScreen: () => exitFullScreen,
+  setupKeyboardInput: () => setupKeyboardInput
+});
+import readline from "readline";
+function setupKeyboardInput(handler) {
+  readline.emitKeypressEvents(process.stdin);
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(true);
+  }
+  process.stdin.resume();
+  const listener = (_str, key) => {
+    if (key) {
+      handler({
+        name: key.name ?? "",
+        ctrl: key.ctrl ?? false,
+        meta: key.meta ?? false,
+        shift: key.shift ?? false,
+        sequence: key.sequence ?? ""
+      });
+    }
+  };
+  process.stdin.on("keypress", listener);
+  return () => {
+    process.stdin.removeListener("keypress", listener);
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(false);
+    }
+    process.stdin.pause();
+  };
+}
+function enterFullScreen() {
+  if (isFullScreen) return;
+  isFullScreen = true;
+  process.stdout.write(ENTER_ALT_SCREEN);
+  process.stdout.write(HIDE_CURSOR);
+}
+function exitFullScreen() {
+  if (!isFullScreen) return;
+  isFullScreen = false;
+  process.stdout.write(SHOW_CURSOR);
+  process.stdout.write(EXIT_ALT_SCREEN);
+}
+var ENTER_ALT_SCREEN, EXIT_ALT_SCREEN, HIDE_CURSOR, SHOW_CURSOR, isFullScreen;
+var init_input = __esm({
+  "src/lib/input.ts"() {
+    "use strict";
+    ENTER_ALT_SCREEN = "\x1B[?1049h";
+    EXIT_ALT_SCREEN = "\x1B[?1049l";
+    HIDE_CURSOR = "\x1B[?25l";
+    SHOW_CURSOR = "\x1B[?25h";
+    isFullScreen = false;
+    process.on("exit", () => {
+      if (isFullScreen) {
+        try {
+          process.stdout.write(SHOW_CURSOR);
+        } catch {
+        }
+        try {
+          process.stdout.write(EXIT_ALT_SCREEN);
+        } catch {
+        }
+        isFullScreen = false;
+      }
+    });
+    process.on("SIGINT", () => {
+      if (isFullScreen) {
+        exitFullScreen();
+      }
+      process.exit(0);
+    });
+    process.on("SIGTERM", () => {
+      if (isFullScreen) {
+        exitFullScreen();
+      }
+      process.exit(0);
+    });
+    process.on("uncaughtException", (err) => {
+      if (isFullScreen) {
+        exitFullScreen();
+      }
+      console.error(err);
+      process.exit(1);
+    });
+  }
+});
+
+// src/components/Header.tsx
+import { Text as Text2 } from "terminui/jsx";
+import { jsx as jsx3 } from "terminui/jsx-runtime";
+function Header({ version } = {}) {
+  const ver = version || BRAND.version;
+  return /* @__PURE__ */ jsx3(Text2, { bold: true, fg: BRAND_COLORS.purple, align: "center", children: `${BRAND.name} v${ver}` });
+}
+var init_Header = __esm({
+  "src/components/Header.tsx"() {
+    "use strict";
+    init_theme();
+  }
+});
+
+// src/components/TabBar.tsx
+import { Tabs } from "terminui/jsx";
+import { createStyle, Modifier } from "terminui";
+import { jsx as jsx4 } from "terminui/jsx-runtime";
+function TabBar({ titles, selected }) {
+  return /* @__PURE__ */ jsx4(
+    Tabs,
+    {
+      titles,
+      selected,
+      border: true,
+      fg: BRAND_COLORS.dimCyan,
+      highlightStyle: createStyle({ fg: BRAND_COLORS.purple, addModifier: Modifier.BOLD })
+    }
+  );
+}
+var init_TabBar = __esm({
+  "src/components/TabBar.tsx"() {
+    "use strict";
+    init_theme();
+  }
+});
+
+// src/components/ShortcutBar.tsx
+import { Text as Text3 } from "terminui/jsx";
+import { jsx as jsx5 } from "terminui/jsx-runtime";
+function ShortcutBar({ shortcuts }) {
+  const text2 = shortcuts.map((s) => `${s.key}: ${s.label}`).join("  |  ");
+  return /* @__PURE__ */ jsx5(Text3, { fg: BRAND_COLORS.dimCyan, children: ` ${text2}` });
+}
+var init_ShortcutBar = __esm({
+  "src/components/ShortcutBar.tsx"() {
+    "use strict";
+    init_theme();
+  }
+});
+
+// src/components/Dashboard.tsx
+import { VStack as VStack2, HStack as HStack2, Box as Box2, Text as Text4, List, Gauge } from "terminui/jsx";
+import { fillConstraint as fillConstraint3, lengthConstraint as lengthConstraint3, createListState, createStyle as createStyle2, Modifier as Modifier2 } from "terminui";
+import { jsx as jsx6, jsxs as jsxs2 } from "terminui/jsx-runtime";
+function DashboardTab({ sessions, stats, selectedIndex, loading }) {
+  const recent = sessions.slice(0, 5);
+  const listItems = recent.length > 0 ? recent.map((s) => `${icon.session} ${s.name}  ${s.pin}  ${s.status}`) : [loading ? "Loading sessions..." : "No sessions yet. Press Tab to go to Create."];
+  const listState = createListState();
+  listState.selected = recent.length > 0 ? selectedIndex : void 0;
+  return /* @__PURE__ */ jsxs2(HStack2, { constraints: [fillConstraint3(2), fillConstraint3(1)], children: [
+    /* @__PURE__ */ jsx6(Box2, { border: true, borderType: "rounded", fg: BRAND_COLORS.dimCyan, title: " Recent Sessions ", children: /* @__PURE__ */ jsx6(
+      List,
+      {
+        items: listItems,
+        state: listState,
+        fg: BRAND_COLORS.cyan,
+        highlightStyle: createStyle2({ fg: BRAND_COLORS.purple, addModifier: Modifier2.BOLD })
+      }
+    ) }),
+    /* @__PURE__ */ jsxs2(VStack2, { constraints: [lengthConstraint3(3), lengthConstraint3(3), fillConstraint3(1)], children: [
+      /* @__PURE__ */ jsx6(Box2, { border: true, borderType: "rounded", fg: BRAND_COLORS.dimCyan, title: " Sessions ", children: /* @__PURE__ */ jsx6(Text4, { bold: true, fg: BRAND_COLORS.white, align: "center", children: String(stats.totalSessions) }) }),
+      /* @__PURE__ */ jsx6(Box2, { border: true, borderType: "rounded", fg: BRAND_COLORS.dimCyan, title: " Participants ", children: /* @__PURE__ */ jsx6(Text4, { bold: true, fg: BRAND_COLORS.white, align: "center", children: String(stats.totalParticipants) }) }),
+      /* @__PURE__ */ jsx6(Box2, { border: true, borderType: "rounded", fg: BRAND_COLORS.dimCyan, title: " Engagement ", children: /* @__PURE__ */ jsx6(
+        Gauge,
+        {
+          percent: stats.avgEngagement,
+          fg: BRAND_COLORS.green
+        }
+      ) })
+    ] })
+  ] });
+}
+function SessionsTab({ sessions, selectedIndex, loading }) {
+  if (sessions.length === 0) {
+    return /* @__PURE__ */ jsx6(Box2, { border: true, borderType: "rounded", fg: BRAND_COLORS.dimCyan, children: /* @__PURE__ */ jsx6(Text4, { fg: BRAND_COLORS.dim, children: loading ? "Loading sessions..." : "No sessions found. Create one with the Create tab." }) });
+  }
+  const listItems = sessions.map(
+    (s) => `${icon.session} ${s.name.padEnd(30).slice(0, 30)}  ${s.pin}  ${s.status.padEnd(10).slice(0, 10)}  ${s.date}`
+  );
+  const listState = createListState();
+  listState.selected = selectedIndex;
+  return /* @__PURE__ */ jsx6(Box2, { border: true, borderType: "rounded", fg: BRAND_COLORS.dimCyan, title: ` Sessions (${sessions.length}) `, children: /* @__PURE__ */ jsx6(
+    List,
+    {
+      items: listItems,
+      state: listState,
+      fg: BRAND_COLORS.cyan,
+      highlightStyle: createStyle2({ fg: BRAND_COLORS.purple, addModifier: Modifier2.BOLD })
+    }
+  ) });
+}
+function CreateTab() {
+  return /* @__PURE__ */ jsx6(Box2, { border: true, borderType: "rounded", fg: BRAND_COLORS.dimCyan, title: " Create Session ", children: /* @__PURE__ */ jsx6(Text4, { fg: BRAND_COLORS.white, children: `  Press Enter to create a new session` }) });
+}
+function AuthTab({ authEmail, authExpired }) {
+  if (authExpired) {
+    return /* @__PURE__ */ jsx6(Box2, { border: true, borderType: "rounded", title: " Authentication ", children: /* @__PURE__ */ jsx6(Text4, { fg: BRAND_COLORS.yellow, children: `  ${icon.cross} Session expired. Press Enter to re-login.` }) });
+  }
+  return /* @__PURE__ */ jsx6(Box2, { border: true, borderType: "rounded", title: " Authentication ", children: /* @__PURE__ */ jsx6(Text4, { fg: authEmail ? BRAND_COLORS.green : BRAND_COLORS.yellow, children: authEmail ? `  ${icon.check} Logged in as ${authEmail}` : `  ${icon.cross} Not logged in. Press Enter to login.` }) });
+}
+function Dashboard({ selectedTab, sessions, stats, selectedIndex, authEmail, authExpired, loading, error }) {
+  let content;
+  switch (selectedTab) {
+    case 0:
+      content = /* @__PURE__ */ jsx6(DashboardTab, { sessions, stats, selectedIndex, loading });
+      break;
+    case 1:
+      content = /* @__PURE__ */ jsx6(SessionsTab, { sessions, selectedIndex, loading });
+      break;
+    case 2:
+      content = /* @__PURE__ */ jsx6(CreateTab, {});
+      break;
+    case 3:
+      content = /* @__PURE__ */ jsx6(AuthTab, { authEmail, authExpired });
+      break;
+    default:
+      content = /* @__PURE__ */ jsx6(DashboardTab, { sessions, stats, selectedIndex });
+  }
+  if (error) {
+    return /* @__PURE__ */ jsxs2(VStack2, { constraints: [lengthConstraint3(1), lengthConstraint3(3), lengthConstraint3(1), fillConstraint3(1), lengthConstraint3(1)], children: [
+      /* @__PURE__ */ jsx6(Header, {}),
+      /* @__PURE__ */ jsx6(TabBar, { titles: [...TAB_TITLES], selected: selectedTab }),
+      /* @__PURE__ */ jsx6(Text4, { fg: BRAND_COLORS.yellow, align: "center", children: `${icon.cross} ${error}` }),
+      content,
+      /* @__PURE__ */ jsx6(ShortcutBar, { shortcuts: SHORTCUTS })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs2(VStack2, { constraints: [lengthConstraint3(1), lengthConstraint3(3), fillConstraint3(1), lengthConstraint3(1)], children: [
+    /* @__PURE__ */ jsx6(Header, {}),
+    /* @__PURE__ */ jsx6(TabBar, { titles: [...TAB_TITLES], selected: selectedTab }),
+    content,
+    /* @__PURE__ */ jsx6(ShortcutBar, { shortcuts: SHORTCUTS })
+  ] });
+}
+var TAB_TITLES, SHORTCUTS;
+var init_Dashboard = __esm({
+  "src/components/Dashboard.tsx"() {
+    "use strict";
+    init_theme();
+    init_Header();
+    init_TabBar();
+    init_ShortcutBar();
+    TAB_TITLES = ["Dashboard", "Sessions", "Create", "Auth"];
+    SHORTCUTS = [
+      { key: "Tab/1-4", label: "switch" },
+      { key: "j/k", label: "navigate" },
+      { key: "Enter", label: "select" },
+      { key: "Esc/q", label: "quit" }
+    ];
+  }
+});
+
+// src/components/MetricsPanel.tsx
+import { VStack as VStack3, Gauge as Gauge2, LineGauge, Text as Text5 } from "terminui/jsx";
+import { lengthConstraint as lengthConstraint4 } from "terminui";
+import { jsx as jsx7 } from "terminui/jsx-runtime";
+function gaugeColor(ratio) {
+  if (ratio >= 70) return BRAND_COLORS.green;
+  if (ratio >= 40) return BRAND_COLORS.cyan;
+  return BRAND_COLORS.yellow;
+}
+function MetricsPanel({ engagementRate, feedbackRate, participants }) {
+  const items = [];
+  const constraints = [];
+  if (participants !== void 0) {
+    items.push(
+      /* @__PURE__ */ jsx7(Text5, { bold: true, fg: BRAND_COLORS.white, children: `  ${String(participants)} participants` })
+    );
+    constraints.push(lengthConstraint4(1));
+  }
+  if (engagementRate !== void 0 && engagementRate > 0) {
+    items.push(
+      /* @__PURE__ */ jsx7(
+        Gauge2,
+        {
+          percent: engagementRate,
+          border: true,
+          title: ` Engagement ${engagementRate}% `,
+          fg: gaugeColor(engagementRate)
+        }
+      )
+    );
+    constraints.push(lengthConstraint4(3));
+  }
+  if (feedbackRate !== void 0 && feedbackRate > 0) {
+    items.push(
+      /* @__PURE__ */ jsx7(
+        LineGauge,
+        {
+          percent: feedbackRate,
+          border: true,
+          title: ` Feedback ${feedbackRate}% `,
+          fg: gaugeColor(feedbackRate)
+        }
+      )
+    );
+    constraints.push(lengthConstraint4(3));
+  }
+  if (items.length === 0) {
+    return /* @__PURE__ */ jsx7(Text5, { fg: BRAND_COLORS.dim, children: "No metrics available" });
+  }
+  return /* @__PURE__ */ jsx7(VStack3, { constraints, children: items });
+}
+var init_MetricsPanel = __esm({
+  "src/components/MetricsPanel.tsx"() {
+    "use strict";
+    init_theme();
+  }
+});
+
+// src/components/SessionDetail.tsx
+import { VStack as VStack4, HStack as HStack3, Box as Box4, Text as Text6, Sparkline, BarChart } from "terminui/jsx";
+import { fillConstraint as fillConstraint4, lengthConstraint as lengthConstraint5, createBarGroup, createBar } from "terminui";
+import { jsx as jsx8, jsxs as jsxs3 } from "terminui/jsx-runtime";
+function statusBadge(status) {
+  switch (status) {
+    case "live":
+      return `${icon.live} live`;
+    case "ended":
+      return `${icon.ended} ended`;
+    case "upcoming":
+      return `${icon.upcoming} upcoming`;
+    default:
+      return status;
+  }
+}
+function SessionDetail({ session, metrics, timeline, analysis, status }) {
+  const sections = [];
+  const sectionConstraints = [];
+  sections.push(
+    /* @__PURE__ */ jsx8(Text6, { bold: true, fg: BRAND_COLORS.purple, children: `  ${session.name || "Untitled Session"}  ${statusBadge(status)}` })
+  );
+  sectionConstraints.push(lengthConstraint5(1));
+  const dateStr = session.date ? new Date(session.date).toLocaleString() : session.createdAt ? new Date(session.createdAt).toLocaleString() : "--";
+  const durationStr = session.durationMinutes ? `${session.durationMinutes} minutes` : "--";
+  const infoPairs = [
+    ["PIN", session.pin || "--"],
+    ["Date", dateStr],
+    ["Duration", durationStr]
+  ];
+  if (session.id) {
+    infoPairs.push(["ID", session.id]);
+  }
+  const hasMetrics = metrics && (metrics.engagementRate !== void 0 && metrics.engagementRate > 0 || metrics.feedbackCompletionRate !== void 0 && metrics.feedbackCompletionRate > 0 || metrics.totalParticipants !== void 0);
+  if (hasMetrics) {
+    const metricsHeight = 1 + (metrics.totalParticipants !== void 0 ? 1 : 0) + (metrics.engagementRate !== void 0 && metrics.engagementRate > 0 ? 3 : 0) + (metrics.feedbackCompletionRate !== void 0 && metrics.feedbackCompletionRate > 0 ? 3 : 0);
+    const infoHeight = infoPairs.length + 2;
+    const panelHeight = Math.max(infoHeight, metricsHeight + 2);
+    sections.push(
+      /* @__PURE__ */ jsxs3(HStack3, { constraints: [fillConstraint4(1), fillConstraint4(1)], children: [
+        /* @__PURE__ */ jsx8(Box4, { border: true, borderType: "rounded", fg: BRAND_COLORS.dimCyan, title: " Session Info ", children: /* @__PURE__ */ jsx8(KeyValue, { pairs: infoPairs }) }),
+        /* @__PURE__ */ jsx8(Box4, { border: true, borderType: "rounded", fg: BRAND_COLORS.dimCyan, title: " Metrics ", children: /* @__PURE__ */ jsx8(
+          MetricsPanel,
+          {
+            engagementRate: metrics.engagementRate,
+            feedbackRate: metrics.feedbackCompletionRate,
+            participants: metrics.totalParticipants
+          }
+        ) })
+      ] })
+    );
+    sectionConstraints.push(lengthConstraint5(panelHeight));
+  } else {
+    sections.push(
+      /* @__PURE__ */ jsx8(Box4, { border: true, borderType: "rounded", fg: BRAND_COLORS.dimCyan, title: " Session Info ", children: /* @__PURE__ */ jsx8(KeyValue, { pairs: infoPairs }) })
+    );
+    sectionConstraints.push(lengthConstraint5(infoPairs.length + 2));
+  }
+  const positiveData = timeline.map((b) => b.positive || 0);
+  if (positiveData.some((v) => v > 0)) {
+    sections.push(
+      /* @__PURE__ */ jsx8(Box4, { border: true, borderType: "rounded", fg: BRAND_COLORS.dimCyan, title: " Reactions Over Time ", children: /* @__PURE__ */ jsx8(
+        Sparkline,
+        {
+          data: positiveData,
+          fg: BRAND_COLORS.green
+        }
+      ) })
+    );
+    sectionConstraints.push(lengthConstraint5(5));
+  }
+  const totalPositive = timeline.reduce((sum, b) => sum + (b.positive || 0), 0);
+  const totalNegative = timeline.reduce((sum, b) => sum + (b.negative || 0), 0);
+  if (totalPositive > 0 || totalNegative > 0) {
+    const barData = [
+      createBarGroup([createBar(totalPositive)], "Positive"),
+      createBarGroup([createBar(totalNegative)], "Negative")
+    ];
+    sections.push(
+      /* @__PURE__ */ jsx8(Box4, { border: true, borderType: "rounded", fg: BRAND_COLORS.dimCyan, title: " Reaction Summary ", children: /* @__PURE__ */ jsx8(
+        BarChart,
+        {
+          data: barData,
+          fg: BRAND_COLORS.cyan
+        }
+      ) })
+    );
+    const maxVal = Math.max(totalPositive, totalNegative, 1);
+    sectionConstraints.push(lengthConstraint5(Math.max(8, maxVal + 4)));
+  }
+  if (analysis && typeof analysis === "object") {
+    const summary = analysis.summary || analysis.feedbackSummary || "";
+    if (summary) {
+      sections.push(
+        /* @__PURE__ */ jsx8(Box4, { border: true, borderType: "rounded", fg: BRAND_COLORS.purple, title: ` ${icon.sparkle} AI Analysis `, children: /* @__PURE__ */ jsx8(Text6, { fg: BRAND_COLORS.white, children: summary }) })
+      );
+      const summaryLines = Math.ceil(summary.length / 70) + 2;
+      sectionConstraints.push(lengthConstraint5(summaryLines));
+    }
+    const insights = analysis.coachingInsights;
+    if (insights && insights.length > 0) {
+      const insightLines = insights.slice(0, 3).map(
+        (insight) => `  ${icon.arrow} ${insight}`
+      ).join("\n");
+      sections.push(
+        /* @__PURE__ */ jsx8(Box4, { border: true, borderType: "rounded", fg: BRAND_COLORS.dimCyan, title: " Coaching Insights ", children: /* @__PURE__ */ jsx8(Text6, { fg: BRAND_COLORS.white, children: insightLines }) })
+      );
+      sectionConstraints.push(lengthConstraint5(Math.min(insights.length, 3) + 2));
+    }
+  }
+  if (session.questions && session.questions.length > 0) {
+    const questionLines = session.questions.map(
+      (q) => `  ${icon.dot} [${q.type}] ${q.label}`
+    ).join("\n");
+    sections.push(
+      /* @__PURE__ */ jsx8(Box4, { border: true, borderType: "rounded", fg: BRAND_COLORS.dimCyan, title: " Rating Criteria ", children: /* @__PURE__ */ jsx8(Text6, { fg: BRAND_COLORS.white, children: questionLines }) })
+    );
+    sectionConstraints.push(lengthConstraint5(session.questions.length + 2));
+  }
+  if (session.links && session.links.length > 0) {
+    const linkLines = session.links.map(
+      (link) => `  ${icon.dot} ${link.label}: ${link.url}`
+    ).join("\n");
+    sections.push(
+      /* @__PURE__ */ jsx8(Box4, { border: true, borderType: "rounded", fg: BRAND_COLORS.dimCyan, title: " Links ", children: /* @__PURE__ */ jsx8(Text6, { fg: BRAND_COLORS.white, children: linkLines }) })
+    );
+    sectionConstraints.push(lengthConstraint5(session.links.length + 2));
+  }
+  if (session.pin) {
+    sections.push(
+      /* @__PURE__ */ jsx8(Box4, { border: true, borderType: "rounded", fg: BRAND_COLORS.dimCyan, title: " Join URL ", children: /* @__PURE__ */ jsx8(Text6, { bold: true, fg: BRAND_COLORS.cyan, children: `https://app.audiencemeter.pro/s/${session.pin}` }) })
+    );
+    sectionConstraints.push(lengthConstraint5(3));
+  }
+  return /* @__PURE__ */ jsx8(VStack4, { constraints: sectionConstraints, children: sections });
+}
+var init_SessionDetail = __esm({
+  "src/components/SessionDetail.tsx"() {
+    "use strict";
+    init_theme();
+    init_KeyValue();
+    init_MetricsPanel();
+  }
+});
+
+// src/lib/app.tsx
+var app_exports = {};
+__export(app_exports, {
+  startDashboard: () => startDashboard,
+  startInteractiveList: () => startInteractiveList
+});
+import { createTerminal as createTerminal2, terminalResize, createListState as createListState2 } from "terminui";
+import { VStack as VStack5, Box as Box5, List as List2, Text as Text7, terminalDrawJsx as terminalDrawJsx2 } from "terminui/jsx";
+import { fillConstraint as fillConstraint5, lengthConstraint as lengthConstraint6, createStyle as createStyle3, Modifier as Modifier3 } from "terminui";
+import { jsx as jsx9, jsxs as jsxs4 } from "terminui/jsx-runtime";
+function getSessionStatus(session) {
+  const sessionDate = session.date ? new Date(session.date) : session.createdAt ? new Date(session.createdAt) : null;
+  if (!sessionDate) return "unknown";
+  const now = /* @__PURE__ */ new Date();
+  const durationMs = (session.durationMinutes || 60) * 60 * 1e3;
+  const endTime = new Date(sessionDate.getTime() + durationMs);
+  if (now < sessionDate) return "upcoming";
+  if (now >= sessionDate && now <= endTime) return "live";
+  return "ended";
+}
+function statusDisplay(status) {
+  switch (status) {
+    case "live":
+      return `${icon.live} live`;
+    case "ended":
+      return `${icon.ended} ended`;
+    case "upcoming":
+      return `${icon.upcoming} soon`;
+    default:
+      return status;
+  }
+}
+function toSessionRows(sessions) {
+  return sessions.map((session) => {
+    const date = session.date ? new Date(session.date).toLocaleDateString() : session.createdAt ? new Date(session.createdAt).toLocaleDateString() : "--";
+    const duration = session.durationMinutes ? `${session.durationMinutes}min` : "--";
+    const status = getSessionStatus(session);
+    const raw = session;
+    const count = raw._count?.attendees ?? raw.participantCount ?? "--";
+    return {
+      name: session.name || "--",
+      pin: session.pin || "--",
+      status: statusDisplay(status),
+      date,
+      duration,
+      participants: String(count)
+    };
+  });
+}
+function renderDashboard(terminal, state) {
+  terminalDrawJsx2(terminal, /* @__PURE__ */ jsx9(
+    Dashboard,
+    {
+      selectedTab: state.selectedTab,
+      sessions: state.sessions,
+      stats: state.stats,
+      selectedIndex: state.selectedIndex,
+      authEmail: state.authEmail,
+      authExpired: state.authExpired,
+      loading: state.loading,
+      error: state.error
+    }
+  ));
+}
+function renderSessionDetail(terminal, session, metrics, timeline, analysis, status) {
+  const detailShortcuts = [
+    { key: "Esc/q", label: "back" }
+  ];
+  terminalDrawJsx2(terminal, /* @__PURE__ */ jsxs4(VStack5, { constraints: [fillConstraint5(1), lengthConstraint6(1)], children: [
+    /* @__PURE__ */ jsx9(
+      SessionDetail,
+      {
+        session,
+        metrics,
+        timeline,
+        analysis,
+        status
+      }
+    ),
+    /* @__PURE__ */ jsx9(ShortcutBar, { shortcuts: detailShortcuts })
+  ] }));
+}
+function renderInteractiveList(terminal, sessionRows, total, selectedIndex) {
+  const listItems = sessionRows.map(
+    (s) => `${icon.session} ${s.name.padEnd(30).slice(0, 30)}  ${s.pin}  ${s.status.padEnd(10).slice(0, 10)}  ${s.date}`
+  );
+  const listState = createListState2();
+  listState.selected = selectedIndex;
+  terminalDrawJsx2(terminal, /* @__PURE__ */ jsxs4(VStack5, { constraints: [lengthConstraint6(1), fillConstraint5(1), lengthConstraint6(1)], children: [
+    /* @__PURE__ */ jsx9(Text7, { bold: true, fg: BRAND_COLORS.purple, align: "center", children: `Sessions (${sessionRows.length} of ${total})` }),
+    /* @__PURE__ */ jsx9(Box5, { border: true, borderType: "rounded", fg: BRAND_COLORS.dimCyan, children: /* @__PURE__ */ jsx9(
+      List2,
+      {
+        items: listItems,
+        state: listState,
+        fg: BRAND_COLORS.cyan,
+        highlightStyle: createStyle3({ fg: BRAND_COLORS.purple, addModifier: Modifier3.BOLD })
+      }
+    ) }),
+    /* @__PURE__ */ jsx9(Text7, { fg: BRAND_COLORS.dimCyan, children: " j/k: navigate  |  Enter: view  |  q: quit" })
+  ] }));
+}
+async function fetchSessionDetail(sessionId) {
+  const client = createApiClient();
+  const isUuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(sessionId);
+  const path = !isUuid ? `/sessions/by-pin/${sessionId}` : `/sessions/${sessionId}`;
+  const session = await client.get(path);
+  let metrics = null;
+  let timeline = [];
+  let analysis = null;
+  if (session.id) {
+    const results = await Promise.allSettled([
+      client.get(`/sessions/${session.id}/metrics`),
+      client.get(`/sessions/${session.id}/sentiment-timeline`),
+      client.get(`/sessions/${session.id}/analysis`)
+    ]);
+    if (results[0].status === "fulfilled") metrics = results[0].value;
+    if (results[1].status === "fulfilled") timeline = results[1].value || [];
+    if (results[2].status === "fulfilled") analysis = results[2].value;
+  }
+  const status = getSessionStatus(session);
+  return {
+    session: {
+      id: session.id,
+      name: session.name,
+      pin: session.pin,
+      date: session.date ? String(session.date) : void 0,
+      durationMinutes: session.durationMinutes,
+      createdAt: session.createdAt ? String(session.createdAt) : void 0,
+      questions: session.questions,
+      links: session.links
+    },
+    metrics: metrics ? {
+      totalParticipants: metrics.totalParticipants,
+      engagementRate: metrics.engagementRate,
+      feedbackCompletionRate: metrics.feedbackCompletionRate
+    } : null,
+    timeline,
+    analysis,
+    status
+  };
+}
+async function startDashboard() {
+  let userId;
+  try {
+    userId = getUserIdFromToken();
+  } catch {
+    console.error("Not authenticated. Run: audiencemeter login");
+    process.exit(1);
+    return;
+  }
+  let authEmail = null;
+  try {
+    authEmail = getUserEmailFromToken();
+  } catch {
+    authEmail = null;
+  }
+  enterFullScreen();
+  const backend = createNodeBackend();
+  const terminal = createTerminal2(backend);
+  let authExpired = false;
+  try {
+    const token = (await Promise.resolve().then(() => (init_config(), config_exports))).getAuthToken();
+    authExpired = isTokenExpired(token);
+  } catch {
+  }
+  const state = {
+    selectedTab: 0,
+    sessions: [],
+    rawSessions: [],
+    total: 0,
+    stats: { totalSessions: 0, totalParticipants: 0, avgEngagement: 0 },
+    selectedIndex: 0,
+    authEmail: authExpired ? null : authEmail,
+    authExpired,
+    showingSession: null,
+    running: true,
+    loading: true,
+    error: null
+  };
+  renderDashboard(terminal, state);
+  let detailData = null;
+  const rerender = () => {
+    if (state.showingSession && detailData) {
+      renderSessionDetail(
+        terminal,
+        detailData.session,
+        detailData.metrics,
+        detailData.timeline,
+        detailData.analysis,
+        detailData.status
+      );
+    } else {
+      renderDashboard(terminal, state);
+    }
+  };
+  const cleanupInput = setupKeyboardInput(async (key) => {
+    if (!state.running) return;
+    if (key.ctrl && key.name === "c") {
+      state.running = false;
+      cleanupInput();
+      exitFullScreen();
+      process.exit(0);
+      return;
+    }
+    if (state.showingSession) {
+      if (key.name === "escape" || key.name === "q") {
+        state.showingSession = null;
+        detailData = null;
+        rerender();
+      }
+      return;
+    }
+    if (key.name === "tab") {
+      state.selectedTab = (state.selectedTab + 1) % 4;
+      state.selectedIndex = 0;
+      rerender();
+      return;
+    }
+    if (["1", "2", "3", "4"].includes(key.name)) {
+      state.selectedTab = parseInt(key.name, 10) - 1;
+      state.selectedIndex = 0;
+      rerender();
+      return;
+    }
+    const itemCount = state.selectedTab === 0 ? Math.min(state.sessions.length, 5) : state.sessions.length;
+    if (itemCount > 0) {
+      if (key.name === "j" || key.name === "down") {
+        state.selectedIndex = (state.selectedIndex + 1) % itemCount;
+        rerender();
+        return;
+      }
+      if (key.name === "k" || key.name === "up") {
+        state.selectedIndex = (state.selectedIndex - 1 + itemCount) % itemCount;
+        rerender();
+        return;
+      }
+    }
+    if (key.name === "return") {
+      if (state.selectedTab === 0 || state.selectedTab === 1) {
+        const rawSession = state.rawSessions[state.selectedIndex];
+        if (rawSession) {
+          const sessionId = rawSession.id || rawSession.pin;
+          if (sessionId) {
+            state.showingSession = sessionId;
+            try {
+              detailData = await fetchSessionDetail(sessionId);
+            } catch {
+              detailData = {
+                session: {
+                  name: rawSession.name,
+                  pin: rawSession.pin,
+                  date: rawSession.date ? String(rawSession.date) : void 0,
+                  durationMinutes: rawSession.durationMinutes,
+                  createdAt: rawSession.createdAt ? String(rawSession.createdAt) : void 0
+                },
+                metrics: null,
+                timeline: [],
+                analysis: null,
+                status: getSessionStatus(rawSession)
+              };
+            }
+            rerender();
+          }
+        }
+        return;
+      }
+      if (state.selectedTab === 2) {
+        state.running = false;
+        cleanupInput();
+        exitFullScreen();
+        try {
+          const { createCommand: createCommand2 } = await Promise.resolve().then(() => (init_create(), create_exports));
+          await createCommand2.parseAsync(["node", "audiencemeter"], { from: "node" });
+        } catch {
+        }
+        return;
+      }
+      if (state.selectedTab === 3) {
+        state.running = false;
+        cleanupInput();
+        exitFullScreen();
+        try {
+          const { authCommand: authCommand2 } = await Promise.resolve().then(() => (init_auth(), auth_exports));
+          const action = state.authEmail && !state.authExpired ? "whoami" : "login";
+          await authCommand2.parseAsync(["node", "audiencemeter", action], { from: "node" });
+        } catch {
+        }
+        return;
+      }
+    }
+    if (key.name === "q" || key.name === "escape") {
+      state.running = false;
+      cleanupInput();
+      exitFullScreen();
+      return;
+    }
+  });
+  const onResize = () => {
+    terminalResize(terminal, backend.size());
+    rerender();
+  };
+  process.stdout.on("resize", onResize);
+  (async () => {
+    try {
+      const client = await createApiClientWithRefresh();
+      if (state.authExpired) {
+        state.authExpired = false;
+        state.authEmail = getUserEmailFromToken();
+        state.error = null;
+      }
+      const queryParams = new URLSearchParams();
+      queryParams.set("take", "50");
+      queryParams.set("sort", "createdAt");
+      queryParams.set("order", "desc");
+      const response = await client.get(
+        `/users/${userId}/sessions?${queryParams.toString()}`
+      );
+      const sessions = Array.isArray(response) ? response : response?.data || [];
+      const total = Array.isArray(response) ? sessions.length : response?.total || sessions.length;
+      state.rawSessions = sessions;
+      state.sessions = toSessionRows(sessions);
+      state.total = total;
+      let totalParticipants = 0;
+      for (const s of sessions) {
+        const raw = s;
+        const count = raw._count?.attendees ?? raw.participantCount ?? 0;
+        totalParticipants += Number(count) || 0;
+      }
+      state.stats = {
+        totalSessions: total,
+        totalParticipants,
+        avgEngagement: 0
+      };
+      state.loading = false;
+      rerender();
+    } catch (err) {
+      state.loading = false;
+      const msg = err instanceof Error ? err.message : "Failed to load sessions";
+      if (msg.includes("expired") || msg.includes("Not authenticated")) {
+        state.authExpired = true;
+        state.authEmail = null;
+        state.error = "Session expired. Go to Auth tab and press Enter to re-login.";
+      } else {
+        state.error = msg;
+      }
+      rerender();
+    }
+  })();
+  return new Promise((resolve) => {
+    const check = setInterval(() => {
+      if (!state.running) {
+        clearInterval(check);
+        process.stdout.removeListener("resize", onResize);
+        resolve();
+      }
+    }, 100);
+  });
+}
+async function startInteractiveList(sessionRows, rawSessions, total) {
+  enterFullScreen();
+  const backend = createNodeBackend();
+  const terminal = createTerminal2(backend);
+  let selectedIndex = 0;
+  let running = true;
+  let showingDetail = false;
+  let detailData = null;
+  const rerender = () => {
+    if (showingDetail && detailData) {
+      renderSessionDetail(
+        terminal,
+        detailData.session,
+        detailData.metrics,
+        detailData.timeline,
+        detailData.analysis,
+        detailData.status
+      );
+    } else {
+      renderInteractiveList(terminal, sessionRows, total, selectedIndex);
+    }
+  };
+  rerender();
+  const cleanupInput = setupKeyboardInput(async (key) => {
+    if (!running) return;
+    if (key.ctrl && key.name === "c") {
+      running = false;
+      cleanupInput();
+      exitFullScreen();
+      process.exit(0);
+      return;
+    }
+    if (showingDetail) {
+      if (key.name === "escape" || key.name === "q") {
+        showingDetail = false;
+        detailData = null;
+        rerender();
+      }
+      return;
+    }
+    if (sessionRows.length > 0) {
+      if (key.name === "j" || key.name === "down") {
+        selectedIndex = (selectedIndex + 1) % sessionRows.length;
+        rerender();
+        return;
+      }
+      if (key.name === "k" || key.name === "up") {
+        selectedIndex = (selectedIndex - 1 + sessionRows.length) % sessionRows.length;
+        rerender();
+        return;
+      }
+    }
+    if (key.name === "return" && sessionRows.length > 0) {
+      const rawSession = rawSessions[selectedIndex];
+      if (rawSession) {
+        const sessionId = rawSession.id || rawSession.pin;
+        if (sessionId) {
+          showingDetail = true;
+          try {
+            detailData = await fetchSessionDetail(sessionId);
+          } catch {
+            detailData = {
+              session: {
+                name: rawSession.name,
+                pin: rawSession.pin,
+                date: rawSession.date ? String(rawSession.date) : void 0,
+                durationMinutes: rawSession.durationMinutes,
+                createdAt: rawSession.createdAt ? String(rawSession.createdAt) : void 0
+              },
+              metrics: null,
+              timeline: [],
+              analysis: null,
+              status: getSessionStatus(rawSession)
+            };
+          }
+          rerender();
+        }
+      }
+      return;
+    }
+    if (key.name === "q" || key.name === "escape") {
+      running = false;
+      cleanupInput();
+      exitFullScreen();
+      return;
+    }
+  });
+  const onResize = () => {
+    terminalResize(terminal, backend.size());
+    rerender();
+  };
+  process.stdout.on("resize", onResize);
+  return new Promise((resolve) => {
+    const check = setInterval(() => {
+      if (!running) {
+        clearInterval(check);
+        process.stdout.removeListener("resize", onResize);
+        resolve();
+      }
+    }, 100);
+  });
+}
+var init_app = __esm({
+  "src/lib/app.tsx"() {
+    "use strict";
+    init_node_backend();
+    init_input();
+    init_api_client();
+    init_Dashboard();
+    init_SessionDetail();
+    init_ShortcutBar();
+    init_theme();
+  }
+});
+
+// src/index.ts
+init_auth();
+init_create();
+import { Command as Command6 } from "commander";
+
+// src/commands/list.ts
+init_api_client();
+init_theme();
+init_render();
+import { Command as Command3 } from "commander";
+import * as p3 from "@clack/prompts";
+
+// src/components/SessionTable.tsx
+init_theme();
+import { Table, Box } from "terminui/jsx";
+import { fillConstraint as fillConstraint2, lengthConstraint as lengthConstraint2 } from "terminui";
+import { jsx as jsx2 } from "terminui/jsx-runtime";
+function SessionTable({ sessions, total }) {
+  const widths = [
+    fillConstraint2(1),
+    // Name -- takes remaining space
+    lengthConstraint2(7),
+    // PIN
+    lengthConstraint2(10),
+    // Status
+    lengthConstraint2(12),
+    // Date
+    lengthConstraint2(10),
+    // Duration
+    lengthConstraint2(6)
+    // Ppl
+  ];
+  const header = ["Name", "PIN", "Status", "Date", "Duration", "Ppl"];
+  const rows = sessions.map((s) => [
+    s.name,
+    s.pin,
+    s.status,
+    s.date,
+    s.duration,
+    s.participants
+  ]);
+  return /* @__PURE__ */ jsx2(
+    Box,
+    {
+      border: true,
+      borderType: "rounded",
+      fg: BRAND_COLORS.dimCyan,
+      title: ` Sessions (${sessions.length} of ${total}) `,
+      children: /* @__PURE__ */ jsx2(
+        Table,
+        {
+          widths,
+          header,
+          rows,
+          fg: BRAND_COLORS.cyan,
+          columnSpacing: 1
+        }
+      )
+    }
+  );
+}
+
+// src/commands/list.ts
+function getSessionStatus2(session) {
+  const sessionDate = session.date ? new Date(session.date) : session.createdAt ? new Date(session.createdAt) : null;
+  if (!sessionDate) return "unknown";
+  const now = /* @__PURE__ */ new Date();
+  const durationMs = (session.durationMinutes || 60) * 60 * 1e3;
+  const endTime = new Date(sessionDate.getTime() + durationMs);
+  if (now < sessionDate) return "upcoming";
+  if (now >= sessionDate && now <= endTime) return "live";
+  return "ended";
+}
+var listCommand = new Command3("list").alias("ls").description("List your feedback sessions").option("--project <name>", "Filter by project name").option("--limit <n>", "Max sessions to display", parseInt, 20).option("--json", "Output as JSON").action(async (options) => {
+  const s = p3.spinner();
+  s.start("Fetching sessions...");
+  try {
+    const client = createApiClient();
+    const userId = getUserIdFromToken();
+    const queryParams = new URLSearchParams();
+    queryParams.set("take", String(options.limit));
+    queryParams.set("sort", "createdAt");
+    queryParams.set("order", "desc");
+    const response = await client.get(
+      `/users/${userId}/sessions?${queryParams.toString()}`
+    );
+    s.stop();
+    const sessions = Array.isArray(response) ? response : response?.data || [];
+    const total = Array.isArray(response) ? sessions.length : response?.total || sessions.length;
+    if (sessions.length === 0) {
+      p3.log.warn("No sessions found.");
+      p3.log.info(
+        'Create one: audiencemeter create --template talk --project "My Talk"'
+      );
+      return;
+    }
+    if (options.json) {
+      console.log(JSON.stringify(sessions, null, 2));
+      return;
+    }
+    const statusDisplay2 = (status) => {
+      switch (status) {
+        case "live":
+          return `${icon.live} live`;
+        case "ended":
+          return `${icon.ended} ended`;
+        case "upcoming":
+          return `${icon.upcoming} soon`;
+        default:
+          return status;
+      }
+    };
+    const rows = sessions.map((session) => {
+      const date = session.date ? new Date(session.date).toLocaleDateString() : session.createdAt ? new Date(session.createdAt).toLocaleDateString() : "--";
+      const duration = session.durationMinutes ? `${session.durationMinutes}min` : "--";
+      const status = getSessionStatus2(session);
+      const raw = session;
+      const count = raw._count?.attendees ?? raw.participantCount ?? "--";
+      const participants = String(count);
+      return {
+        name: session.name || "--",
+        pin: session.pin || "--",
+        status: statusDisplay2(status),
+        date,
+        duration,
+        participants
+      };
+    });
+    if (process.stdout.isTTY && !options.json) {
+      const { startInteractiveList: startInteractiveList2 } = await Promise.resolve().then(() => (init_app(), app_exports));
+      await startInteractiveList2(rows, sessions, total);
+      return;
+    }
+    const tableHeight = rows.length + 4;
+    const output = renderJsxToString(
+      getTermWidth(),
+      tableHeight,
+      SessionTable({ sessions: rows, total })
+    );
+    console.log(output);
+  } catch (error) {
+    s.stop(
+      `${icon.cross} Failed to list sessions: ${error instanceof Error ? error.message : "Unknown error"}`
+    );
+    if (error instanceof Error && error.message.includes("Not authenticated")) {
+      p3.log.warn("Run: audiencemeter login");
+    }
+    process.exit(1);
+  }
+});
+
+// src/commands/show.ts
+init_api_client();
+init_theme();
+init_render();
+init_SessionDetail();
+import { Command as Command4 } from "commander";
+import * as p4 from "@clack/prompts";
+function getSessionStatus3(session) {
+  const sessionDate = session.date ? new Date(session.date) : session.createdAt ? new Date(session.createdAt) : null;
+  if (!sessionDate) return "unknown";
+  const now = /* @__PURE__ */ new Date();
+  const durationMs = (session.durationMinutes || 60) * 60 * 1e3;
+  const endTime = new Date(sessionDate.getTime() + durationMs);
+  if (now < sessionDate) return "upcoming";
+  if (now >= sessionDate && now <= endTime) return "live";
+  return "ended";
+}
+var showCommand = new Command4("show").description("Show session details with rich metrics").argument("<session-id>", "Session ID (UUID) or PIN (5 characters)").option("--json", "Output as JSON").action(async (sessionId, options) => {
+  const s = p4.spinner();
+  s.start("Fetching session...");
+  try {
+    const client = createApiClient();
+    const isUuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(sessionId);
+    const path = !isUuid ? `/sessions/by-pin/${sessionId}` : `/sessions/${sessionId}`;
+    const session = await client.get(path);
+    let metrics = null;
+    let timeline = [];
+    let analysis = null;
+    let isOwner = false;
+    try {
+      isOwner = !!session.userId && session.userId === getUserIdFromToken();
+    } catch {
+    }
+    if (session.id && isOwner) {
+      s.message("Fetching metrics...");
+      const results = await Promise.allSettled([
+        client.get(`/sessions/${session.id}/metrics`),
+        client.get(
+          `/sessions/${session.id}/sentiment-timeline`
+        ),
+        client.get(
+          `/sessions/${session.id}/analysis`
+        )
+      ]);
+      if (results[0].status === "fulfilled") metrics = results[0].value;
+      if (results[1].status === "fulfilled")
+        timeline = results[1].value || [];
+      if (results[2].status === "fulfilled") analysis = results[2].value;
+    }
+    s.stop();
+    if (options.json) {
+      const output2 = {
+        ...session,
+        ...metrics && { metrics },
+        ...timeline.length && { timeline },
+        ...analysis && { analysis }
+      };
+      console.log(JSON.stringify(output2, null, 2));
+      return;
+    }
+    const status = getSessionStatus3(session);
+    let height = 3;
+    const infoPairCount = 3 + (session.id ? 1 : 0);
+    const hasMetrics = metrics && (metrics.engagementRate !== void 0 && metrics.engagementRate > 0 || metrics.feedbackCompletionRate !== void 0 && metrics.feedbackCompletionRate > 0 || metrics.totalParticipants !== void 0);
+    if (hasMetrics) {
+      const metricsH = 1 + (metrics.totalParticipants !== void 0 ? 1 : 0) + (metrics.engagementRate !== void 0 && metrics.engagementRate > 0 ? 3 : 0) + (metrics.feedbackCompletionRate !== void 0 && metrics.feedbackCompletionRate > 0 ? 3 : 0);
+      height += Math.max(infoPairCount + 2, metricsH + 2);
+    } else {
+      height += infoPairCount + 2;
+    }
+    const positiveData = timeline.map((b) => b.positive || 0);
+    if (positiveData.some((v) => v > 0)) {
+      height += 5;
+    }
+    const totalPositive = timeline.reduce((sum, b) => sum + (b.positive || 0), 0);
+    const totalNegative = timeline.reduce((sum, b) => sum + (b.negative || 0), 0);
+    if (totalPositive > 0 || totalNegative > 0) {
+      const maxVal = Math.max(totalPositive, totalNegative, 1);
+      height += Math.max(8, maxVal + 4);
+    }
+    if (analysis && typeof analysis === "object") {
+      const summary = analysis.summary || analysis.feedbackSummary || "";
+      if (summary) {
+        height += Math.ceil(summary.length / 70) + 2;
+      }
+      const insights = analysis.coachingInsights;
+      if (insights && insights.length > 0) {
+        height += Math.min(insights.length, 3) + 2;
+      }
+    }
+    if (session.questions && session.questions.length > 0) {
+      height += session.questions.length + 2;
+    }
+    if (session.links && session.links.length > 0) {
+      height += session.links.length + 2;
+    }
+    if (session.pin) {
+      height += 3;
+    }
+    const sessionData = {
+      id: session.id,
+      name: session.name,
+      pin: session.pin,
+      date: session.date,
+      durationMinutes: session.durationMinutes,
+      createdAt: session.createdAt,
+      questions: session.questions,
+      links: session.links
+    };
+    const metricsData = metrics ? {
+      totalParticipants: metrics.totalParticipants,
+      engagementRate: metrics.engagementRate,
+      feedbackCompletionRate: metrics.feedbackCompletionRate
+    } : null;
+    console.log();
+    const output = renderJsxToString(
+      getTermWidth(),
+      height,
+      SessionDetail({
+        session: sessionData,
+        metrics: metricsData,
+        timeline,
+        analysis,
+        status
+      })
+    );
+    console.log(output);
+  } catch (error) {
+    s.stop(
+      `${icon.cross} Failed to fetch session: ${error instanceof Error ? error.message : "Unknown error"}`
+    );
+    if (error instanceof Error && error.message.includes("Not authenticated")) {
+      p4.log.warn("Run: audiencemeter login");
+    }
+    process.exit(1);
+  }
+});
+
+// src/commands/delete.ts
+init_api_client();
+init_theme();
+import { Command as Command5 } from "commander";
+import * as p5 from "@clack/prompts";
+var deleteCommand = new Command5("delete").alias("rm").description("Delete a session").argument("<session-id>", "Session ID (UUID)").option("--force", "Skip confirmation prompt").action(async (sessionId, options) => {
+  try {
+    const client = createApiClient();
+    let sessionName = sessionId;
+    try {
+      const session = await client.get(
+        `/sessions/${sessionId}`
+      );
+      if (session.name) {
+        sessionName = session.name;
+      }
+    } catch {
+    }
+    if (!options.force) {
+      const confirmed = await p5.confirm({
+        message: `Delete session "${sessionName}"? This cannot be undone.`
+      });
+      if (p5.isCancel(confirmed) || !confirmed) {
+        p5.log.info("Cancelled.");
+        return;
+      }
+    }
+    const s = p5.spinner();
+    s.start("Deleting session...");
+    await client.delete(`/sessions/${sessionId}`);
+    s.stop(`${icon.check} Session "${sessionName}" deleted.`);
+  } catch (error) {
+    p5.log.error(
+      `Failed to delete session: ${error instanceof Error ? error.message : "Unknown error"}`
+    );
+    if (error instanceof Error && error.message.includes("Not authenticated")) {
+      p5.log.warn("Run: audiencemeter login");
+    }
+    process.exit(1);
+  }
+});
+
+// src/index.ts
+init_theme();
+var program = new Command6();
+program.name("audiencemeter").description(
+  `${BRAND.name} CLI \u2014 ${BRAND.tagline}`
+).version(BRAND.version, "-v, --version");
+program.addCommand(loginCommand);
+program.addCommand(logoutCommand);
+program.addCommand(authCommand);
+program.addCommand(createCommand);
+program.addCommand(listCommand);
+program.addCommand(showCommand);
+program.addCommand(deleteCommand);
+var hasArgs = process.argv.length > 2;
+if (hasArgs) {
+  program.parse(process.argv);
+} else if (process.stdout.isTTY) {
+  Promise.resolve().then(() => (init_app(), app_exports)).then(({ startDashboard: startDashboard2 }) => startDashboard2()).catch((err) => {
+    Promise.resolve().then(() => (init_input(), input_exports)).then(({ exitFullScreen: exitFullScreen2 }) => {
+      exitFullScreen2();
+    }).catch(() => {
+    });
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  });
+} else {
+  program.help();
+}
+//# sourceMappingURL=index.js.map