buildless-cli 0.1.9 → 0.1.11

package/dist/index.js

@@ -1,94 +1,2364 @@
 #!/usr/bin/env node
-import { jsx as _jsx } from "react/jsx-runtime";
+
+// src/index.tsx
 import { Command } from "commander";
 import { render } from "ink";
-import { App } from "./app.js";
-import { loadConfig, saveConfig } from "./config.js";
-import { isTokenValid, startExternalLogin, decodeJwtPayload } from "./auth.js";
-import { log, setVerbose } from "./log.js";
-const ensureProjectId = (config) => {
-    if (!config.firebaseProjectId) {
-        throw new Error("Could not determine project. Please reinstall: npm install -g buildless-cli");
-    }
-};
-const runLogin = async (config, configPath) => {
-    log(`Starting login flow via ${config.webOrigin}/cli-auth`);
-    const result = await startExternalLogin({ webOrigin: config.webOrigin });
-    const payload = decodeJwtPayload(result.token);
-    const uid = payload?.user_id ?? payload?.sub ?? "unknown";
-    log(`Login successful: uid=${uid}, exp=${result.exp}, appCheck=${result.appCheckToken ? "yes" : "no"}`);
-    const next = {
-        ...config,
-        idToken: result.token,
-        tokenExp: result.exp ?? undefined,
-        appCheckToken: result.appCheckToken,
+
+// src/app.tsx
+import { useEffect as useEffect3, useState as useState4 } from "react";
+import { Box as Box3, Text as Text3 } from "ink";
+
+// src/auth.ts
+import { createServer } from "http";
+import crypto from "crypto";
+import { URL as URL2 } from "url";
+import open from "open";
+
+// src/log.ts
+var verbose = process.env.BLO_DEBUG === "1" || process.env.BLO_DEBUG === "true";
+var setVerbose = (enabled) => {
+  verbose = enabled;
+};
+var log = (message) => {
+  if (verbose) {
+    process.stderr.write(`[blo] ${message}
+`);
+  }
+};
+
+// src/auth.ts
+var decodeJwtPayload = (token) => {
+  const parts = token.split(".");
+  if (parts.length < 2) return null;
+  try {
+    const payload = Buffer.from(parts[1], "base64url").toString("utf8");
+    return JSON.parse(payload);
+  } catch {
+    return null;
+  }
+};
+var getTokenExp = (token) => {
+  const payload = decodeJwtPayload(token);
+  if (!payload || typeof payload.exp !== "number") return null;
+  return payload.exp;
+};
+var isTokenValid = (token, exp) => {
+  if (!token) return false;
+  if (exp == null) return true;
+  const now = Math.floor(Date.now() / 1e3);
+  return exp - 30 > now;
+};
+var LOGIN_TIMEOUT_MS = 12e4;
+var startExternalLogin = async (options) => {
+  const state = crypto.randomBytes(16).toString("hex");
+  const server = createServer();
+  const result = await new Promise((resolve, reject) => {
+    let settled = false;
+    const timeout = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      server.close();
+      reject(new Error("Login timed out after 2 minutes. Please try again."));
+    }, LOGIN_TIMEOUT_MS);
+    server.on("request", (req, res) => {
+      if (!req.url) return;
+      const url = new URL2(req.url, "http://localhost");
+      if (url.pathname !== "/callback") {
+        res.writeHead(404, { "Content-Type": "text/plain" });
+        res.end("Not found");
+        return;
+      }
+      if (settled) {
+        res.writeHead(409, { "Content-Type": "text/plain" });
+        res.end("Login already handled. You can close this window.");
+        return;
+      }
+      const token = url.searchParams.get("token") || "";
+      const returnedState = url.searchParams.get("state") || "";
+      const appCheckToken = url.searchParams.get("appCheckToken") || void 0;
+      if (!token || returnedState !== state) {
+        settled = true;
+        res.writeHead(400, { "Content-Type": "text/plain" });
+        res.end("Invalid login response. You can close this window.");
+        clearTimeout(timeout);
+        log(`Login callback failed: token=${token ? "present" : "missing"}, state=${returnedState === state ? "match" : "mismatch"}`);
+        reject(new Error("Login failed: invalid callback. Make sure you completed the login in your browser."));
+        server.close();
+        return;
+      }
+      settled = true;
+      res.writeHead(200, { "Content-Type": "text/plain" });
+      res.end("Login complete. You can close this window.");
+      clearTimeout(timeout);
+      const exp = getTokenExp(token);
+      log(`Login callback received: exp=${exp}, appCheck=${appCheckToken ? "yes" : "no"}`);
+      resolve({ token, exp, appCheckToken });
+      server.close();
+    });
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      if (!address || typeof address === "string") {
+        clearTimeout(timeout);
+        reject(new Error("Failed to start local login server."));
+        return;
+      }
+      const callbackUrl = `http://127.0.0.1:${address.port}/callback`;
+      const loginUrl = new URL2("/cli-auth", options.webOrigin);
+      loginUrl.searchParams.set("redirect_uri", callbackUrl);
+      loginUrl.searchParams.set("state", state);
+      log(`Login server listening on port ${address.port}`);
+      log(`Opening browser: ${loginUrl.toString()}`);
+      process.stderr.write("Opening browser for login...\n");
+      void open(loginUrl.toString());
+    });
+  });
+  return result;
+};
+
+// src/firestore.ts
+var resolveUidFromToken = (idToken) => {
+  const payload = decodeJwtPayload(idToken);
+  if (!payload) return null;
+  const uid = payload.user_id ?? payload.sub;
+  return typeof uid === "string" && uid.trim() ? uid.trim() : null;
+};
+var fromFirestoreValue = (value) => {
+  if (value == null || typeof value !== "object") return null;
+  if ("stringValue" in value) return String(value.stringValue);
+  if ("booleanValue" in value) return Boolean(value.booleanValue);
+  if ("integerValue" in value) return Number(value.integerValue);
+  if ("doubleValue" in value) return Number(value.doubleValue);
+  if ("timestampValue" in value) return String(value.timestampValue);
+  if ("referenceValue" in value) return String(value.referenceValue);
+  if ("mapValue" in value) {
+    const fields = value.mapValue?.fields || {};
+    const output = {};
+    for (const [key, entry] of Object.entries(fields)) {
+      output[key] = fromFirestoreValue(entry);
+    }
+    return output;
+  }
+  if ("arrayValue" in value) {
+    const values = value.arrayValue?.values || [];
+    return values.map(fromFirestoreValue);
+  }
+  if ("nullValue" in value) return null;
+  return null;
+};
+var parseDocument = (doc) => {
+  const fields = doc?.fields || {};
+  const output = {};
+  for (const [key, entry] of Object.entries(fields)) {
+    output[key] = fromFirestoreValue(entry);
+  }
+  return output;
+};
+var firestoreDocsBase = (projectId) => `https://firestore.googleapis.com/v1/projects/${encodeURIComponent(projectId)}/databases/(default)/documents`;
+var parseRunQueryDocs = (rows) => rows.map((row) => row.document).filter(Boolean);
+var extractDocIdFromName = (name) => {
+  if (!name) return void 0;
+  const chunks = String(name).split("/");
+  return chunks[chunks.length - 1] || void 0;
+};
+var authHeaders = (idToken, appCheckToken) => {
+  const headers = {
+    Authorization: `Bearer ${idToken}`
+  };
+  if (appCheckToken) {
+    headers["X-Firebase-AppCheck"] = appCheckToken;
+  }
+  return headers;
+};
+var fetchRunnableAppsViaServer = async (opts) => {
+  const { terminalUrl, idToken, query } = opts;
+  const url = new URL("/api/apps", terminalUrl);
+  if (query) url.searchParams.set("q", query);
+  log(`Fetching apps: GET ${url.toString()}`);
+  const response = await fetch(url.toString(), {
+    headers: { Authorization: `Bearer ${idToken}` }
+  });
+  if (!response.ok) {
+    let message;
+    try {
+      const body2 = await response.json();
+      message = body2.message;
+    } catch {
+    }
+    log(`Fetch apps failed: ${response.status} ${message || "(no message)"}`);
+    if (response.status === 401) {
+      throw new Error("Authentication failed. Try 'blo login' to re-authenticate.");
+    }
+    if (response.status === 403 && message?.toLowerCase().includes("cli access")) {
+      const uid = resolveUidFromToken(idToken) || "unknown";
+      throw new Error(`CLI access is not enabled for your account (uid: ${uid}). Contact an admin to enable it.`);
+    }
+    if (response.status >= 500) {
+      throw new Error(`Server error (${response.status}). The terminal server may be having issues.`);
+    }
+    throw new Error(message || `Failed to fetch apps (${response.status})`);
+  }
+  const body = await response.json();
+  const apps = body.apps || [];
+  log(`Fetched ${apps.length} apps`);
+  return apps;
+};
+var filterApp = (app, term) => [
+  app.projectId,
+  app.displayName,
+  app.name,
+  app.tagline,
+  app.description,
+  app.authorName,
+  app.ownerDisplayName,
+  app.versionId,
+  app.accessTier
+].filter(Boolean).some((field) => String(field).toLowerCase().includes(term));
+
+// src/ui/app-search.tsx
+import { useMemo, useState } from "react";
+import { Box, Text, useInput } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+var AppSearch = ({ apps, initialQuery, onSelect, onExit }) => {
+  const [query, setQuery] = useState(initialQuery || "");
+  const [selected, setSelected] = useState(0);
+  const [appFilter, setAppFilter] = useState("all");
+  const filtered = useMemo(() => {
+    let result = apps;
+    if (appFilter === "user") {
+      result = result.filter((app) => !app.appSource || app.appSource === "user");
+    } else if (appFilter === "published") {
+      result = result.filter((app) => app.appSource === "published");
+    }
+    const term = query.trim().toLowerCase();
+    if (!term) return result;
+    return result.filter((app) => filterApp(app, term));
+  }, [apps, query, appFilter]);
+  useInput((input, key) => {
+    if (key.ctrl && input === "c") {
+      onExit();
+      return;
+    }
+    if (key.escape) {
+      setQuery("");
+      setSelected(0);
+      return;
+    }
+    if (input === "m" || input === "M") {
+      setAppFilter("user");
+      setSelected(0);
+      return;
+    }
+    if (input === "p" || input === "P") {
+      setAppFilter("published");
+      setSelected(0);
+      return;
+    }
+    if (input === "a" || input === "A") {
+      setAppFilter("all");
+      setSelected(0);
+      return;
+    }
+    if (key.upArrow) {
+      setSelected((prev) => filtered.length ? (prev - 1 + filtered.length) % filtered.length : 0);
+      return;
+    }
+    if (key.downArrow) {
+      setSelected((prev) => filtered.length ? (prev + 1) % filtered.length : 0);
+      return;
+    }
+    if (key.return) {
+      const app = filtered[selected];
+      if (app) onSelect(app);
+      return;
+    }
+    if (key.backspace || key.delete) {
+      setQuery((prev) => prev.slice(0, -1));
+      setSelected(0);
+      return;
+    }
+    if (input) {
+      setQuery((prev) => prev + input);
+      setSelected(0);
+    }
+  });
+  const maxVisible = Math.max(3, Math.min(20, (process.stdout.rows || 24) - 6));
+  const scrollOffset = Math.max(0, Math.min(selected - maxVisible + 1, filtered.length - maxVisible));
+  const visible = filtered.slice(scrollOffset, scrollOffset + maxVisible);
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx(Text, { color: "green", children: "BLO CLI Runner Apps" }),
+    /* @__PURE__ */ jsxs(Text, { children: [
+      "Search apps: ",
+      query || "(type to filter)"
+    ] }),
+    /* @__PURE__ */ jsxs(Text, { children: [
+      "Filter:",
+      " ",
+      /* @__PURE__ */ jsx(Text, { color: appFilter === "all" ? "green" : "gray", children: "A" }),
+      /* @__PURE__ */ jsx(Text, { color: "gray", children: "ll | " }),
+      /* @__PURE__ */ jsx(Text, { color: appFilter === "user" ? "green" : "gray", children: "M" }),
+      /* @__PURE__ */ jsx(Text, { color: "gray", children: "y | " }),
+      /* @__PURE__ */ jsx(Text, { color: appFilter === "published" ? "green" : "gray", children: "P" }),
+      /* @__PURE__ */ jsx(Text, { color: "gray", children: "ublished" })
+    ] }),
+    /* @__PURE__ */ jsx(Text, { color: "gray", children: "Enter = launch, Esc = clear, Ctrl+C = exit" }),
+    /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginTop: 1, children: [
+      visible.length === 0 ? /* @__PURE__ */ jsx(Text, { children: "No runnable apps found." }) : visible.map((app, index) => {
+        const globalIndex = scrollOffset + index;
+        const isSelected = globalIndex === selected;
+        const label = app.displayName || app.name || app.projectId;
+        const author = app.authorName || app.ownerDisplayName || "Unknown";
+        const versionHint = `${app.versionSource}:${app.versionId}`;
+        return /* @__PURE__ */ jsxs(Text, { color: isSelected ? "green" : void 0, children: [
+          isSelected ? ">" : " ",
+          " ",
+          label,
+          " \u2014 ",
+          author,
+          " (",
+          versionHint,
+          ")"
+        ] }, app.id);
+      }),
+      filtered.length > maxVisible && /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+        scrollOffset + visible.length,
+        " of ",
+        filtered.length,
+        " apps"
+      ] })
+    ] })
+  ] });
+};
+
+// src/ui/runner.tsx
+import { useEffect as useEffect2, useMemo as useMemo3, useRef as useRef2, useState as useState3 } from "react";
+import { Box as Box2, Text as Text2, useInput as useInput2 } from "ink";
+
+// src/ai.ts
+async function callUnifiedChat(opts) {
+  const url = `https://us-central1-${opts.firebaseProjectId}.cloudfunctions.net/aiApi`;
+  const headers = {
+    "Content-Type": "application/json",
+    Authorization: `Bearer ${opts.idToken}`
+  };
+  if (opts.appCheckToken) {
+    headers["X-Firebase-AppCheck"] = opts.appCheckToken;
+  }
+  const res = await fetch(url, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({ data: { action: "unifiedChat", payload: opts.payload } })
+  });
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`AI request failed (${res.status}): ${text}`);
+  }
+  const json = await res.json();
+  const data = json.result?.data;
+  if (!data) throw new Error("Unexpected AI response format");
+  return data;
+}
+async function loadLatestConversation(opts) {
+  const base = firestoreDocsBase(opts.firebaseProjectId);
+  const parent = `projects/${opts.projectId}/versions/${opts.versionId}`;
+  const convoRes = await fetch(`${base}/${parent}:runQuery`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", ...authHeaders(opts.idToken, opts.appCheckToken) },
+    body: JSON.stringify({
+      structuredQuery: {
+        from: [{ collectionId: "ai_conversations" }],
+        limit: 50
+      }
+    })
+  });
+  if (!convoRes.ok) return null;
+  const convoRows = parseRunQueryDocs(await convoRes.json());
+  if (!convoRows.length) return null;
+  let bestDoc = convoRows[0];
+  let bestTime = 0;
+  for (const doc of convoRows) {
+    const data = parseDocument(doc);
+    const t = Math.max(toMs(data.updatedAt), toMs(data.createdAt));
+    if (t > bestTime || bestTime === 0) {
+      bestTime = t;
+      bestDoc = doc;
+    }
+  }
+  const conversationId = extractDocIdFromName(bestDoc?.name);
+  if (!conversationId) return null;
+  const msgRes = await fetch(
+    `${base}/${parent}/ai_conversations/${encodeURIComponent(conversationId)}:runQuery`,
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json", ...authHeaders(opts.idToken, opts.appCheckToken) },
+      body: JSON.stringify({
+        structuredQuery: {
+          from: [{ collectionId: "messages" }],
+          orderBy: [{ field: { fieldPath: "seq" }, direction: "ASCENDING" }],
+          limit: 200
+        }
+      })
+    }
+  );
+  if (!msgRes.ok) return { conversationId, messages: [], messageCount: 0 };
+  const msgDocs = parseRunQueryDocs(await msgRes.json());
+  const messages = msgDocs.map((doc) => {
+    const d = parseDocument(doc);
+    return { role: d.role, text: d.text, toolName: d.toolName || void 0 };
+  });
+  return { conversationId, messages, messageCount: messages.length };
+}
+async function createConversation(opts) {
+  const base = firestoreDocsBase(opts.firebaseProjectId);
+  const colPath = `projects/${opts.projectId}/versions/${opts.versionId}/ai_conversations`;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const res = await fetch(`${base}/${colPath}`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", ...authHeaders(opts.idToken, opts.appCheckToken) },
+    body: JSON.stringify({
+      fields: {
+        projectId: { stringValue: opts.projectId },
+        versionId: { stringValue: opts.versionId },
+        createdAt: { timestampValue: now },
+        updatedAt: { timestampValue: now }
+      }
+    })
+  });
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`Failed to create conversation (${res.status}): ${text}`);
+  }
+  const doc = await res.json();
+  const id = extractDocIdFromName(doc.name);
+  if (!id) throw new Error("Failed to extract conversation ID");
+  return id;
+}
+async function appendMessage(opts) {
+  const base = firestoreDocsBase(opts.firebaseProjectId);
+  const msgPath = `projects/${opts.projectId}/versions/${opts.versionId}/ai_conversations/${opts.conversationId}/messages`;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const fields = {
+    role: { stringValue: opts.role },
+    text: { stringValue: opts.text },
+    seq: { integerValue: String(opts.seq) },
+    createdAt: { timestampValue: now }
+  };
+  if (opts.toolName) {
+    fields.toolName = { stringValue: opts.toolName };
+  }
+  const msgRes = await fetch(`${base}/${msgPath}`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", ...authHeaders(opts.idToken, opts.appCheckToken) },
+    body: JSON.stringify({ fields })
+  });
+  if (!msgRes.ok) return;
+  const convoPath = `projects/${opts.projectId}/versions/${opts.versionId}/ai_conversations/${opts.conversationId}`;
+  await fetch(`${base}/${convoPath}?updateMask.fieldPaths=updatedAt`, {
+    method: "PATCH",
+    headers: { "Content-Type": "application/json", ...authHeaders(opts.idToken, opts.appCheckToken) },
+    body: JSON.stringify({
+      fields: { updatedAt: { timestampValue: now } }
+    })
+  }).catch(() => {
+  });
+}
+function toMs(value) {
+  if (!value) return 0;
+  if (typeof value === "number") return value;
+  if (typeof value === "string") {
+    const parsed = Date.parse(value);
+    return Number.isNaN(parsed) ? 0 : parsed;
+  }
+  return 0;
+}
+
+// src/ui/useRunnerSession.ts
+import { useEffect, useRef, useState as useState2 } from "react";
+import WebSocket from "ws";
+var toWsBaseUrl = (httpBase) => {
+  if (httpBase.startsWith("https://")) return `wss://${httpBase.slice("https://".length)}`;
+  if (httpBase.startsWith("http://")) return `ws://${httpBase.slice("http://".length)}`;
+  return httpBase;
+};
+var getTerminalSize = () => {
+  const cols = Math.max(3, Math.min(300, Number(process.stdout.columns || 80)));
+  const rows = Math.max(3, Math.min(200, Number(process.stdout.rows || 24)));
+  return { rows, cols };
+};
+var useRunnerSession = ({ projectId, versionId, terminalUrl, idToken }) => {
+  const [screen, setScreen] = useState2(null);
+  const [error, setError] = useState2(null);
+  const [connecting, setConnecting] = useState2(true);
+  const [sessionId, setSessionId] = useState2(null);
+  const wsRef = useRef(null);
+  const lastSentSizeRef = useRef("");
+  useEffect(() => {
+    let cancelled = false;
+    const run = async () => {
+      try {
+        setConnecting(true);
+        setError(null);
+        const sessionUrl = `${terminalUrl.replace(/\/+$/, "")}/api/sessions`;
+        log(`Creating session: POST ${sessionUrl}`);
+        log(`  projectId=${projectId}, versionId=${versionId || "(latest)"}`);
+        const response = await fetch(sessionUrl, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${idToken}`
+          },
+          body: JSON.stringify({
+            projectId,
+            versionId,
+            runnerVersion: "cli-dev"
+          })
+        });
+        if (!response.ok) {
+          const text = await response.text();
+          log(`Session create failed: ${response.status} ${text}`);
+          if (response.status === 401) {
+            throw new Error("Authentication failed. Try 'blo login' to re-authenticate.");
+          }
+          if (response.status === 403) {
+            throw new Error(`Access denied for project ${projectId}: ${text}`);
+          }
+          if (response.status === 429) {
+            throw new Error("Rate limited. Please wait a moment and try again.");
+          }
+          throw new Error(`Session create failed (${response.status}): ${text}`);
+        }
+        const body = await response.json();
+        if (cancelled) return;
+        const screenPayload = "screen" in body && body.screen && typeof body.screen === "object" && "sessionId" in body.screen ? body.screen : body;
+        const sid = screenPayload.sessionId || ("bootstrap" in body ? body.bootstrap?.sessionId : void 0) || "";
+        if (!sid) {
+          log(`WARNING: No sessionId in response. Response keys: ${Object.keys(body).join(", ")}`);
+          throw new Error("Server returned no session ID. The server may be running an incompatible version.");
+        }
+        log(`Session created: sessionId=${sid}`);
+        log(`  screen=${screenPayload.screen}, lines=${screenPayload.lines?.length || 0}`);
+        setScreen(screenPayload);
+        setSessionId(sid);
+        const wsBase = toWsBaseUrl(terminalUrl.replace(/\/+$/, ""));
+        const wsUrl = `${wsBase}/ws?sessionId=${encodeURIComponent(sid)}`;
+        log(`Connecting WebSocket: ${wsUrl}`);
+        const ws = new WebSocket(wsUrl);
+        wsRef.current = ws;
+        ws.onopen = () => {
+          log("WebSocket connected");
+          ws.send(JSON.stringify({ type: "init" }));
+          const size = getTerminalSize();
+          const sizeKey = `${size.rows}x${size.cols}`;
+          lastSentSizeRef.current = sizeKey;
+          log(`Sending resize: ${size.cols}x${size.rows}`);
+          ws.send(
+            JSON.stringify({
+              type: "resize",
+              rows: size.rows,
+              cols: size.cols
+            })
+          );
+          setConnecting(false);
+        };
+        ws.onmessage = (event) => {
+          try {
+            const data = JSON.parse(String(event.data));
+            if (data.type === "screen") {
+              log(`Screen update: screen=${data.screen}, lines=${data.lines?.length || 0}`);
+              setScreen(data);
+              return;
+            }
+            if (data.type === "error") {
+              log(`Server error: ${data.message}`);
+              setError(data.message);
+            }
+          } catch (err) {
+            log(`Failed to parse server message: ${err}`);
+            setError(err instanceof Error ? err.message : String(err));
+          }
+        };
+        ws.onclose = (event) => {
+          const code = event.code;
+          const reason = event.reason || "(no reason)";
+          log(`WebSocket closed: code=${code}, reason=${reason}`);
+          if (!cancelled) {
+            if (code === 1008) {
+              setError(`Session rejected by server: ${reason}`);
+            } else if (code === 1006) {
+              setError("Lost connection to server. Check if the terminal server is running.");
+            } else {
+              setError(`Connection closed (code ${code}).`);
+            }
+          }
+        };
+        ws.onerror = (event) => {
+          log(`WebSocket error: ${event.message || "unknown"}`);
+          if (!cancelled) {
+            setError(`Connection error: ${event.message || "Failed to connect to terminal server."}`);
+          }
+        };
+      } catch (err) {
+        if (!cancelled) {
+          log(`Runner error: ${err}`);
+          setError(err instanceof Error ? err.message : String(err));
+        }
+      }
+    };
+    void run();
+    return () => {
+      cancelled = true;
+      wsRef.current?.close();
+      wsRef.current = null;
+    };
+  }, [projectId, versionId, terminalUrl, idToken]);
+  useEffect(() => {
+    if (!sessionId || !process.stdout.isTTY) return;
+    const onTerminalResize = () => {
+      const ws = wsRef.current;
+      if (!ws || ws.readyState !== WebSocket.OPEN) return;
+      const size = getTerminalSize();
+      const sizeKey = `${size.rows}x${size.cols}`;
+      if (lastSentSizeRef.current === sizeKey) return;
+      lastSentSizeRef.current = sizeKey;
+      log(`Terminal resized: ${size.cols}x${size.rows}`);
+      ws.send(
+        JSON.stringify({
+          type: "resize",
+          rows: size.rows,
+          cols: size.cols
+        })
+      );
     };
-    saveConfig(configPath, next);
-    log(`Config saved to ${configPath}`);
-    return next;
-};
-const program = new Command();
-program
-    .name("blo")
-    .description("BLO terminal client")
-    .version("0.1.0")
-    .option("-v, --verbose", "Enable verbose debug output")
-    .hook("preAction", () => {
-    if (program.opts().verbose) {
-        setVerbose(true);
+    process.stdout.on("resize", onTerminalResize);
+    return () => {
+      process.stdout.off("resize", onTerminalResize);
+    };
+  }, [sessionId]);
+  const sendMessage = (message) => {
+    const ws = wsRef.current;
+    if (!ws || ws.readyState !== WebSocket.OPEN) {
+      log(`Cannot send message (ws ${ws ? `state=${ws.readyState}` : "null"}): ${JSON.stringify(message)}`);
+      if (ws && ws.readyState >= WebSocket.CLOSING) {
+        setError("Connection lost. Press x to return to apps.");
+      }
+      return;
+    }
+    log(`Sending: ${JSON.stringify(message)}`);
+    ws.send(JSON.stringify(message));
+  };
+  return { screen, error, connecting, sessionId, sendMessage };
+};
+
+// src/ui/useRunnerRenderSource.ts
+import { useMemo as useMemo2 } from "react";
+
+// ../shared/src/screen-runtime/parsing/fieldParser.ts
+var isRecord = (value) => Boolean(value && typeof value === "object" && !Array.isArray(value));
+var parseMaxLength = (value) => {
+  if (typeof value === "number" && Number.isFinite(value) && value > 0) {
+    return Math.min(Math.floor(value), 512);
+  }
+  if (typeof value === "string") {
+    const parsed = Number.parseInt(value, 10);
+    if (Number.isFinite(parsed) && parsed > 0) {
+      return Math.min(parsed, 512);
+    }
+  }
+  return 80;
+};
+var parseRows = (value) => {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return Math.max(1, Math.floor(value));
+  }
+  if (typeof value === "string") {
+    const parsed = Number.parseInt(value, 10);
+    if (Number.isFinite(parsed)) {
+      return Math.max(1, Math.floor(parsed));
     }
+  }
+  return 1;
+};
+var toFiniteNumber = (value) => {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && value.trim().length > 0) {
+    const parsed = Number(value);
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  return null;
+};
+var normalizeHotkey = (value) => {
+  const raw = String(value || "").trim().toLowerCase();
+  if (!raw) return null;
+  if (!/^[a-z0-9]$/.test(raw)) return null;
+  return raw;
+};
+
+// ../shared/src/screen-runtime/state/pathUtils.ts
+var DANGEROUS_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+var isDangerousKey = (key) => DANGEROUS_KEYS.has(key);
+var resolvePath = (source, path2) => {
+  if (!path2.trim()) return void 0;
+  return path2.split(".").reduce((acc, key) => {
+    if (!isRecord(acc)) return void 0;
+    if (isDangerousKey(key)) return void 0;
+    return acc[key];
+  }, source);
+};
+var interpolate = (template, context) => template.replace(/\{\{\s*([^}]+)\s*\}\}/g, (_full, exprRaw) => {
+  const expr = String(exprRaw || "").trim();
+  const defaultMatch = expr.match(
+    /^([A-Za-z0-9_.]+)\s*\|\s*default\s*:\s*(.+)$/
+  );
+  if (defaultMatch) {
+    const path2 = String(defaultMatch[1] || "").trim();
+    const fallbackRaw = String(defaultMatch[2] || "").trim();
+    const resolved = resolvePath(context, path2);
+    if (resolved != null) {
+      return String(resolved);
+    }
+    const fallback = fallbackRaw === "null" ? null : fallbackRaw === "true" ? true : fallbackRaw === "false" ? false : /^-?\d+(\.\d+)?$/.test(fallbackRaw) ? Number(fallbackRaw) : fallbackRaw.replace(/^["']|["']$/g, "");
+    return fallback == null ? "" : String(fallback);
+  }
+  const value = resolvePath(context, expr);
+  return value == null ? "" : String(value);
 });
-program
-    .command("login")
-    .description("Authenticate via external browser")
-    .action(async () => {
-    const { config, path } = loadConfig();
-    log(`Config loaded from ${path}`);
-    ensureProjectId(config);
-    const next = await runLogin(config, path);
-    process.stdout.write(`Logged in for project ${next.firebaseProjectId}.\n`);
+
+// ../shared/src/screen-runtime/actions/actionBuilder.ts
+var compareSortValues = (left, right) => {
+  const leftNum = toFiniteNumber(left);
+  const rightNum = toFiniteNumber(right);
+  if (leftNum != null && rightNum != null) {
+    return leftNum - rightNum;
+  }
+  const leftText = String(left ?? "").toLowerCase();
+  const rightText = String(right ?? "").toLowerCase();
+  return leftText.localeCompare(rightText);
+};
+
+// ../shared/src/screen-runtime/rendering/widgetHelpers.ts
+var fieldBindKey = (widget) => widget.bind.trim() || widget.id;
+var selectBindKey = (widget) => widget.bind.trim() || widget.id;
+var fieldLabel = (widget) => widget.label || widget.placeholder || widget.id;
+var selectLabel = (widget) => widget.label || widget.placeholder || widget.id;
+var resolveFieldValue = (widget, state) => {
+  const bindKey = fieldBindKey(widget);
+  const fallback = resolvePath(state.data, bindKey);
+  if (state.fields[bindKey] != null) {
+    return String(state.fields[bindKey] || "");
+  }
+  if (typeof fallback === "string" || typeof fallback === "number" || typeof fallback === "boolean") {
+    return String(fallback);
+  }
+  return "";
+};
+var resolveSelectValue = (widget, state) => {
+  const bindKey = selectBindKey(widget);
+  if (state.fields[bindKey] != null) {
+    return String(state.fields[bindKey] || "");
+  }
+  const fallback = resolvePath(state.data, bindKey);
+  if (typeof fallback === "string" || typeof fallback === "number" || typeof fallback === "boolean") {
+    return String(fallback);
+  }
+  return "";
+};
+var checkboxBindKey = (widget) => widget.bind.trim() || widget.id;
+var radioBindKey = (widget) => widget.bind.trim() || widget.id;
+var numberBindKey = (widget) => widget.bind.trim() || widget.id;
+var resolveCheckboxValue = (widget, state) => {
+  const bindKey = checkboxBindKey(widget);
+  if (state.fields[bindKey] != null) {
+    const v = state.fields[bindKey];
+    return v === "true" || v === "1";
+  }
+  const fallback = resolvePath(state.data, bindKey);
+  if (typeof fallback === "string") {
+    return fallback === "true" || fallback === "1";
+  }
+  return Boolean(fallback);
+};
+var resolveNumberValue = (widget, state) => {
+  const bindKey = numberBindKey(widget);
+  if (state.fields[bindKey] != null) {
+    const v = Number(state.fields[bindKey]);
+    return Number.isFinite(v) ? v : 0;
+  }
+  const fallback = resolvePath(state.data, bindKey);
+  if (typeof fallback === "number" && Number.isFinite(fallback)) return fallback;
+  return 0;
+};
+var dateBindKey = (widget) => widget.bind.trim() || widget.id;
+var resolveDateValue = (widget, state) => {
+  const bindKey = dateBindKey(widget);
+  if (state.fields[bindKey] != null) {
+    const v = String(state.fields[bindKey] || "");
+    if (parseISODate(v)) return v;
+  }
+  const fallback = resolvePath(state.data, bindKey);
+  if (typeof fallback === "string" && parseISODate(fallback)) return fallback;
+  return todayISO();
+};
+var MONTH_NAMES = [
+  "January",
+  "February",
+  "March",
+  "April",
+  "May",
+  "June",
+  "July",
+  "August",
+  "September",
+  "October",
+  "November",
+  "December"
+];
+var MONTH_ABBR = [
+  "Jan",
+  "Feb",
+  "Mar",
+  "Apr",
+  "May",
+  "Jun",
+  "Jul",
+  "Aug",
+  "Sep",
+  "Oct",
+  "Nov",
+  "Dec"
+];
+var parseISODate = (str) => {
+  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(str);
+  if (!match) return null;
+  const y = Number(match[1]);
+  const m = Number(match[2]);
+  const d = Number(match[3]);
+  if (m < 1 || m > 12 || d < 1 || d > daysInMonth(y, m)) return null;
+  return { y, m, d };
+};
+var formatDisplayDate = (y, m, d) => `${MONTH_ABBR[m - 1]} ${d}, ${y}`;
+var daysInMonth = (y, m) => {
+  if (m === 2) return y % 4 === 0 && (y % 100 !== 0 || y % 400 === 0) ? 29 : 28;
+  return [0, 31, 0, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][m];
+};
+var dayOfWeek = (y, m, d) => {
+  const t = [0, 3, 2, 5, 0, 3, 5, 1, 4, 6, 2, 4];
+  const yr = m < 3 ? y - 1 : y;
+  return (yr + Math.floor(yr / 4) - Math.floor(yr / 100) + Math.floor(yr / 400) + t[m - 1] + d) % 7;
+};
+var pad2 = (n) => n < 10 ? "0" + n : String(n);
+var toISO = (y, m, d) => `${y}-${pad2(m)}-${pad2(d)}`;
+var shiftDay = (iso, delta) => {
+  const parsed = parseISODate(iso);
+  if (!parsed) return iso;
+  const ms = Date.UTC(parsed.y, parsed.m - 1, parsed.d) + delta * 864e5;
+  const dt = new Date(ms);
+  return toISO(dt.getUTCFullYear(), dt.getUTCMonth() + 1, dt.getUTCDate());
+};
+var shiftMonth = (iso, delta) => {
+  const parsed = parseISODate(iso);
+  if (!parsed) return iso;
+  let newM = parsed.m + delta;
+  let newY = parsed.y;
+  while (newM > 12) {
+    newM -= 12;
+    newY++;
+  }
+  while (newM < 1) {
+    newM += 12;
+    newY--;
+  }
+  const clamped = Math.min(parsed.d, daysInMonth(newY, newM));
+  return toISO(newY, newM, clamped);
+};
+var buildCalendarLines = (y, m, selectedDay) => {
+  const lines = [];
+  lines.push(`  Su  Mo  Tu  We  Th  Fr  Sa`);
+  const total = daysInMonth(y, m);
+  const startDow = dayOfWeek(y, m, 1);
+  let line = " ".repeat(startDow * 4);
+  for (let d = 1; d <= total; d++) {
+    line += d === selectedDay ? `[${pad2(d)}]` : `  ${pad2(d)}`;
+    const dow = (startDow + d) % 7;
+    if (dow === 0 && d < total) {
+      lines.push(line.trimEnd());
+      line = "";
+    }
+  }
+  if (line.trim()) lines.push(line.trimEnd());
+  return lines;
+};
+var todayISO = () => {
+  const now = /* @__PURE__ */ new Date();
+  return toISO(now.getUTCFullYear(), now.getUTCMonth() + 1, now.getUTCDate());
+};
+var CANCEL_PICKER = { type: "data.set", path: "__datePicker", value: null };
+var CONFIRM_PICKER = { type: "date.pick" };
+var isDatePickerActive = (data, activeScreenId) => {
+  const raw = data.__datePicker;
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+  const picker = raw;
+  if (typeof picker.bindPath !== "string" || typeof picker.currentISO !== "string") return null;
+  if (picker.returnScreenId !== activeScreenId) return null;
+  return picker;
+};
+var renderDatePickerLines = (picker) => {
+  const iso = picker.currentISO;
+  const parsed = parseISODate(iso);
+  if (!parsed) {
+    return { lines: [{ text: "Invalid date" }], shortcuts: [], enterAction: CANCEL_PICKER, cancelAction: CANCEL_PICKER };
+  }
+  const p = "__datePicker.currentISO";
+  const setP = (v) => ({ type: "data.set", path: p, value: v });
+  return {
+    lines: [
+      { text: "" },
+      { text: "  === Select Date ===" },
+      { text: "" },
+      { text: `       ${parsed.y}` },
+      { text: `  [<]  ${MONTH_NAMES[parsed.m - 1]}  [>]` },
+      { text: "" },
+      ...buildCalendarLines(parsed.y, parsed.m, parsed.d).map((cl) => ({ text: `  ${cl}` })),
+      { text: "" },
+      { text: `  Selected: ${formatDisplayDate(parsed.y, parsed.m, parsed.d)}` },
+      { text: "" },
+      { text: "  Arrows/H/L: Day  J/K: Week" },
+      { text: "  [<] Prev Month  [>] Next Month" },
+      { text: "  [[] Prev Year   []] Next Year" },
+      { text: "  [T] Today" },
+      { text: "  Enter: Select   Esc: Cancel" }
+    ],
+    shortcuts: [
+      { key: "<", label: "Prev month", action: setP(shiftMonth(iso, -1)) },
+      { key: ">", label: "Next month", action: setP(shiftMonth(iso, 1)) },
+      { key: "h", label: "Prev day", action: setP(shiftDay(iso, -1)) },
+      { key: "l", label: "Next day", action: setP(shiftDay(iso, 1)) },
+      { key: "j", label: "Next week", action: setP(shiftDay(iso, 7)) },
+      { key: "k", label: "Prev week", action: setP(shiftDay(iso, -7)) },
+      { key: "[", label: "Prev year", action: setP(shiftMonth(iso, -12)) },
+      { key: "]", label: "Next year", action: setP(shiftMonth(iso, 12)) },
+      { key: "t", label: "Today", action: { type: "date.pick", value: todayISO() } }
+    ],
+    enterAction: CONFIRM_PICKER,
+    cancelAction: CANCEL_PICKER
+  };
+};
+
+// ../shared/src/screen-runtime/rendering/screenRenderer.ts
+var collectScreenSpecContext = (screenSpec, state, options = {}) => {
+  const ctx = { lines: [], shortcuts: [], inputFields: [], actionLines: [], listScrollInfo: {} };
+  const hotkeySet = /* @__PURE__ */ new Set();
+  const vars = {
+    ...state.data,
+    fields: state.fields
+  };
+  const picker = isDatePickerActive(state.data, state.activeScreenId);
+  if (picker) {
+    const result = renderDatePickerLines(picker);
+    return { ...ctx, ...result };
+  }
+  const sortedWidgets = [...screenSpec.widgets].sort((a, b) => {
+    const rowA = Number(a.row || 0);
+    const rowB = Number(b.row || 0);
+    if (rowA !== rowB) return rowA - rowB;
+    const colA = Number(a.col || 0);
+    const colB = Number(b.col || 0);
+    return colA - colB;
+  });
+  const pushSpacerLines = (count) => {
+    for (let i = 0; i < count; i += 1) {
+      ctx.lines.push({ text: "" });
+    }
+  };
+  sortedWidgets.forEach((widget) => {
+    if (widget.kind === "text") {
+      ctx.lines.push({
+        text: interpolate(widget.text, vars),
+        widgetId: widget.id
+      });
+      return;
+    }
+    if (widget.kind === "field") {
+      const bindKey = fieldBindKey(widget);
+      const value = resolveFieldValue(widget, state);
+      const label = fieldLabel(widget);
+      const perRowLength = Math.max(1, parseMaxLength(widget.length));
+      const rowCount = Math.max(1, parseRows(widget.rows));
+      const lineStep = Math.max(1, Number(widget.lineStep) || 1);
+      const maxLength = Math.min(512, perRowLength * rowCount);
+      const labelPrefix = label ? `${label}: ` : "";
+      const indent = " ".repeat(labelPrefix.length);
+      const rawLines = String(value || "").split(/\r?\n/);
+      const wrappedLines = [];
+      rawLines.forEach((line) => {
+        if (line.length === 0) {
+          wrappedLines.push("");
+          return;
+        }
+        for (let i = 0; i < line.length; i += perRowLength) {
+          wrappedLines.push(line.slice(i, i + perRowLength));
+        }
+      });
+      if (wrappedLines.length === 0) wrappedLines.push("");
+      const paddedLines = wrappedLines.slice(0, rowCount);
+      while (paddedLines.length < rowCount) paddedLines.push("");
+      const lineIndex = ctx.lines.length;
+      paddedLines.forEach((line, idx) => {
+        ctx.lines.push({
+          text: `${idx === 0 ? labelPrefix : indent}${line}`,
+          widgetId: widget.id,
+          fieldId: bindKey
+        });
+        const isLast = idx === paddedLines.length - 1;
+        if (lineStep > 1 && !isLast) {
+          for (let gap = 1; gap < lineStep; gap += 1) {
+            ctx.lines.push({
+              text: indent,
+              widgetId: widget.id,
+              fieldId: bindKey
+            });
+          }
+        }
+      });
+      const validationMessage = String(state.fieldErrors?.[bindKey] || "").trim();
+      if (validationMessage) {
+        ctx.lines.push({ text: `! ${validationMessage}`, widgetId: widget.id });
+      }
+      ctx.inputFields.push({
+        id: bindKey,
+        value,
+        maxLength,
+        label,
+        lineIndex,
+        rows: rowCount,
+        lineStep
+      });
+      if (!ctx.firstInput) {
+        ctx.firstInput = {
+          id: bindKey,
+          maxLength,
+          label
+        };
+      }
+      return;
+    }
+    if (widget.kind === "action") {
+      const renderedLabel = interpolate(widget.label, vars);
+      const hotkey = normalizeHotkey(widget.hotkey);
+      const lineLabel = options.hideHotkeys ? renderedLabel : hotkey ? `[${hotkey.toUpperCase()}] ${renderedLabel}` : `[ ${renderedLabel} ]`;
+      if (widget.action.type === "nav.goto") {
+        ctx.lines.push({
+          text: lineLabel,
+          widgetId: widget.id,
+          target: widget.action.target
+        });
+        if (!options.hideHotkeys && hotkey && !hotkeySet.has(hotkey)) {
+          hotkeySet.add(hotkey);
+          ctx.shortcuts.push({
+            key: hotkey,
+            label: renderedLabel,
+            target: widget.action.target
+          });
+        }
+        return;
+      }
+      ctx.lines.push({
+        text: lineLabel,
+        widgetId: widget.id,
+        action: widget.action
+      });
+      if (!options.hideHotkeys && hotkey && !hotkeySet.has(hotkey)) {
+        hotkeySet.add(hotkey);
+        ctx.shortcuts.push({
+          key: hotkey,
+          label: renderedLabel,
+          action: widget.action
+        });
+      }
+      return;
+    }
+    if (widget.kind === "select") {
+      const bindKey = selectBindKey(widget);
+      const label = selectLabel(widget);
+      const currentValue = resolveSelectValue(widget, state).trim();
+      const normalizedCurrent = currentValue.toLowerCase();
+      const gap = Math.max(1, Number(widget.gap ?? 2));
+      const parts = [];
+      const labelPrefix = label ? `${label} ` : "";
+      widget.options.forEach((option) => {
+        const renderedLabel = interpolate(option.label, vars);
+        const hotkey = normalizeHotkey(option.hotkey);
+        const normalizedOption = String(option.value || "").trim().toLowerCase();
+        const selected = normalizedCurrent.length > 0 && normalizedCurrent === normalizedOption;
+        const displayLabel = selected ? `${renderedLabel}*` : renderedLabel;
+        const lineLabel = options.hideHotkeys ? displayLabel : hotkey ? `[${hotkey.toUpperCase()}] ${displayLabel}` : `[ ${displayLabel} ]`;
+        parts.push(lineLabel);
+        if (!options.hideHotkeys && hotkey && !hotkeySet.has(hotkey)) {
+          hotkeySet.add(hotkey);
+          ctx.shortcuts.push({
+            key: hotkey,
+            label: renderedLabel,
+            action: {
+              type: "data.set",
+              path: bindKey,
+              value: option.value
+            }
+          });
+        }
+      });
+      const lineIndex = ctx.lines.length;
+      ctx.lines.push({
+        text: `${labelPrefix}${parts.join(" ".repeat(gap))}`.trimEnd(),
+        widgetId: widget.id,
+        fieldId: bindKey
+      });
+      ctx.inputFields.push({
+        id: bindKey,
+        value: currentValue,
+        maxLength: 0,
+        label,
+        lineIndex,
+        rows: 1
+      });
+      const validationMessage = String(state.fieldErrors?.[bindKey] || "").trim();
+      if (validationMessage) {
+        ctx.lines.push({ text: `! ${validationMessage}`, widgetId: widget.id });
+      }
+      return;
+    }
+    if (widget.kind === "checkbox") {
+      const bindKey = checkboxBindKey(widget);
+      const checked = resolveCheckboxValue(widget, state);
+      const marker = checked ? "[X]" : "[ ]";
+      const renderedLabel = interpolate(widget.label, vars);
+      const hotkey = normalizeHotkey(widget.hotkey);
+      const lineLabel = options.hideHotkeys ? `${marker} ${renderedLabel}` : hotkey ? `[${hotkey.toUpperCase()}] ${marker} ${renderedLabel}` : `${marker} ${renderedLabel}`;
+      const lineIndex = ctx.lines.length;
+      ctx.lines.push({ text: lineLabel, widgetId: widget.id, fieldId: bindKey });
+      const toggleAction = widget.action ?? { type: "data.toggleFlag", path: bindKey };
+      if (!options.hideHotkeys && hotkey && !hotkeySet.has(hotkey)) {
+        hotkeySet.add(hotkey);
+        ctx.shortcuts.push({
+          key: hotkey,
+          label: renderedLabel,
+          action: toggleAction
+        });
+      }
+      ctx.inputFields.push({
+        id: bindKey,
+        value: String(checked),
+        maxLength: 0,
+        label: renderedLabel,
+        lineIndex,
+        rows: 1,
+        action: toggleAction
+      });
+      return;
+    }
+    if (widget.kind === "radio") {
+      const bindKey = radioBindKey(widget);
+      const currentValue = resolveSelectValue(widget, state).trim();
+      const normalizedCurrent = currentValue.toLowerCase();
+      const gap = Math.max(1, Number(widget.gap ?? 2));
+      const parts = [];
+      const label = widget.label ? `${widget.label} ` : "";
+      widget.options.forEach((option) => {
+        const renderedLabel = interpolate(option.label, vars);
+        const hotkey = normalizeHotkey(option.hotkey);
+        const normalizedOption = String(option.value || "").trim().toLowerCase();
+        const selected = normalizedCurrent.length > 0 && normalizedCurrent === normalizedOption;
+        const marker = selected ? "(o)" : "( )";
+        const displayLabel = `${marker} ${renderedLabel}`;
+        const lineLabel = options.hideHotkeys ? displayLabel : hotkey ? `[${hotkey.toUpperCase()}] ${displayLabel}` : displayLabel;
+        parts.push(lineLabel);
+        if (!options.hideHotkeys && hotkey && !hotkeySet.has(hotkey)) {
+          hotkeySet.add(hotkey);
+          ctx.shortcuts.push({
+            key: hotkey,
+            label: renderedLabel,
+            action: { type: "data.set", path: bindKey, value: option.value }
+          });
+        }
+      });
+      const lineIndex = ctx.lines.length;
+      ctx.lines.push({
+        text: `${label}${parts.join(" ".repeat(gap))}`.trimEnd(),
+        widgetId: widget.id,
+        fieldId: bindKey
+      });
+      ctx.inputFields.push({
+        id: bindKey,
+        value: currentValue,
+        maxLength: 0,
+        label: widget.label || widget.id,
+        lineIndex,
+        rows: 1
+      });
+      const validationMessage = String(state.fieldErrors?.[bindKey] || "").trim();
+      if (validationMessage) {
+        ctx.lines.push({ text: `! ${validationMessage}`, widgetId: widget.id });
+      }
+      return;
+    }
+    if (widget.kind === "number") {
+      const bindKey = numberBindKey(widget);
+      const value = resolveNumberValue(widget, state);
+      const label = widget.label || widget.id;
+      const step = typeof widget.step === "number" && Number.isFinite(widget.step) ? widget.step : 1;
+      const incAction = {
+        type: "data.increment",
+        path: bindKey,
+        by: step,
+        ...typeof widget.min === "number" ? { min: widget.min } : {},
+        ...typeof widget.max === "number" ? { max: widget.max } : {}
+      };
+      const decAction = {
+        type: "data.increment",
+        path: bindKey,
+        by: -step,
+        ...typeof widget.min === "number" ? { min: widget.min } : {},
+        ...typeof widget.max === "number" ? { max: widget.max } : {}
+      };
+      const lineLabel = options.hideHotkeys ? `${label}: [ ${value} ]` : `${label}: [ ${value} ]  [+][-]`;
+      const lineIndex = ctx.lines.length;
+      ctx.lines.push({ text: lineLabel, widgetId: widget.id, fieldId: bindKey });
+      if (!options.hideHotkeys) {
+        if (!hotkeySet.has("+")) {
+          hotkeySet.add("+");
+          ctx.shortcuts.push({ key: "+", label: `${label} +`, action: incAction });
+        }
+        if (!hotkeySet.has("-")) {
+          hotkeySet.add("-");
+          ctx.shortcuts.push({ key: "-", label: `${label} -`, action: decAction });
+        }
+      }
+      ctx.inputFields.push({
+        id: bindKey,
+        value: String(value),
+        maxLength: 0,
+        label,
+        lineIndex,
+        rows: 1
+      });
+      const validationMessage = String(state.fieldErrors?.[bindKey] || "").trim();
+      if (validationMessage) {
+        ctx.lines.push({ text: `! ${validationMessage}`, widgetId: widget.id });
+      }
+      return;
+    }
+    if (widget.kind === "date") {
+      const bindKey = dateBindKey(widget);
+      const iso = resolveDateValue(widget, state);
+      const parsed = parseISODate(iso);
+      const label = widget.label || widget.id;
+      const display = widget.display || "inline";
+      const dateLineIndex = ctx.lines.length;
+      if (display === "calendar" && parsed) {
+        const monthLabel = `${MONTH_NAMES[parsed.m - 1]} ${parsed.y}`;
+        ctx.lines.push({ text: `${label}:   ${monthLabel}`, widgetId: widget.id, fieldId: bindKey });
+        const navLine = options.hideHotkeys ? "" : `[<]                   [>]`;
+        if (navLine) ctx.lines.push({ text: navLine, widgetId: widget.id });
+        const calLines = buildCalendarLines(parsed.y, parsed.m, parsed.d);
+        for (const cl of calLines) {
+          ctx.lines.push({ text: cl, widgetId: widget.id });
+        }
+        if (!options.hideHotkeys) {
+          if (!hotkeySet.has("<")) {
+            hotkeySet.add("<");
+            ctx.shortcuts.push({
+              key: "<",
+              label: `${label} prev month`,
+              action: { type: "data.set", path: bindKey, value: shiftMonth(iso, -1) }
+            });
+          }
+          if (!hotkeySet.has(">")) {
+            hotkeySet.add(">");
+            ctx.shortcuts.push({
+              key: ">",
+              label: `${label} next month`,
+              action: { type: "data.set", path: bindKey, value: shiftMonth(iso, 1) }
+            });
+          }
+        }
+      } else if (parsed) {
+        const displayStr = formatDisplayDate(parsed.y, parsed.m, parsed.d);
+        const lineLabel = options.hideHotkeys ? `${label}: ${displayStr}` : `${label}: [<] ${displayStr} [>]`;
+        ctx.lines.push({ text: lineLabel, widgetId: widget.id, fieldId: bindKey });
+        if (!options.hideHotkeys) {
+          if (!hotkeySet.has("<")) {
+            hotkeySet.add("<");
+            ctx.shortcuts.push({
+              key: "<",
+              label: `${label} prev day`,
+              action: { type: "data.set", path: bindKey, value: shiftDay(iso, -1) }
+            });
+          }
+          if (!hotkeySet.has(">")) {
+            hotkeySet.add(">");
+            ctx.shortcuts.push({
+              key: ">",
+              label: `${label} next day`,
+              action: { type: "data.set", path: bindKey, value: shiftDay(iso, 1) }
+            });
+          }
+        }
+      }
+      if (!ctx.enterAction) {
+        ctx.enterAction = {
+          type: "data.set",
+          path: "__datePicker",
+          value: {
+            bindPath: bindKey,
+            currentISO: iso,
+            returnScreenId: screenSpec.id
+          }
+        };
+      }
+      ctx.inputFields.push({
+        id: bindKey,
+        value: iso,
+        maxLength: 0,
+        label,
+        lineIndex: dateLineIndex,
+        rows: 1
+      });
+      const validationMessage = String(state.fieldErrors?.[bindKey] || "").trim();
+      if (validationMessage) {
+        ctx.lines.push({ text: `! ${validationMessage}`, widgetId: widget.id });
+      }
+      return;
+    }
+    if (widget.kind === "row") {
+      const gap = Math.max(1, Number(widget.gap ?? 2));
+      const parts = [];
+      widget.items.forEach((item) => {
+        if (item.kind === "text") {
+          parts.push(interpolate(item.text, vars));
+          return;
+        }
+        const renderedLabel = interpolate(item.label, vars);
+        const hotkey = normalizeHotkey(item.hotkey);
+        const lineLabel = options.hideHotkeys ? renderedLabel : hotkey ? `[${hotkey.toUpperCase()}] ${renderedLabel}` : `[ ${renderedLabel} ]`;
+        parts.push(lineLabel);
+        if (!options.hideHotkeys && hotkey && !hotkeySet.has(hotkey)) {
+          hotkeySet.add(hotkey);
+          ctx.shortcuts.push({
+            key: hotkey,
+            label: renderedLabel,
+            action: item.action
+          });
+        }
+      });
+      ctx.lines.push({
+        text: parts.join(" ".repeat(gap)),
+        widgetId: widget.id
+      });
+      return;
+    }
+    if (widget.kind === "table") {
+      const padCell = (text, width, align = "left") => {
+        const truncated = text.length > width ? text.slice(0, width) : text;
+        return align === "right" ? truncated.padStart(width) : truncated.padEnd(width);
+      };
+      const marginTop = Math.max(0, Number(widget.marginTop ?? 1));
+      if (marginTop) pushSpacerLines(marginTop);
+      const listValue = resolvePath(vars, widget.bind);
+      let rows = Array.isArray(listValue) ? listValue : [];
+      if (widget.whereEqualsPath) {
+        rows = rows.filter((item) => {
+          const raw = resolvePath(item, widget.whereEqualsPath || "");
+          return raw === widget.whereEquals;
+        });
+      }
+      const sortByPath = String(widget.sortByPath || "").trim();
+      if (sortByPath) {
+        const direction = String(widget.sortDirection || "asc").trim().toLowerCase() === "desc" ? -1 : 1;
+        rows = [...rows].sort((left, right) => {
+          const leftValue = resolvePath(left, sortByPath);
+          const rightValue = resolvePath(right, sortByPath);
+          const primary = compareSortValues(leftValue, rightValue) * direction;
+          if (primary !== 0) return primary;
+          return compareSortValues(resolvePath(left, "id"), resolvePath(right, "id"));
+        });
+      }
+      const cols = widget.columns;
+      const separator = "+" + cols.map((c) => "-".repeat(c.width)).join("+") + "+";
+      const headerRow = "|" + cols.map((c) => padCell(c.header, c.width)).join("|") + "|";
+      ctx.lines.push({ text: separator, widgetId: widget.id });
+      ctx.lines.push({ text: headerRow, widgetId: widget.id });
+      ctx.lines.push({ text: separator, widgetId: widget.id });
+      if (!rows.length) {
+        const emptyText = widget.emptyText || "(no rows)";
+        const totalInner = cols.reduce((sum, c) => sum + c.width, 0) + cols.length - 1;
+        const paddedEmpty = emptyText.length > totalInner ? emptyText.slice(0, totalInner) : emptyText.padEnd(totalInner);
+        ctx.lines.push({ text: "|" + paddedEmpty + "|", widgetId: widget.id });
+        ctx.lines.push({ text: separator, widgetId: widget.id });
+        const marginBottom2 = Math.max(0, Number(widget.marginBottom ?? 1));
+        if (marginBottom2) pushSpacerLines(marginBottom2);
+        return;
+      }
+      const maxVisible = Math.max(1, Number(widget.height) || 10);
+      const tableScrollable = rows.length > maxVisible;
+      const tableOffset = Math.max(0, Math.min(options.listScrollOffsets?.[widget.id] ?? 0, rows.length - maxVisible));
+      const visibleRows = rows.slice(tableOffset, tableOffset + maxVisible);
+      if (tableScrollable) {
+        ctx.lines.push({ text: tableOffset > 0 ? `\u2191 ${tableOffset} more` : "", widgetId: widget.id });
+      }
+      visibleRows.forEach((item, sliceIndex) => {
+        const index = tableOffset + sliceIndex;
+        const fields = {};
+        Object.entries(widget.rowActionFields || {}).forEach(([fieldId, valuePath]) => {
+          const raw = resolvePath(item, String(valuePath || "").trim());
+          fields[String(fieldId)] = raw == null ? "" : String(raw);
+        });
+        const rowActionField = String(widget.rowActionField || "").trim();
+        if (rowActionField) {
+          const valuePath = String(widget.rowActionValuePath || "").trim() || "id";
+          const rawValue = resolvePath(item, valuePath);
+          fields[rowActionField] = rawValue == null ? "" : String(rawValue);
+        }
+        const hasFields = Object.keys(fields).length > 0;
+        const rowAction = widget.rowAction;
+        const cellTexts = cols.map((c) => {
+          const raw = resolvePath(item, c.path);
+          return padCell(raw == null ? "" : String(raw), c.width, c.align);
+        });
+        ctx.lines.push({
+          text: "|" + cellTexts.join("|") + "|",
+          widgetId: widget.id,
+          selectable: Boolean(rowAction),
+          target: rowAction?.type === "nav.goto" ? rowAction.target : void 0,
+          action: rowAction && rowAction.type !== "nav.goto" ? rowAction : void 0,
+          fields: hasFields ? fields : void 0
+        });
+      });
+      const dataRowsEmitted = visibleRows.length;
+      for (let pad = dataRowsEmitted; pad < maxVisible; pad++) {
+        ctx.lines.push({ text: "", widgetId: widget.id });
+      }
+      if (tableScrollable) {
+        const belowCount = rows.length - tableOffset - visibleRows.length;
+        ctx.lines.push({ text: belowCount > 0 ? `\u2193 ${belowCount} more` : "", widgetId: widget.id });
+      }
+      ctx.lines.push({ text: separator, widgetId: widget.id });
+      if (rows.length > maxVisible) {
+        ctx.listScrollInfo[widget.id] = { totalRows: rows.length, visibleRows: visibleRows.length, offset: tableOffset };
+      }
+      const marginBottom = Math.max(0, Number(widget.marginBottom ?? 1));
+      if (marginBottom) pushSpacerLines(marginBottom);
+      return;
+    }
+    if (widget.kind === "list") {
+      const marginTop = Math.max(0, Number(widget.marginTop ?? 1));
+      if (marginTop) pushSpacerLines(marginTop);
+      const listValue = resolvePath(vars, widget.bind);
+      let rows = Array.isArray(listValue) ? listValue : [];
+      if (widget.whereEqualsPath) {
+        rows = rows.filter((item) => {
+          const raw = resolvePath(item, widget.whereEqualsPath || "");
+          return raw === widget.whereEquals;
+        });
+      }
+      const sortByPath = String(widget.sortByPath || "").trim();
+      if (sortByPath) {
+        const direction = String(widget.sortDirection || "asc").trim().toLowerCase() === "desc" ? -1 : 1;
+        rows = [...rows].sort((left, right) => {
+          const leftValue = resolvePath(left, sortByPath);
+          const rightValue = resolvePath(right, sortByPath);
+          const primary = compareSortValues(leftValue, rightValue) * direction;
+          if (primary !== 0) return primary;
+          return compareSortValues(resolvePath(left, "id"), resolvePath(right, "id"));
+        });
+      }
+      if (!rows.length) {
+        ctx.lines.push({
+          text: widget.emptyText || "(no rows)",
+          widgetId: widget.id
+        });
+        const marginBottom2 = Math.max(0, Number(widget.marginBottom ?? 1));
+        if (marginBottom2) pushSpacerLines(marginBottom2);
+        return;
+      }
+      const listMaxVisible = Math.max(1, Number(widget.height) || 10);
+      const listScrollable = rows.length > listMaxVisible;
+      const listOffset = Math.max(0, Math.min(options.listScrollOffsets?.[widget.id] ?? 0, rows.length - listMaxVisible));
+      const listVisibleRows = rows.slice(listOffset, listOffset + listMaxVisible);
+      if (listScrollable) {
+        ctx.lines.push({ text: listOffset > 0 ? `\u2191 ${listOffset} more` : "", widgetId: widget.id });
+      }
+      listVisibleRows.forEach((item, sliceIndex) => {
+        const index = listOffset + sliceIndex;
+        const fields = {};
+        Object.entries(widget.rowActionFields || {}).forEach(([fieldId, valuePath]) => {
+          const raw = resolvePath(item, String(valuePath || "").trim());
+          fields[String(fieldId)] = raw == null ? "" : String(raw);
+        });
+        const rowActionField = String(widget.rowActionField || "").trim();
+        if (rowActionField) {
+          const valuePath = String(widget.rowActionValuePath || "").trim() || "id";
+          const rawValue = resolvePath(item, valuePath);
+          fields[rowActionField] = rawValue == null ? "" : String(rawValue);
+        }
+        const hasFields = Object.keys(fields).length > 0;
+        const rowAction = widget.rowAction;
+        const lineIndex = ctx.lines.length;
+        ctx.lines.push({
+          text: interpolate(widget.rowTemplate, {
+            ...vars,
+            item,
+            index: index + 1
+          }),
+          widgetId: widget.id,
+          selectable: Boolean(rowAction),
+          target: rowAction?.type === "nav.goto" ? rowAction.target : void 0,
+          action: rowAction && rowAction.type !== "nav.goto" ? rowAction : void 0,
+          fields: hasFields ? fields : void 0
+        });
+        if (rowAction) {
+          ctx.actionLines.push({
+            index: lineIndex,
+            selectable: true,
+            target: rowAction.type === "nav.goto" ? rowAction.target : void 0,
+            action: rowAction.type !== "nav.goto" ? rowAction : void 0,
+            fields: hasFields ? fields : void 0
+          });
+        }
+      });
+      const listDataRowsEmitted = listVisibleRows.length;
+      for (let pad = listDataRowsEmitted; pad < listMaxVisible; pad++) {
+        ctx.lines.push({ text: "", widgetId: widget.id });
+      }
+      if (listScrollable) {
+        const listBelowCount = rows.length - listOffset - listVisibleRows.length;
+        ctx.lines.push({ text: listBelowCount > 0 ? `\u2193 ${listBelowCount} more` : "", widgetId: widget.id });
+      }
+      if (rows.length > listMaxVisible) {
+        ctx.listScrollInfo[widget.id] = { totalRows: rows.length, visibleRows: listVisibleRows.length, offset: listOffset };
+      }
+      const marginBottom = Math.max(0, Number(widget.marginBottom ?? 1));
+      if (marginBottom) pushSpacerLines(marginBottom);
+    }
+  });
+  return ctx;
+};
+
+// src/ui/useRunnerRenderSource.ts
+var useRunnerRenderSource = (screen, listScrollOffsets) => {
+  const result = useMemo2(() => {
+    if (!screen?.screenSpec || !screen?.state) return { screen, listScrollInfo: void 0 };
+    const ctx = collectScreenSpecContext(screen.screenSpec, {
+      activeScreenId: screen.state.activeScreenId || screen.screen,
+      fields: screen.state.fields || {},
+      fieldErrors: screen.state.fieldErrors || {},
+      data: screen.state.data || {},
+      statusLine: screen.state.statusLine || screen.statusLine
+    }, { hideHotkeys: false, listScrollOffsets });
+    const lines = ctx.lines.map((line) => line.text);
+    const lineWidgetIds = ctx.lines.map((line) => line.widgetId);
+    const fieldLineIndexById = /* @__PURE__ */ new Map();
+    ctx.lines.forEach((line, idx) => {
+      if (line.fieldId && !fieldLineIndexById.has(line.fieldId)) {
+        fieldLineIndexById.set(line.fieldId, idx);
+      }
+    });
+    const actionLines = [];
+    ctx.lines.forEach((line, idx) => {
+      if (!(line.target || line.aidAlias || line.action)) return;
+      actionLines.push({
+        index: idx,
+        selectable: line.selectable,
+        target: line.target,
+        aidAlias: line.aidAlias,
+        action: line.action,
+        fields: line.fields
+      });
+    });
+    const inputFields = ctx.inputFields.map((field) => ({
+      ...field,
+      lineIndex: fieldLineIndexById.get(field.id)
+    }));
+    const firstMatch = ctx.firstInput ? inputFields.find((f) => f.id === ctx.firstInput?.id) : void 0;
+    const inputField = ctx.firstInput ? {
+      id: ctx.firstInput.id,
+      value: screen.state.fields?.[ctx.firstInput.id] || "",
+      maxLength: ctx.firstInput.maxLength,
+      label: firstMatch?.label,
+      lineIndex: fieldLineIndexById.get(ctx.firstInput.id),
+      rows: firstMatch?.rows,
+      action: firstMatch?.action
+    } : void 0;
+    return {
+      screen: {
+        ...screen,
+        lines,
+        actionLines,
+        inputFields,
+        inputField,
+        shortcuts: ctx.shortcuts,
+        statusLine: screen.state.statusLine || screen.statusLine
+      },
+      listScrollInfo: ctx.listScrollInfo,
+      lineWidgetIds
+    };
+  }, [screen, listScrollOffsets]);
+  return result;
+};
+
+// src/ui/runner.tsx
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var Runner = ({
+  projectId,
+  versionId,
+  terminalUrl,
+  idToken,
+  firebaseProjectId,
+  appCheckToken,
+  onBackToApps,
+  onExit
+}) => {
+  const { screen: rawScreen, error, connecting, sessionId, sendMessage } = useRunnerSession({
+    projectId,
+    versionId,
+    terminalUrl,
+    idToken
+  });
+  const [listScrollOffsets, setListScrollOffsets] = useState3({});
+  const { screen, listScrollInfo, lineWidgetIds } = useRunnerRenderSource(rawScreen, listScrollOffsets);
+  const [inputMode, setInputMode] = useState3(false);
+  const [activeInputIndex, setActiveInputIndex] = useState3(0);
+  const [fieldValues, setFieldValues] = useState3({});
+  const [aiMode, setAiMode] = useState3(false);
+  const [aiMessages, setAiMessages] = useState3([]);
+  const [aiInput, setAiInput] = useState3("");
+  const [aiLoading, setAiLoading] = useState3(false);
+  const aiRequestRef = useRef2(0);
+  const [aiConversationId, setAiConversationId] = useState3(null);
+  const aiMessageSeqRef = useRef2(0);
+  const [aiHistoryLoading, setAiHistoryLoading] = useState3(false);
+  useEffect2(() => {
+    let cancelled = false;
+    const vid = versionId || "published";
+    setAiHistoryLoading(true);
+    loadLatestConversation({ firebaseProjectId, idToken, appCheckToken, projectId, versionId: vid }).then((result) => {
+      if (cancelled) return;
+      if (result) {
+        setAiConversationId(result.conversationId);
+        setAiMessages(result.messages);
+        aiMessageSeqRef.current = result.messageCount;
+      }
+    }).catch(() => {
+    }).finally(() => {
+      if (!cancelled) setAiHistoryLoading(false);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [firebaseProjectId, idToken, appCheckToken, projectId, versionId]);
+  const sendAiMessage = async (text) => {
+    if (!text.trim() || aiLoading) return;
+    const userMsg = { role: "user", text: text.trim() };
+    const updatedMessages = [...aiMessages, userMsg];
+    setAiMessages(updatedMessages);
+    setAiInput("");
+    setAiLoading(true);
+    const requestId = ++aiRequestRef.current;
+    const vid = versionId || "published";
+    const persistOpts = { firebaseProjectId, idToken, appCheckToken, projectId, versionId: vid };
+    try {
+      let convoId = aiConversationId;
+      if (!convoId) {
+        convoId = await createConversation(persistOpts);
+        setAiConversationId(convoId);
+      }
+      const userSeq = ++aiMessageSeqRef.current;
+      appendMessage({ ...persistOpts, conversationId: convoId, role: "user", text: text.trim(), seq: userSeq }).catch(() => {
+      });
+      const response = await callUnifiedChat({
+        firebaseProjectId,
+        idToken,
+        appCheckToken,
+        payload: {
+          projectId,
+          versionId: vid,
+          message: text.trim(),
+          screenId: rawScreen?.screen,
+          conversation: updatedMessages
+        }
+      });
+      if (requestId !== aiRequestRef.current) return;
+      const newMessages = [];
+      if (response.operations?.length) {
+        for (const op of response.operations) {
+          const isError = op.result && typeof op.result === "object" && "error" in op.result;
+          const summary = isError ? `${op.tool}: error - ${op.result.error}` : `${op.tool}: OK`;
+          const toolMsg = { role: "tool", text: summary, toolName: op.tool };
+          newMessages.push(toolMsg);
+          const toolSeq = ++aiMessageSeqRef.current;
+          appendMessage({ ...persistOpts, conversationId: convoId, role: "tool", text: summary, toolName: op.tool, seq: toolSeq }).catch(() => {
+          });
+        }
+      }
+      const assistantMsg = { role: "assistant", text: response.text };
+      newMessages.push(assistantMsg);
+      const assistantSeq = ++aiMessageSeqRef.current;
+      appendMessage({ ...persistOpts, conversationId: convoId, role: "assistant", text: response.text, seq: assistantSeq }).catch(() => {
+      });
+      setAiMessages((prev) => [...prev, ...newMessages]);
+    } catch (err) {
+      if (requestId !== aiRequestRef.current) return;
+      const errMsg = err instanceof Error ? err.message : String(err);
+      setAiMessages((prev) => [...prev, { role: "assistant", text: `Error: ${errMsg}` }]);
+    } finally {
+      if (requestId === aiRequestRef.current) setAiLoading(false);
+    }
+  };
+  const inputFields = useMemo3(() => {
+    if (!screen) return [];
+    if (screen.inputFields && screen.inputFields.length > 0) return screen.inputFields;
+    if (screen.inputField) return [screen.inputField];
+    return [];
+  }, [screen]);
+  const selectableLines = useMemo3(() => {
+    return (screen?.actionLines || []).filter((line) => line.selectable && (line.target || line.aidAlias || line.action)).sort((a, b) => a.index - b.index);
+  }, [screen?.actionLines]);
+  const shortcutByKey = useMemo3(() => {
+    const map = /* @__PURE__ */ new Map();
+    for (const s of screen?.shortcuts || []) {
+      const k = String(s.key || "").trim().toLowerCase();
+      if (k) map.set(k, s);
+    }
+    return map;
+  }, [screen?.shortcuts]);
+  const [selectedLineIndex, setSelectedLineIndex] = useState3(0);
+  useEffect2(() => {
+    setSelectedLineIndex(0);
+    setListScrollOffsets({});
+  }, [screen?.sessionId]);
+  useEffect2(() => {
+    if (selectableLines.length > 0) {
+      setSelectedLineIndex((prev) => Math.min(prev, selectableLines.length - 1));
+    }
+  }, [selectableLines.length]);
+  useEffect2(() => {
+    if (!inputFields.length) {
+      setInputMode(false);
+      setActiveInputIndex(0);
+      return;
+    }
+    setActiveInputIndex((prev) => Math.min(prev, inputFields.length - 1));
+  }, [inputFields.length]);
+  useEffect2(() => {
+    if (!inputFields.length) return;
+    setFieldValues((prev) => {
+      const next = { ...prev };
+      for (const field of inputFields) {
+        const isNonEditable = (field.maxLength ?? 0) === 0;
+        if (isNonEditable || next[field.id] === void 0) {
+          next[field.id] = String(field.value || "");
+        }
+      }
+      return next;
+    });
+  }, [inputFields]);
+  const collectFields = (extra) => {
+    return { ...fieldValues, ...extra };
+  };
+  const applySelectedLine = (line) => {
+    const fields = collectFields(line.fields);
+    if (line.target) {
+      sendMessage({ type: "nav", target: line.target, fields });
+      return;
+    }
+    if (line.aidAlias) {
+      sendMessage({ type: "aid", key: line.aidAlias, fields });
+      return;
+    }
+    if (line.action) {
+      sendMessage({ type: "action", action: line.action, fields });
+    }
+  };
+  const executeShortcut = (shortcut) => {
+    const fields = collectFields(shortcut.fields);
+    if (shortcut.target) {
+      sendMessage({ type: "nav", target: shortcut.target, fields });
+      return;
+    }
+    if (shortcut.action) {
+      sendMessage({ type: "action", action: shortcut.action, fields });
+      return;
+    }
+    if (shortcut.aidAlias) {
+      sendMessage({ type: "aid", key: shortcut.aidAlias, fields });
+    }
+  };
+  const toggleActiveCheckbox = () => {
+    const activeField2 = inputFields[activeInputIndex];
+    if (!activeField2) return;
+    const toggleAction = activeField2.action ?? { type: "data.toggleFlag", path: activeField2.id };
+    sendMessage({ type: "action", action: toggleAction, fields: collectFields() });
+  };
+  const activeField = inputFields[activeInputIndex] ?? null;
+  const isEditable = activeField != null && (activeField.maxLength ?? 0) > 0;
+  const isMultiLine = isEditable && (activeField.rows ?? 1) > 1;
+  useInput2((input, key) => {
+    if (key.ctrl && input === "c") {
+      onExit();
+      return;
+    }
+    if (!screen) return;
+    if (aiMode) {
+      if (key.escape) {
+        setAiMode(false);
+        return;
+      }
+      if (key.backspace || key.delete) {
+        setAiInput((prev) => prev.slice(0, -1));
+        return;
+      }
+      if (key.return && !aiLoading) {
+        void sendAiMessage(aiInput);
+        return;
+      }
+      if (input && !key.ctrl && !key.meta) {
+        setAiInput((prev) => prev + input);
+      }
+      return;
+    }
+    if (inputMode) {
+      if (!activeField) return;
+      if (key.escape) {
+        sendMessage({ type: "aid", key: "B", fields: fieldValues });
+        setInputMode(false);
+        return;
+      }
+      if (!isEditable) {
+        if (key.tab || input === "	" || key.downArrow || key.rightArrow) {
+          setActiveInputIndex((prev) => (prev + 1) % inputFields.length);
+          return;
+        }
+        if (key.upArrow || key.leftArrow) {
+          setActiveInputIndex(
+            (prev) => inputFields.length ? (prev - 1 + inputFields.length) % inputFields.length : 0
+          );
+          return;
+        }
+        if (key.return || input === " ") {
+          toggleActiveCheckbox();
+          return;
+        }
+        if (input) {
+          const shortcut = shortcutByKey.get(input.toLowerCase());
+          if (shortcut) {
+            executeShortcut(shortcut);
+            return;
+          }
+        }
+        return;
+      }
+      if (key.tab || input === "	") {
+        sendMessage({ type: "aid", key: "ENTER", fields: fieldValues });
+        setInputMode(false);
+        return;
+      }
+      if (key.backspace || key.delete) {
+        setFieldValues((prev) => ({
+          ...prev,
+          [activeField.id]: (prev[activeField.id] || "").slice(0, -1)
+        }));
+        return;
+      }
+      if (key.return) {
+        if (isMultiLine) {
+          setFieldValues((prev) => {
+            const current = prev[activeField.id] || "";
+            if (current.length >= activeField.maxLength) return prev;
+            return { ...prev, [activeField.id]: current + "\n" };
+          });
+          return;
+        }
+        sendMessage({ type: "aid", key: "ENTER", fields: fieldValues });
+        setInputMode(false);
+        return;
+      }
+      if (input) {
+        setFieldValues((prev) => {
+          const current = prev[activeField.id] || "";
+          if (current.length >= activeField.maxLength) return prev;
+          return { ...prev, [activeField.id]: current + input };
+        });
+      }
+      return;
+    }
+    if (input === "x" || input === "q") {
+      onBackToApps();
+      return;
+    }
+    if (key.escape) {
+      sendMessage({ type: "aid", key: "B", fields: fieldValues });
+      return;
+    }
+    if (key.return && (key.ctrl || key.meta)) {
+      sendMessage({ type: "aid", key: "ENTER_BACK", fields: fieldValues });
+      return;
+    }
+    if (input === " " && activeField && !isEditable) {
+      toggleActiveCheckbox();
+      return;
+    }
+    if (key.return) {
+      if (activeField && !isEditable) {
+        toggleActiveCheckbox();
+        return;
+      }
+      if (inputFields.length > 0 && isEditable) {
+        setInputMode(true);
+        return;
+      }
+      const line = selectableLines[selectedLineIndex];
+      if (line) {
+        applySelectedLine(line);
+        return;
+      }
+      sendMessage({ type: "aid", key: "ENTER", fields: fieldValues });
+      return;
+    }
+    if (key.pageUp || key.pageDown) {
+      const delta = key.pageDown ? 1 : -1;
+      const currentLine = selectableLines[selectedLineIndex];
+      const wId = currentLine ? lineWidgetIds?.[currentLine.index] : void 0;
+      if (wId && listScrollInfo?.[wId]) {
+        const info = listScrollInfo[wId];
+        const scrollAmount = delta * info.visibleRows;
+        const newOffset = Math.max(0, Math.min(info.offset + scrollAmount, info.totalRows - info.visibleRows));
+        if (newOffset !== info.offset) {
+          setListScrollOffsets((prev) => ({ ...prev, [wId]: newOffset }));
+        }
+      }
+      return;
+    }
+    if (key.upArrow || key.downArrow || key.leftArrow || key.rightArrow) {
+      const arrowMap = {
+        // ink key names aren't available as event.key, so we check the boolean flags
+      };
+      let mapped;
+      if (key.leftArrow) mapped = "h";
+      else if (key.rightArrow) mapped = "l";
+      else if (key.upArrow) mapped = "k";
+      else if (key.downArrow) mapped = "j";
+      if (mapped) {
+        const shortcut = shortcutByKey.get(mapped);
+        if (shortcut) {
+          executeShortcut(shortcut);
+          return;
+        }
+      }
+      if (key.upArrow || key.downArrow) {
+        const delta = key.downArrow ? 1 : -1;
+        if (inputFields.length > 0) {
+          setActiveInputIndex(
+            (prev) => (prev + delta + inputFields.length) % inputFields.length
+          );
+        } else if (selectableLines.length > 0) {
+          const nextIdx = selectedLineIndex + delta;
+          if (nextIdx < 0 || nextIdx >= selectableLines.length) {
+            const currentLine = selectableLines[selectedLineIndex];
+            const wId = currentLine ? lineWidgetIds?.[currentLine.index] : void 0;
+            if (wId && listScrollInfo?.[wId]) {
+              const info = listScrollInfo[wId];
+              if (delta > 0 && info.offset + info.visibleRows < info.totalRows) {
+                setListScrollOffsets((prev) => ({ ...prev, [wId]: info.offset + 1 }));
+                return;
+              }
+              if (delta < 0 && info.offset > 0) {
+                setListScrollOffsets((prev) => ({ ...prev, [wId]: info.offset - 1 }));
+                return;
+              }
+            }
+          }
+          setSelectedLineIndex(
+            (prev) => (prev + delta + selectableLines.length) % selectableLines.length
+          );
+        }
+      }
+      return;
+    }
+    if ((key.tab || input === "	" || input === "i") && inputFields.length > 0) {
+      setInputMode(true);
+      return;
+    }
+    if (input) {
+      const shortcut = shortcutByKey.get(input.toLowerCase());
+      if (shortcut) {
+        executeShortcut(shortcut);
+        return;
+      }
+    }
+    if (input === "/" && !shortcutByKey.has("/")) {
+      setAiMode(true);
+      return;
+    }
+    if (input === "b") {
+      sendMessage({ type: "aid", key: "B", fields: fieldValues });
+      return;
+    }
+    if (input === "c") {
+      sendMessage({ type: "aid", key: "C", fields: fieldValues });
+      return;
+    }
+  });
+  const fieldLineMap = useMemo3(() => {
+    const map = /* @__PURE__ */ new Map();
+    for (const field of inputFields) {
+      if (typeof field.lineIndex !== "number") continue;
+      const rows = Math.max(1, Number(field.rows ?? 1));
+      const lineStep = Math.max(1, Number(field.lineStep ?? 1));
+      for (let r = 0; r < rows; r++) {
+        map.set(field.lineIndex + r * lineStep, {
+          fieldId: field.id,
+          rowOffset: r,
+          label: field.label || field.id,
+          rows
+        });
+      }
+    }
+    return map;
+  }, [inputFields]);
+  const displayLines = useMemo3(() => {
+    if (!screen) return [];
+    const lines = [...screen.lines || []];
+    if (!inputMode || !activeField || !isEditable) return lines;
+    const fieldId = activeField.id;
+    const editValue = fieldValues[fieldId] || "";
+    const label = activeField.label || activeField.id;
+    const labelPrefix = label ? `${label}: ` : "";
+    const indent = " ".repeat(labelPrefix.length);
+    const rows = Math.max(1, Number(activeField.rows ?? 1));
+    const lineStep = Math.max(1, Number(activeField.lineStep ?? 1));
+    if (typeof activeField.lineIndex !== "number") return lines;
+    const editLines = editValue.split(/\r?\n/);
+    const paddedEditLines = editLines.slice(0, rows);
+    while (paddedEditLines.length < rows) paddedEditLines.push("");
+    for (let r = 0; r < rows; r++) {
+      const lineIdx = activeField.lineIndex + r * lineStep;
+      if (lineIdx >= 0 && lineIdx < lines.length) {
+        const prefix = r === 0 ? labelPrefix : indent;
+        const text = paddedEditLines[r] || "";
+        const cursor = r === editLines.length - 1 || r === rows - 1 && editLines.length >= rows ? "\u2588" : "";
+        lines[lineIdx] = `${prefix}${text}${cursor}`;
+      }
+    }
+    return lines;
+  }, [screen, inputMode, activeField, isEditable, fieldValues, inputFields]);
+  const hintText = useMemo3(() => {
+    if (aiMode) return "Type message, Enter=send, Esc=back to app";
+    if (!activeField) return "Enter=select, /=AI, b=back, Tab/i=edit, arrows=nav, x=apps";
+    if (inputMode && isEditable) {
+      return isMultiLine ? "Type to edit, Enter=newline, Tab=submit, Esc=cancel" : "Type to edit, Enter=submit, Tab=submit, Esc=cancel";
+    }
+    if (isEditable) return "Enter=edit, Tab=next field, arrows=nav, b=back, x=apps";
+    return "Enter/Space=toggle, arrows=nav, b=back, x=apps";
+  }, [activeField, aiMode, inputMode, isEditable, isMultiLine]);
+  if (error) {
+    return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs2(Text2, { color: "red", children: [
+        "Runner error: ",
+        error
+      ] }),
+      /* @__PURE__ */ jsx2(Text2, { children: "Press x to return to apps, or Ctrl+C to exit." })
+    ] });
+  }
+  if (connecting || !screen) {
+    return /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", children: /* @__PURE__ */ jsx2(Text2, { color: "green", children: "Starting runner..." }) });
+  }
+  const selectedLine = selectableLines[selectedLineIndex];
+  if (aiMode) {
+    return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs2(Text2, { color: "green", children: [
+        "AI CHAT | project=",
+        projectId,
+        " | screen=",
+        rawScreen?.screen || "-"
+      ] }),
+      /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", marginTop: 1, children: [
+        aiHistoryLoading && /* @__PURE__ */ jsx2(Text2, { color: "gray", children: "Loading conversation..." }),
+        aiMessages.length === 0 && !aiLoading && !aiHistoryLoading && /* @__PURE__ */ jsx2(Text2, { color: "gray", children: "Ask anything about this app or screen." }),
+        aiMessages.map((msg, idx) => {
+          const prefix = msg.role === "user" ? "You: " : msg.role === "tool" ? `TOOL(${msg.toolName || "?"}): ` : "AI: ";
+          const color = msg.role === "user" ? "cyan" : msg.role === "tool" ? "yellow" : "white";
+          return /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", children: /* @__PURE__ */ jsxs2(Text2, { color, wrap: "wrap", children: [
+            prefix,
+            msg.text
+          ] }) }, idx);
+        }),
+        aiLoading && /* @__PURE__ */ jsx2(Text2, { color: "yellow", children: "Thinking..." })
+      ] }),
+      /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", marginTop: 1, children: [
+        /* @__PURE__ */ jsxs2(Text2, { color: "green", children: [
+          "> ",
+          aiInput,
+          /* @__PURE__ */ jsx2(Text2, { color: "green", children: "\u2588" })
+        ] }),
+        /* @__PURE__ */ jsx2(Text2, { color: "gray", children: hintText })
+      ] })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs2(Text2, { color: "green", children: [
+      "RUNNER | project=",
+      projectId,
+      " | version=",
+      versionId || "published",
+      " | session=",
+      sessionId || "-"
+    ] }),
+    /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", marginTop: 1, children: displayLines.map((line, idx) => {
+      const match = selectableLines.findIndex((entry) => entry.index === idx);
+      const isSelectedActionLine = match >= 0 && selectableLines[match] === selectedLine;
+      const fieldInfo = fieldLineMap.get(idx);
+      const isActiveInputLine = fieldInfo != null && fieldInfo.fieldId === activeField?.id;
+      const isAnyInputLine = fieldInfo != null;
+      const lineColor = isSelectedActionLine ? "green" : isActiveInputLine ? inputMode ? "yellow" : "cyan" : isAnyInputLine ? "cyan" : void 0;
+      const lineBackground = isActiveInputLine && inputMode ? "blackBright" : void 0;
+      const actionLine = match >= 0 ? selectableLines[match] : void 0;
+      const isButton = actionLine && !actionLine.fields;
+      const prevWidgetId = idx > 0 ? lineWidgetIds?.[idx - 1] : void 0;
+      const curWidgetId = lineWidgetIds?.[idx];
+      const needsTopSpace = isButton && prevWidgetId && prevWidgetId !== curWidgetId;
+      return /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", marginTop: needsTopSpace ? 1 : 0, children: /* @__PURE__ */ jsx2(
+        Text2,
+        {
+          color: lineColor,
+          backgroundColor: lineBackground,
+          bold: isActiveInputLine,
+          children: line
+        }
+      ) }, `${idx}-${line}`);
+    }) }),
+    /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", marginTop: 1, children: [
+      /* @__PURE__ */ jsx2(Text2, { color: "gray", children: screen.statusLine }),
+      /* @__PURE__ */ jsx2(Text2, { color: "gray", children: hintText })
+    ] })
+  ] });
+};
+
+// src/app.tsx
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+var App = ({ config, idToken, initialQuery, onExit }) => {
+  const [apps, setApps] = useState4([]);
+  const [loading, setLoading] = useState4(true);
+  const [error, setError] = useState4(null);
+  const [selectedApp, setSelectedApp] = useState4(null);
+  useEffect3(() => {
+    let mounted = true;
+    const load = async () => {
+      try {
+        setLoading(true);
+        log(`Loading apps from ${config.terminalUrl}`);
+        const results = await fetchRunnableAppsViaServer({
+          terminalUrl: config.terminalUrl,
+          idToken,
+          query: initialQuery
+        });
+        if (!mounted) return;
+        log(`Loaded ${results.length} apps`);
+        setApps(results);
+        setError(null);
+      } catch (err) {
+        if (!mounted) return;
+        setError(err instanceof Error ? err.message : String(err));
+      } finally {
+        if (mounted) setLoading(false);
+      }
+    };
+    void load();
+    return () => {
+      mounted = false;
+    };
+  }, [config.firebaseProjectId, config.terminalUrl, idToken, initialQuery]);
+  if (error) {
+    return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx3(Text3, { color: "red", children: error }),
+      /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "Tip: Set BLO_DEBUG=1 for detailed logs." }),
+      /* @__PURE__ */ jsx3(Text3, { children: "Press Ctrl+C to exit." })
+    ] });
+  }
+  if (loading) {
+    return /* @__PURE__ */ jsx3(Box3, { flexDirection: "column", children: /* @__PURE__ */ jsxs3(Text3, { color: "green", children: [
+      "Loading apps from ",
+      config.terminalUrl,
+      "..."
+    ] }) });
+  }
+  if (apps.length === 0) {
+    return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx3(Text3, { color: "yellow", children: "No apps found." }),
+      /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: initialQuery ? `No apps matched "${initialQuery}". Try without a query filter.` : "Your account has no projects and no published apps are available." }),
+      /* @__PURE__ */ jsx3(Text3, { children: "Press Ctrl+C to exit." })
+    ] });
+  }
+  if (!selectedApp) {
+    return /* @__PURE__ */ jsx3(
+      AppSearch,
+      {
+        apps,
+        initialQuery,
+        onSelect: (app) => {
+          log(`Selected app: ${app.projectId} (version=${app.versionId}, source=${app.versionSource})`);
+          setSelectedApp(app);
+        },
+        onExit
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx3(
+    Runner,
+    {
+      projectId: selectedApp.projectId,
+      versionId: selectedApp.versionId,
+      terminalUrl: config.terminalUrl,
+      idToken,
+      firebaseProjectId: config.firebaseProjectId,
+      appCheckToken: config.appCheckToken,
+      onBackToApps: () => {
+        log("Returning to app list");
+        setSelectedApp(null);
+      },
+      onExit
+    }
+  );
+};
+
+// src/config.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+var defaultWebOrigin = process.env.BLO_WEB_ORIGIN || "https://buildless.online";
+var defaultTerminalUrl = process.env.BLO_TERMINAL_URL || "https://buildless.online";
+var defaultProjectId = process.env.BLO_FIREBASE_PROJECT_ID || "buildless-online";
+var resolveConfigPath = () => {
+  if (process.env.BLO_CONFIG_PATH) return process.env.BLO_CONFIG_PATH;
+  const home = os.homedir();
+  const configDir = process.env.XDG_CONFIG_HOME || path.join(home, ".config");
+  return path.join(configDir, "blo", "cli.json");
+};
+var loadConfig = () => {
+  const configPath = resolveConfigPath();
+  const defaults = {
+    webOrigin: defaultWebOrigin,
+    terminalUrl: defaultTerminalUrl,
+    firebaseProjectId: defaultProjectId
+  };
+  if (!fs.existsSync(configPath)) {
+    return { path: configPath, config: defaults };
+  }
+  try {
+    const raw = fs.readFileSync(configPath, "utf8");
+    const parsed = JSON.parse(raw);
+    return {
+      path: configPath,
+      config: {
+        // Merge persisted values (tokens) with authoritative defaults.
+        // Service URLs and project ID always come from defaults (env or
+        // hardcoded prod) so a stale config file can't point the
+        // published CLI at the wrong Firebase project.
+        ...defaults,
+        idToken: parsed.idToken,
+        tokenExp: parsed.tokenExp,
+        appCheckToken: parsed.appCheckToken
+      }
+    };
+  } catch (err) {
+    process.stderr.write(`Warning: failed to parse ${configPath}, using defaults: ${err instanceof Error ? err.message : String(err)}
+`);
+    return { path: configPath, config: defaults };
+  }
+};
+var saveConfig = (configPath, config) => {
+  const dir = path.dirname(configPath);
+  fs.mkdirSync(dir, { recursive: true, mode: 448 });
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2), { mode: 384 });
+};
+
+// src/index.tsx
+import { jsx as jsx4 } from "react/jsx-runtime";
+var ensureProjectId = (config) => {
+  if (!config.firebaseProjectId) {
+    throw new Error(
+      "Could not determine project. Please reinstall: npm install -g buildless-cli"
+    );
+  }
+};
+var runLogin = async (config, configPath) => {
+  log(`Starting login flow via ${config.webOrigin}/cli-auth`);
+  const result = await startExternalLogin({ webOrigin: config.webOrigin });
+  const payload = decodeJwtPayload(result.token);
+  const uid = payload?.user_id ?? payload?.sub ?? "unknown";
+  log(`Login successful: uid=${uid}, exp=${result.exp}, appCheck=${result.appCheckToken ? "yes" : "no"}`);
+  const next = {
+    ...config,
+    idToken: result.token,
+    tokenExp: result.exp ?? void 0,
+    appCheckToken: result.appCheckToken
+  };
+  saveConfig(configPath, next);
+  log(`Config saved to ${configPath}`);
+  return next;
+};
+var program = new Command();
+program.name("blo").description("BLO terminal client").version("0.1.0").option("-v, --verbose", "Enable verbose debug output").hook("preAction", () => {
+  if (program.opts().verbose) {
+    setVerbose(true);
+  }
+});
+program.command("login").description("Authenticate via external browser").action(async () => {
+  const { config, path: path2 } = loadConfig();
+  log(`Config loaded from ${path2}`);
+  ensureProjectId(config);
+  const next = await runLogin(config, path2);
+  process.stdout.write(`Logged in for project ${next.firebaseProjectId}.
+`);
 });
-const runAction = async (options) => {
-    process.stdout.write("\x1b[2J\x1b[H");
-    const { config, path } = loadConfig();
-    log(`Config loaded from ${path}`);
-    log(`Project: ${config.firebaseProjectId}`);
-    log(`Terminal URL: ${config.terminalUrl}`);
-    log(`Web origin: ${config.webOrigin}`);
-    ensureProjectId(config);
-    let effective = config;
-    if (!isTokenValid(config.idToken, config.tokenExp ?? null)) {
-        log("Token expired or missing, starting login");
-        effective = await runLogin(config, path);
-    }
-    else {
-        const payload = decodeJwtPayload(config.idToken || "");
-        const uid = payload?.user_id ?? payload?.sub ?? "unknown";
-        log(`Token valid: uid=${uid}, expires=${config.tokenExp ? new Date(config.tokenExp * 1000).toISOString() : "unknown"}`);
-    }
-    log(`Rendering app with query=${options.query || "(none)"}`);
-    const { waitUntilExit } = render(_jsx(App, { config: effective, idToken: effective.idToken || "", initialQuery: options.query, onExit: () => process.exit(0) }));
-    await waitUntilExit();
-};
-program
-    .command("run")
-    .description("Search and run a published app")
-    .option("-q, --query <query>", "Initial search query")
-    .action(runAction);
-program
-    .command("list")
-    .description("List published apps (interactive)")
-    .option("-q, --query <query>", "Initial search query")
-    .action(runAction);
-const main = async () => {
-    if (process.argv.length <= 2) {
-        await program.parseAsync([process.argv[0], process.argv[1], "run"]);
-        return;
-    }
-    await program.parseAsync(process.argv);
+var runAction = async (options) => {
+  process.stdout.write("\x1B[2J\x1B[H");
+  const { config, path: path2 } = loadConfig();
+  log(`Config loaded from ${path2}`);
+  log(`Project: ${config.firebaseProjectId}`);
+  log(`Terminal URL: ${config.terminalUrl}`);
+  log(`Web origin: ${config.webOrigin}`);
+  ensureProjectId(config);
+  let effective = config;
+  if (!isTokenValid(config.idToken, config.tokenExp ?? null)) {
+    log("Token expired or missing, starting login");
+    effective = await runLogin(config, path2);
+  } else {
+    const payload = decodeJwtPayload(config.idToken || "");
+    const uid = payload?.user_id ?? payload?.sub ?? "unknown";
+    log(`Token valid: uid=${uid}, expires=${config.tokenExp ? new Date(config.tokenExp * 1e3).toISOString() : "unknown"}`);
+  }
+  log(`Rendering app with query=${options.query || "(none)"}`);
+  const { waitUntilExit } = render(
+    /* @__PURE__ */ jsx4(
+      App,
+      {
+        config: effective,
+        idToken: effective.idToken || "",
+        initialQuery: options.query,
+        onExit: () => process.exit(0)
+      }
+    )
+  );
+  await waitUntilExit();
+};
+program.command("run").description("Search and run a published app").option("-q, --query <query>", "Initial search query").action(runAction);
+program.command("list").description("List published apps (interactive)").option("-q, --query <query>", "Initial search query").action(runAction);
+var main = async () => {
+  if (process.argv.length <= 2) {
+    await program.parseAsync([process.argv[0], process.argv[1], "run"]);
+    return;
+  }
+  await program.parseAsync(process.argv);
 };
 main().catch((err) => {
-    process.stderr.write(`${err instanceof Error ? err.message : String(err)}\n`);
-    process.exit(1);
+  process.stderr.write(`${err instanceof Error ? err.message : String(err)}
+`);
+  process.exit(1);
 });
 //# sourceMappingURL=index.js.map