@rehpic/vcli 0.1.0-beta.61.1 → 0.1.0-beta.69.1

package/dist/index.js

@@ -285,7 +285,7 @@ var init_default_browser_id = __esm({
 // ../../node_modules/.pnpm/run-applescript@7.1.0/node_modules/run-applescript/index.js
 import process5 from "process";
 import { promisify as promisify4 } from "util";
-import { execFile as execFile4, execFileSync as execFileSync2 } from "child_process";
+import { execFile as execFile4, execFileSync as execFileSync3 } from "child_process";
 async function runAppleScript(script, { humanReadableOutput = true, signal } = {}) {
   if (process5.platform !== "darwin") {
     throw new Error("macOS only");
@@ -1056,15 +1056,68 @@ function printOutput(data, json = false) {
 }
 
 // src/session.ts
-import { mkdir, readFile, rm, writeFile } from "fs/promises";
+import { mkdir, readFile, readdir, rm, writeFile } from "fs/promises";
 import { homedir } from "os";
 import path from "path";
 function getSessionRoot() {
   return process.env.VECTOR_HOME?.trim() || path.join(homedir(), ".vector");
 }
+function getProfileConfigPath() {
+  return path.join(getSessionRoot(), "cli-config.json");
+}
 function getSessionPath(profile = "default") {
   return path.join(getSessionRoot(), `cli-${profile}.json`);
 }
+async function readDefaultProfile() {
+  try {
+    const raw = await readFile(getProfileConfigPath(), "utf8");
+    const parsed = JSON.parse(raw);
+    const profile = parsed.defaultProfile?.trim();
+    return profile || "default";
+  } catch {
+    return "default";
+  }
+}
+async function writeDefaultProfile(profile) {
+  const normalized = profile.trim() || "default";
+  await mkdir(getSessionRoot(), { recursive: true });
+  const config = {
+    version: 1,
+    defaultProfile: normalized
+  };
+  await writeFile(
+    getProfileConfigPath(),
+    `${JSON.stringify(config, null, 2)}
+`,
+    "utf8"
+  );
+}
+async function listProfiles() {
+  const root = getSessionRoot();
+  const defaultProfile = await readDefaultProfile();
+  try {
+    const entries = await readdir(root, { withFileTypes: true });
+    const names = entries.filter((entry) => entry.isFile()).map((entry) => entry.name).filter((name) => /^cli-.+\.json$/.test(name)).map((name) => name.replace(/^cli-/, "").replace(/\.json$/, ""));
+    const uniqueNames = Array.from(/* @__PURE__ */ new Set([...names, defaultProfile])).sort(
+      (left, right) => left.localeCompare(right)
+    );
+    return Promise.all(
+      uniqueNames.map(async (name) => ({
+        name,
+        isDefault: name === defaultProfile,
+        hasSession: await readSession(name) !== null
+      }))
+    );
+  } catch {
+    return [
+      {
+        name: defaultProfile,
+        isDefault: true,
+        hasSession: await readSession(defaultProfile) !== null
+      }
+    ];
+  }
+}
 async function readSession(profile = "default") {
   try {
     const raw = await readFile(getSessionPath(profile), "utf8");
@@ -1099,9 +1152,285 @@ function createEmptySession() {
 
 // src/bridge-service.ts
 import { ConvexHttpClient as ConvexHttpClient2 } from "convex/browser";
-import { execFileSync, execSync as execSync2 } from "child_process";
+import { execFileSync as execFileSync2, execSync as execSync2 } from "child_process";
+
+// src/terminal-peer.ts
+import { createServer } from "http";
+import { WebSocketServer, WebSocket } from "ws";
+import { ConvexClient } from "convex/browser";
+import * as pty from "node-pty";
+import { existsSync } from "fs";
+import { randomUUID } from "crypto";
+import { execFileSync } from "child_process";
+import localtunnel from "localtunnel";
+function findTmuxPath() {
+  for (const p of [
+    "/opt/homebrew/bin/tmux",
+    "/usr/local/bin/tmux",
+    "/usr/bin/tmux"
+  ]) {
+    if (existsSync(p)) return p;
+  }
+  return "tmux";
+}
+var TMUX = findTmuxPath();
+function ts() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(11, 19);
+}
+function findPort() {
+  return new Promise((resolve, reject) => {
+    const srv = createServer();
+    srv.listen(0, "127.0.0.1", () => {
+      const addr = srv.address();
+      const port = typeof addr === "object" && addr ? addr.port : 9100;
+      srv.close(() => resolve(port));
+    });
+    srv.on("error", reject);
+  });
+}
+function createViewerSession(targetSession, paneId) {
+  const viewerName = `viewer-${randomUUID().slice(0, 8)}`;
+  try {
+    execFileSync(TMUX, [
+      "new-session",
+      "-d",
+      "-s",
+      viewerName,
+      "-t",
+      targetSession
+    ]);
+    execFileSync(TMUX, ["set-option", "-t", viewerName, "status", "off"]);
+    if (paneId) {
+      try {
+        execFileSync(TMUX, ["select-pane", "-t", paneId]);
+      } catch {
+      }
+    }
+    return viewerName;
+  } catch (err) {
+    console.error(`[${ts()}] Failed to create viewer session:`, err);
+    return targetSession;
+  }
+}
+function killViewerSession(sessionName) {
+  try {
+    execFileSync(TMUX, ["kill-session", "-t", sessionName]);
+  } catch {
+  }
+}
+var TerminalPeerManager = class {
+  constructor(config) {
+    this.terminals = /* @__PURE__ */ new Map();
+    this.failedSessions = /* @__PURE__ */ new Set();
+    this.pendingStops = /* @__PURE__ */ new Map();
+    this.unsubscribers = /* @__PURE__ */ new Map();
+    this.config = config;
+    this.client = new ConvexClient(config.convexUrl);
+  }
+  watchSession(workSessionId, tmuxSessionName, tmuxPaneId) {
+    if (this.unsubscribers.has(workSessionId)) return;
+    const unsub = this.client.onUpdate(
+      api.agentBridge.bridgePublic.getWorkSessionTerminalState,
+      {
+        deviceId: this.config.deviceId,
+        deviceSecret: this.config.deviceSecret,
+        workSessionId
+      },
+      (state) => {
+        if (!state) return;
+        const terminal = this.terminals.get(workSessionId);
+        if (state.terminalViewerActive && !terminal && !this.failedSessions.has(workSessionId)) {
+          const pendingStop = this.pendingStops.get(workSessionId);
+          if (pendingStop) {
+            clearTimeout(pendingStop);
+            this.pendingStops.delete(workSessionId);
+          }
+          console.log(`[${ts()}] Viewer active for ${tmuxSessionName}`);
+          void this.startTerminal(
+            workSessionId,
+            tmuxSessionName,
+            tmuxPaneId,
+            state.terminalCols,
+            state.terminalRows
+          );
+        } else if (!state.terminalViewerActive && terminal) {
+          if (!this.pendingStops.has(workSessionId)) {
+            this.pendingStops.set(
+              workSessionId,
+              setTimeout(() => {
+                this.pendingStops.delete(workSessionId);
+                console.log(`[${ts()}] Viewer inactive for ${tmuxSessionName}`);
+                this.stopTerminal(workSessionId);
+                this.failedSessions.delete(workSessionId);
+              }, 2e3)
+            );
+          }
+        }
+      }
+    );
+    this.unsubscribers.set(workSessionId, unsub);
+  }
+  unwatchSession(workSessionId) {
+    const unsub = this.unsubscribers.get(workSessionId);
+    if (unsub) {
+      unsub();
+      this.unsubscribers.delete(workSessionId);
+    }
+    this.stopTerminal(workSessionId);
+  }
+  async startTerminal(workSessionId, tmuxSessionName, tmuxPaneId, cols, rows) {
+    if (this.terminals.has(workSessionId)) return;
+    try {
+      const port = await findPort();
+      const viewerSession = createViewerSession(tmuxSessionName, tmuxPaneId);
+      const isLinked = viewerSession !== tmuxSessionName;
+      console.log(
+        `[${ts()}] Viewer session: ${viewerSession}${isLinked ? " (linked)" : ""}`
+      );
+      console.log(
+        `[${ts()}] Spawning PTY: ${TMUX} attach-session -t ${viewerSession}`
+      );
+      const ptyProcess = pty.spawn(
+        TMUX,
+        ["attach-session", "-t", viewerSession],
+        {
+          name: "xterm-256color",
+          cols: Math.max(cols, 10),
+          rows: Math.max(rows, 4),
+          cwd: process.env.HOME ?? "/",
+          env: { ...process.env, TERM: "xterm-256color" }
+        }
+      );
+      console.log(`[${ts()}] PTY started`);
+      const token = randomUUID();
+      const httpServer = createServer();
+      const wss = new WebSocketServer({ server: httpServer });
+      wss.on("connection", (ws, req) => {
+        const url = new URL(req.url ?? "/", `http://localhost`);
+        const clientToken = url.searchParams.get("token");
+        if (clientToken !== token) {
+          console.log(`[${ts()}] Rejected unauthorized connection`);
+          ws.close(4401, "Unauthorized");
+          return;
+        }
+        console.log(`[${ts()}] Client connected (${tmuxSessionName})`);
+        const dataHandler = ptyProcess.onData((data) => {
+          if (ws.readyState === WebSocket.OPEN) {
+            ws.send(data);
+          }
+        });
+        ws.on("message", (msg) => {
+          const str = msg.toString();
+          if (str.startsWith("\0{")) {
+            try {
+              const parsed = JSON.parse(str.slice(1));
+              if (parsed.type === "resize" && parsed.cols && parsed.rows) {
+                ptyProcess.resize(
+                  Math.max(parsed.cols, 10),
+                  Math.max(parsed.rows, 4)
+                );
+                return;
+              }
+            } catch {
+            }
+          }
+          ptyProcess.write(str);
+        });
+        ws.on("close", () => {
+          console.log(`[${ts()}] Client disconnected (${tmuxSessionName})`);
+          dataHandler.dispose();
+        });
+      });
+      await new Promise((resolve) => {
+        httpServer.listen(port, "0.0.0.0", resolve);
+      });
+      console.log(`[${ts()}] WS server on port ${port}`);
+      const tunnelOpts = { port };
+      if (this.config.tunnelHost) {
+        tunnelOpts.host = this.config.tunnelHost;
+      }
+      console.log(
+        `[${ts()}] Opening tunnel...${this.config.tunnelHost ? ` (host: ${this.config.tunnelHost})` : ""}`
+      );
+      const tunnel = await localtunnel(tunnelOpts);
+      const tunnelUrl = tunnel.url;
+      console.log(`[${ts()}] Tunnel: ${tunnelUrl}`);
+      const wsUrl = tunnelUrl.replace(/^https?:\/\//, "wss://");
+      const terminal = {
+        ptyProcess,
+        httpServer,
+        wss,
+        tunnel,
+        viewerSessionName: isLinked ? viewerSession : null,
+        token,
+        workSessionId,
+        tmuxSessionName,
+        port
+      };
+      this.terminals.set(workSessionId, terminal);
+      await this.client.mutation(
+        api.agentBridge.bridgePublic.updateWorkSessionTerminalUrl,
+        {
+          deviceId: this.config.deviceId,
+          deviceSecret: this.config.deviceSecret,
+          workSessionId,
+          terminalUrl: wsUrl,
+          terminalToken: token,
+          terminalLocalPort: port
+        }
+      );
+      ptyProcess.onExit(() => {
+        console.log(`[${ts()}] PTY exited for ${tmuxSessionName}`);
+        this.stopTerminal(workSessionId);
+      });
+    } catch (err) {
+      console.error(`[${ts()}] Failed to start terminal:`, err);
+      this.failedSessions.add(workSessionId);
+    }
+  }
+  stopTerminal(workSessionId) {
+    const terminal = this.terminals.get(workSessionId);
+    if (!terminal) return;
+    try {
+      terminal.ptyProcess.kill();
+    } catch {
+    }
+    try {
+      terminal.tunnel.close();
+    } catch {
+    }
+    try {
+      terminal.wss.close();
+    } catch {
+    }
+    try {
+      terminal.httpServer.close();
+    } catch {
+    }
+    if (terminal.viewerSessionName) {
+      killViewerSession(terminal.viewerSessionName);
+    }
+    this.terminals.delete(workSessionId);
+    console.log(`[${ts()}] Terminal stopped for ${terminal.tmuxSessionName}`);
+  }
+  stop() {
+    for (const unsub of this.unsubscribers.values()) {
+      try {
+        unsub();
+      } catch {
+      }
+    }
+    this.unsubscribers.clear();
+    for (const id of this.terminals.keys()) {
+      this.stopTerminal(id);
+    }
+    void this.client.close();
+  }
+};
+
+// src/bridge-service.ts
 import {
-  existsSync as existsSync2,
+  existsSync as existsSync3,
   mkdirSync,
   readFileSync as readFileSync2,
   writeFileSync,
@@ -1109,17 +1438,18 @@ import {
 } from "fs";
 import { homedir as homedir3, hostname, platform } from "os";
 import { join as join2 } from "path";
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 
 // src/agent-adapters.ts
-import { execSync, spawn } from "child_process";
-import { existsSync, readFileSync, readdirSync } from "fs";
+import { execSync, spawn as spawn2 } from "child_process";
+import { existsSync as existsSync2, readFileSync, readdirSync } from "fs";
 import { homedir as homedir2, userInfo } from "os";
 import { basename, join } from "path";
 var LSOF_PATHS = ["/usr/sbin/lsof", "/usr/bin/lsof"];
 var VECTOR_BRIDGE_CLIENT_VERSION = "0.1.0";
 function discoverAttachableSessions() {
   return dedupeSessions([
+    ...discoverTmuxSessions(),
     ...discoverCodexSessions(),
     ...discoverClaudeSessions()
   ]);
@@ -1141,7 +1471,7 @@ async function resumeProviderSession(provider, sessionKey, cwd, prompt2) {
   });
 }
 async function runCodexAppServerTurn(args) {
-  const child = spawn("codex", ["app-server"], {
+  const child = spawn2("codex", ["app-server"], {
     cwd: args.cwd,
     env: { ...process.env },
     stdio: ["pipe", "pipe", "pipe"]
@@ -1429,6 +1759,65 @@ function discoverClaudeSessions() {
     return parsed ? [parsed] : [];
   }).sort(compareObservedSessions);
 }
+function discoverTmuxSessions() {
+  try {
+    const output = execSync(
+      "tmux list-panes -a -F '#{pane_id}	#{pane_pid}	#{session_name}	#{window_name}	#{pane_current_path}	#{pane_current_command}	#{pane_title}'",
+      {
+        encoding: "utf-8",
+        timeout: 3e3
+      }
+    );
+    return output.split("\n").map((line) => line.trim()).filter(Boolean).flatMap((line) => {
+      const [
+        paneId,
+        panePid,
+        sessionName,
+        windowName,
+        cwd,
+        currentCommand,
+        paneTitle
+      ] = line.split("	");
+      if (!paneId || !panePid || !sessionName || !windowName || !cwd) {
+        return [];
+      }
+      const normalizedCommand = (currentCommand ?? "").trim().toLowerCase();
+      if (normalizedCommand === "codex" || normalizedCommand === "claude") {
+        return [];
+      }
+      const gitInfo = getGitInfo(cwd);
+      const title = summarizeTitle(
+        buildTmuxPaneTitle({
+          paneTitle,
+          sessionName,
+          windowName,
+          cwd,
+          currentCommand
+        }),
+        cwd
+      );
+      return [
+        {
+          provider: "vector_cli",
+          providerLabel: "Tmux",
+          localProcessId: panePid,
+          sessionKey: `tmux:${paneId}`,
+          cwd,
+          ...gitInfo,
+          title,
+          tmuxSessionName: sessionName,
+          tmuxWindowName: windowName,
+          tmuxPaneId: paneId,
+          mode: "observed",
+          status: "observed",
+          supportsInboundMessages: true
+        }
+      ];
+    }).sort(compareObservedSessions);
+  } catch {
+    return [];
+  }
+}
 function getCodexHistoryFile() {
   return join(getRealHomeDir(), ".codex", "history.jsonl");
 }
@@ -1453,7 +1842,7 @@ function getRealHomeDir() {
 }
 function resolveExecutable(fallbackCommand, absoluteCandidates) {
   for (const candidate of absoluteCandidates) {
-    if (existsSync(candidate)) {
+    if (existsSync2(candidate)) {
       return candidate;
     }
   }
@@ -1512,7 +1901,7 @@ function getCodexTranscriptPath(pid) {
 }
 function readClaudePidSession(pid) {
   const path3 = join(getClaudeSessionStateDir(), `${pid}.json`);
-  if (!existsSync(path3)) {
+  if (!existsSync2(path3)) {
     return null;
   }
   try {
@@ -1534,7 +1923,7 @@ function findClaudeTranscriptPath(sessionId) {
   return findJsonlFileByStem(getClaudeProjectsDir(), sessionId);
 }
 function findJsonlFileByStem(root, stem) {
-  if (!existsSync(root)) {
+  if (!existsSync2(root)) {
     return void 0;
   }
   for (const entry of readdirSync(root, { withFileTypes: true })) {
@@ -1694,6 +2083,17 @@ function summarizeTitle(message, cwd) {
   }
   return "Local session";
 }
+function buildTmuxPaneTitle(args) {
+  const paneTitle = cleanSessionTitleCandidate(args.paneTitle ?? "");
+  if (paneTitle) {
+    return paneTitle;
+  }
+  const command = asString(args.currentCommand);
+  if (command && !["zsh", "bash", "fish", "sh", "nu"].includes(command)) {
+    return `${command} in ${basename(args.cwd)}`;
+  }
+  return `${basename(args.cwd)} (${args.sessionName}:${args.windowName})`;
+}
 function truncate(value, maxLength) {
   return value.length > maxLength ? `${value.slice(0, maxLength - 3).trimEnd()}...` : value;
 }
@@ -1912,7 +2312,7 @@ var COMMAND_POLL_INTERVAL_MS = 5e3;
 var LIVE_ACTIVITY_SYNC_INTERVAL_MS = 5e3;
 var PROCESS_DISCOVERY_INTERVAL_MS = 6e4;
 function loadBridgeConfig() {
-  if (!existsSync2(BRIDGE_CONFIG_FILE)) return null;
+  if (!existsSync3(BRIDGE_CONFIG_FILE)) return null;
   try {
     return JSON.parse(readFileSync2(BRIDGE_CONFIG_FILE, "utf-8"));
   } catch {
@@ -1920,17 +2320,18 @@ function loadBridgeConfig() {
   }
 }
 function saveBridgeConfig(config) {
-  if (!existsSync2(CONFIG_DIR)) mkdirSync(CONFIG_DIR, { recursive: true });
+  if (!existsSync3(CONFIG_DIR)) mkdirSync(CONFIG_DIR, { recursive: true });
   writeFileSync(BRIDGE_CONFIG_FILE, JSON.stringify(config, null, 2));
   persistDeviceKey(config.deviceKey);
 }
 function writeLiveActivitiesCache(activities) {
-  if (!existsSync2(CONFIG_DIR)) mkdirSync(CONFIG_DIR, { recursive: true });
+  if (!existsSync3(CONFIG_DIR)) mkdirSync(CONFIG_DIR, { recursive: true });
   writeFileSync(LIVE_ACTIVITIES_CACHE, JSON.stringify(activities, null, 2));
 }
 var BridgeService = class {
   constructor(config) {
     this.timers = [];
+    this.terminalPeer = null;
     this.config = config;
     this.client = new ConvexHttpClient2(config.convexUrl);
   }
@@ -1949,7 +2350,7 @@ var BridgeService = class {
       }
     );
     if (commands.length > 0) {
-      console.log(`[${ts()}] ${commands.length} pending command(s)`);
+      console.log(`[${ts2()}] ${commands.length} pending command(s)`);
     }
     for (const cmd of commands) {
       await this.handleCommand(cmd);
@@ -1978,6 +2379,10 @@ var BridgeService = class {
           await this.handleLaunchCommand(cmd);
           await this.completeCommand(cmd._id, "delivered");
           return;
+        case "resize":
+          await this.handleResizeCommand(cmd);
+          await this.completeCommand(cmd._id, "delivered");
+          return;
         default:
           throw new Error(`Unsupported bridge command: ${cmd.kind}`);
       }
@@ -2012,7 +2417,7 @@ var BridgeService = class {
     }
     if (processes.length > 0) {
       console.log(
-        `[${ts()}] Discovered ${processes.length} attachable session(s)`
+        `[${ts2()}] Discovered ${processes.length} attachable session(s)`
       );
     }
   }
@@ -2027,6 +2432,17 @@ var BridgeService = class {
       );
       writeLiveActivitiesCache(activities);
       await this.syncWorkSessionTerminals(activities);
+      if (this.terminalPeer) {
+        for (const activity of activities) {
+          if (activity.workSessionId && activity.tmuxSessionName) {
+            this.terminalPeer.watchSession(
+              activity.workSessionId,
+              activity.tmuxSessionName,
+              activity.tmuxPaneId
+            );
+          }
+        }
+      }
     } catch {
     }
   }
@@ -2115,45 +2531,62 @@ var BridgeService = class {
     console.log(`  Convex:  ${this.config.convexUrl}`);
     console.log(`  PID:     ${process.pid}`);
     console.log("");
-    if (!existsSync2(CONFIG_DIR)) mkdirSync(CONFIG_DIR, { recursive: true });
+    if (!existsSync3(CONFIG_DIR)) mkdirSync(CONFIG_DIR, { recursive: true });
     writeFileSync(PID_FILE, String(process.pid));
+    try {
+      this.terminalPeer = new TerminalPeerManager({
+        deviceId: this.config.deviceId,
+        deviceSecret: this.config.deviceSecret,
+        convexUrl: this.config.convexUrl,
+        tunnelHost: this.config.tunnelHost
+      });
+      console.log(
+        `  Terminal: ready${this.config.tunnelHost ? ` (tunnel: ${this.config.tunnelHost})` : ""}`
+      );
+    } catch (e) {
+      console.error(
+        `  WebRTC:  failed (${e instanceof Error ? e.message : "unknown"})`
+      );
+    }
+    console.log("");
     await this.heartbeat();
     await this.reportProcesses();
     await this.refreshLiveActivities();
-    console.log(`[${ts()}] Service running. Ctrl+C to stop.
+    console.log(`[${ts2()}] Service running. Ctrl+C to stop.
 `);
     this.timers.push(
       setInterval(() => {
         this.heartbeat().catch(
-          (e) => console.error(`[${ts()}] Heartbeat error:`, e.message)
+          (e) => console.error(`[${ts2()}] Heartbeat error:`, e.message)
         );
       }, HEARTBEAT_INTERVAL_MS)
     );
     this.timers.push(
       setInterval(() => {
         this.pollCommands().catch(
-          (e) => console.error(`[${ts()}] Command poll error:`, e.message)
+          (e) => console.error(`[${ts2()}] Command poll error:`, e.message)
         );
       }, COMMAND_POLL_INTERVAL_MS)
     );
     this.timers.push(
       setInterval(() => {
         this.refreshLiveActivities().catch(
-          (e) => console.error(`[${ts()}] Live activity sync error:`, e.message)
+          (e) => console.error(`[${ts2()}] Live activity sync error:`, e.message)
         );
       }, LIVE_ACTIVITY_SYNC_INTERVAL_MS)
     );
     this.timers.push(
       setInterval(() => {
         this.reportProcesses().catch(
-          (e) => console.error(`[${ts()}] Discovery error:`, e.message)
+          (e) => console.error(`[${ts2()}] Discovery error:`, e.message)
         );
       }, PROCESS_DISCOVERY_INTERVAL_MS)
     );
     const shutdown = () => {
       console.log(`
-[${ts()}] Shutting down...`);
+[${ts2()}] Shutting down...`);
       for (const t of this.timers) clearInterval(t);
+      this.terminalPeer?.stop();
       try {
         unlinkSync(PID_FILE);
       } catch {
@@ -2252,6 +2685,29 @@ var BridgeService = class {
       title: cmd.liveActivity?.title ?? process9.title
     });
   }
+  async handleResizeCommand(cmd) {
+    const payload = cmd.payload;
+    const cols = payload?.cols;
+    const rows = payload?.rows;
+    const paneId = cmd.workSession?.tmuxPaneId;
+    if (!paneId || !cols || !rows) {
+      throw new Error("Resize command missing paneId, cols, or rows");
+    }
+    console.log(`  Resize ${paneId} \u2192 ${cols}x${rows}`);
+    resizeTmuxPane(paneId, cols, rows);
+    if (cmd.workSession) {
+      await this.refreshWorkSessionTerminal(cmd.workSession._id, {
+        tmuxSessionName: cmd.workSession.tmuxSessionName,
+        tmuxWindowName: cmd.workSession.tmuxWindowName,
+        tmuxPaneId: paneId,
+        cwd: cmd.workSession.cwd,
+        repoRoot: cmd.workSession.repoRoot,
+        branch: cmd.workSession.branch,
+        agentProvider: cmd.workSession.agentProvider,
+        agentSessionKey: cmd.workSession.agentSessionKey
+      });
+    }
+  }
   async handleLaunchCommand(cmd) {
     if (!cmd.liveActivityId) {
       throw new Error("Launch command is missing liveActivityId");
@@ -2365,6 +2821,9 @@ var BridgeService = class {
       branch,
       title,
       model,
+      tmuxSessionName,
+      tmuxWindowName,
+      tmuxPaneId,
       mode,
       status,
       supportsInboundMessages
@@ -2383,6 +2842,9 @@ var BridgeService = class {
         branch,
         title,
         model,
+        tmuxSessionName,
+        tmuxWindowName,
+        tmuxPaneId,
         mode,
         status,
         supportsInboundMessages
@@ -2440,11 +2902,11 @@ var BridgeService = class {
 };
 function createTmuxWorkSession(args) {
   const slug = sanitizeTmuxName(args.issueKey.toLowerCase());
-  const sessionName = `vector-${slug}-${randomUUID().slice(0, 8)}`;
+  const sessionName = `vector-${slug}-${randomUUID2().slice(0, 8)}`;
   const windowName = sanitizeTmuxName(
     args.provider === "codex" ? "codex" : args.provider === "claude_code" ? "claude" : "shell"
   );
-  execFileSync("tmux", [
+  execFileSync2("tmux", [
     "new-session",
     "-d",
     "-s",
@@ -2454,7 +2916,7 @@ function createTmuxWorkSession(args) {
     "-c",
     args.workspacePath
   ]);
-  const paneId = execFileSync(
+  const paneId = execFileSync2(
     "tmux",
     [
       "display-message",
@@ -2465,13 +2927,13 @@ function createTmuxWorkSession(args) {
     ],
     { encoding: "utf-8" }
   ).trim();
-  const paneProcessId = execFileSync(
+  const paneProcessId = execFileSync2(
     "tmux",
     ["display-message", "-p", "-t", paneId, "#{pane_pid}"],
     { encoding: "utf-8" }
   ).trim();
   if (args.provider) {
-    execFileSync("tmux", [
+    execFileSync2("tmux", [
       "send-keys",
       "-t",
       paneId,
@@ -2479,7 +2941,7 @@ function createTmuxWorkSession(args) {
       "Enter"
     ]);
   } else {
-    execFileSync("tmux", [
+    execFileSync2("tmux", [
       "send-keys",
       "-t",
       paneId,
@@ -2495,17 +2957,32 @@ function createTmuxWorkSession(args) {
   };
 }
 function sendTextToTmuxPane(paneId, text2) {
-  execFileSync("tmux", ["set-buffer", "--", text2]);
-  execFileSync("tmux", ["paste-buffer", "-t", paneId]);
-  execFileSync("tmux", ["send-keys", "-t", paneId, "Enter"]);
-  execFileSync("tmux", ["delete-buffer"]);
+  execFileSync2("tmux", ["set-buffer", "--", text2]);
+  execFileSync2("tmux", ["paste-buffer", "-t", paneId]);
+  execFileSync2("tmux", ["send-keys", "-t", paneId, "Enter"]);
+  execFileSync2("tmux", ["delete-buffer"]);
 }
 function captureTmuxPane(paneId) {
-  return execFileSync(
+  return execFileSync2(
     "tmux",
-    ["capture-pane", "-p", "-t", paneId, "-S", "-120"],
+    ["capture-pane", "-p", "-e", "-t", paneId, "-S", "-120"],
     { encoding: "utf-8" }
-  ).replace(/\u001B\[[0-9;?]*[A-Za-z]/g, "").trimEnd();
+  ).trimEnd();
+}
+function resizeTmuxPane(paneId, cols, rows) {
+  try {
+    execFileSync2("tmux", [
+      "resize-pane",
+      "-t",
+      paneId,
+      "-x",
+      String(cols),
+      "-y",
+      String(rows)
+    ]);
+  } catch (e) {
+    console.error(`Failed to resize pane ${paneId}:`, e);
+  }
 }
 function currentGitBranch(cwd) {
   try {
@@ -2564,18 +3041,18 @@ function getStableDeviceKey() {
     persistDeviceKey(existingKey);
     return existingKey;
   }
-  if (existsSync2(DEVICE_KEY_FILE)) {
+  if (existsSync3(DEVICE_KEY_FILE)) {
     const savedKey = readFileSync2(DEVICE_KEY_FILE, "utf-8").trim();
     if (savedKey) {
       return savedKey;
     }
   }
-  const generatedKey = `${hostname()}-${randomUUID().slice(0, 8)}`;
+  const generatedKey = `${hostname()}-${randomUUID2().slice(0, 8)}`;
   persistDeviceKey(generatedKey);
   return generatedKey;
 }
 function persistDeviceKey(deviceKey) {
-  if (!existsSync2(CONFIG_DIR)) mkdirSync(CONFIG_DIR, { recursive: true });
+  if (!existsSync3(CONFIG_DIR)) mkdirSync(CONFIG_DIR, { recursive: true });
   writeFileSync(DEVICE_KEY_FILE, `${deviceKey}
 `);
 }
@@ -2672,7 +3149,13 @@ function isBridgeProvider(provider) {
   return provider === "codex" || provider === "claude_code";
 }
 function providerLabel(provider) {
-  return provider === "codex" ? "Codex" : "Claude";
+  if (provider === "codex") {
+    return "Codex";
+  }
+  if (provider === "claude_code") {
+    return "Claude";
+  }
+  return "Vector CLI";
 }
 function installLaunchAgent(vcliPath) {
   if (platform() !== "darwin") {
@@ -2710,7 +3193,7 @@ ${environmentVariables}
   </dict>
 </dict>
 </plist>`;
-  if (!existsSync2(LAUNCHAGENT_DIR)) {
+  if (!existsSync3(LAUNCHAGENT_DIR)) {
     mkdirSync(LAUNCHAGENT_DIR, { recursive: true });
   }
   removeLegacyMenuBarLaunchAgent();
@@ -2741,7 +3224,7 @@ function resolveCliInvocation(vcliPath) {
       ".bin",
       "tsx"
     );
-    if (existsSync2(tsxPath)) {
+    if (existsSync3(tsxPath)) {
       return [tsxPath, vcliPath];
     }
   }
@@ -2790,7 +3273,7 @@ function uninstallLaunchAgent() {
 }
 var MENUBAR_PID_FILE = join2(CONFIG_DIR, "menubar.pid");
 function removeLegacyMenuBarLaunchAgent() {
-  if (platform() !== "darwin" || !existsSync2(LEGACY_MENUBAR_LAUNCHAGENT_PLIST)) {
+  if (platform() !== "darwin" || !existsSync3(LEGACY_MENUBAR_LAUNCHAGENT_PLIST)) {
     return;
   }
   try {
@@ -2810,7 +3293,7 @@ function launchctlGuiDomain() {
 }
 function runLaunchctl(args) {
   try {
-    execFileSync("launchctl", args, {
+    execFileSync2("launchctl", args, {
       stdio: "ignore"
     });
     return true;
@@ -2825,7 +3308,7 @@ function findCliEntrypoint() {
     join2(import.meta.dirname ?? "", "..", "dist", "index.js")
   ];
   for (const p of candidates) {
-    if (existsSync2(p)) return p;
+    if (existsSync3(p)) return p;
   }
   return null;
 }
@@ -2857,7 +3340,7 @@ function findMenuBarExecutable() {
     )
   ];
   for (const p of candidates) {
-    if (existsSync2(p)) {
+    if (existsSync3(p)) {
       return p;
     }
   }
@@ -2875,7 +3358,7 @@ function isKnownMenuBarProcess(pid) {
   }
 }
 function killExistingMenuBar() {
-  if (existsSync2(MENUBAR_PID_FILE)) {
+  if (existsSync3(MENUBAR_PID_FILE)) {
     try {
       const pid = Number(readFileSync2(MENUBAR_PID_FILE, "utf-8").trim());
       if (Number.isFinite(pid) && pid > 0 && isKnownMenuBarProcess(pid)) {
@@ -2890,7 +3373,7 @@ function killExistingMenuBar() {
   }
 }
 function getRunningMenuBarPid() {
-  if (!existsSync2(MENUBAR_PID_FILE)) {
+  if (!existsSync3(MENUBAR_PID_FILE)) {
     return null;
   }
   try {
@@ -2945,7 +3428,7 @@ function getBridgeStatus() {
   let running = false;
   let starting = false;
   let pid;
-  if (existsSync2(PID_FILE)) {
+  if (existsSync3(PID_FILE)) {
     const pidStr = readFileSync2(PID_FILE, "utf-8").trim();
     pid = Number(pidStr);
     try {
@@ -2968,7 +3451,7 @@ function stopBridge(options) {
     writeLiveActivitiesCache([]);
   } catch {
   }
-  if (!existsSync2(PID_FILE)) return false;
+  if (!existsSync3(PID_FILE)) return false;
   const pid = Number(readFileSync2(PID_FILE, "utf-8").trim());
   try {
     process.kill(pid, "SIGTERM");
@@ -2977,7 +3460,7 @@ function stopBridge(options) {
     return false;
   }
 }
-function ts() {
+function ts2() {
   return (/* @__PURE__ */ new Date()).toLocaleTimeString();
 }
 
@@ -3187,7 +3670,7 @@ async function resolveAppUrl(raw) {
     return url;
   }
 }
-async function fetchConvexUrl(appUrl) {
+async function fetchAppConfig(appUrl) {
   try {
     const url = new URL("/api/config", appUrl).toString();
     const response = await fetch(url);
@@ -3196,15 +3679,22 @@ async function fetchConvexUrl(appUrl) {
     }
     const data = await response.json();
     if (data.convexUrl) {
-      return data.convexUrl;
+      return {
+        convexUrl: data.convexUrl,
+        tunnelHost: data.tunnelHost || void 0
+      };
     }
   } catch {
   }
-  return "http://127.0.0.1:3210";
+  return { convexUrl: "http://127.0.0.1:3210" };
+}
+async function fetchConvexUrl(appUrl) {
+  const config = await fetchAppConfig(appUrl);
+  return config.convexUrl;
 }
 async function getRuntime(command) {
   const options = command.optsWithGlobals();
-  const profile = options.profile ?? "default";
+  const profile = options.profile ?? await readDefaultProfile();
   const session = await readSession(profile);
   const appUrlSource = options.appUrl ?? session?.appUrl ?? process.env.NEXT_PUBLIC_APP_URL;
   const appUrl = await resolveAppUrl(requiredString(appUrlSource, "app URL"));
@@ -3345,6 +3835,10 @@ async function ensureBridgeConfig(command) {
     if (!config) {
       throw new Error("Bridge device is not configured.");
     }
+    const appConfig = await fetchAppConfig(runtime.appUrl);
+    if (appConfig.tunnelHost) {
+      config.tunnelHost = appConfig.tunnelHost;
+    }
     saveBridgeConfig(config);
     return config;
   } catch (error) {
@@ -3541,7 +4035,7 @@ function readPackageVersionSync() {
 program.name("vcli").description("Vector CLI").version(readPackageVersionSync(), "-v, --version").showHelpAfterError().option(
   "--app-url <url>",
   "Vector app URL. Required unless saved in the profile or NEXT_PUBLIC_APP_URL is set."
-).option("--convex-url <url>", "Convex deployment URL").option("--org <slug>", "Organization slug override").option("--profile <name>", "CLI profile name", "default").option("--json", "Output JSON");
+).option("--convex-url <url>", "Convex deployment URL").option("--org <slug>", "Organization slug override").option("--profile <name>", "CLI profile name").option("--json", "Output JSON");
 var authCommand = program.command("auth").description("Authentication");
 authCommand.command("signup").option("--email <email>", "Email address").option("--username <username>", "Username").option("--password <password>", "Password").action(async (options, command) => {
   const runtime = await getRuntime(command);
@@ -3664,6 +4158,38 @@ authCommand.command("whoami").action(async (_options, command) => {
     runtime.json
   );
 });
+authCommand.command("profiles").action(async (_options, command) => {
+  const options = command.optsWithGlobals();
+  const explicitProfile = options.profile?.trim();
+  const defaultProfile = await readDefaultProfile();
+  const profiles = await listProfiles();
+  const activeProfile = explicitProfile || defaultProfile;
+  printOutput(
+    {
+      activeProfile,
+      defaultProfile,
+      profiles
+    },
+    Boolean(options.json)
+  );
+});
+authCommand.command("use-profile <name>").action(async (name, _options, command) => {
+  const options = command.optsWithGlobals();
+  const profile = name.trim();
+  if (!profile) {
+    throw new Error("Profile name is required.");
+  }
+  await writeDefaultProfile(profile);
+  const session = await readSession(profile);
+  printOutput(
+    {
+      ok: true,
+      defaultProfile: profile,
+      hasSession: session !== null
+    },
+    Boolean(options.json)
+  );
+});
 var orgCommand = program.command("org").description("Organizations");
 orgCommand.command("list").action(async (_options, command) => {
   const { client, runtime } = await getClient(command);
@@ -5145,8 +5671,11 @@ serviceCommand.command("status").description("Show bridge service status").actio
 serviceCommand.command("menu-state").description("Return JSON state for the macOS tray").action(async (_options, command) => {
   const status = getBridgeStatus();
   const globalOptions = command.optsWithGlobals();
-  const profile = globalOptions.profile ?? "default";
+  const profile = globalOptions.profile ?? await readDefaultProfile();
   const session = await readSession(profile);
+  const profiles = await listProfiles();
+  const defaultProfile = await readDefaultProfile();
+  let workspaces = [];
   let workSessions = [];
   let detectedSessions = [];
   try {
@@ -5157,6 +5686,13 @@ serviceCommand.command("menu-state").description("Return JSON state for the macO
         runtime.appUrl,
         runtime.convexUrl
       );
+      workspaces = await runQuery(
+        client,
+        api.agentBridge.queries.listDeviceWorkspaces,
+        {
+          deviceId: status.config.deviceId
+        }
+      );
       workSessions = await runQuery(
         client,
         api.agentBridge.queries.listDeviceWorkSessions,
@@ -5175,6 +5711,7 @@ serviceCommand.command("menu-state").description("Return JSON state for the macO
       detectedSessions = currentDevice?.processes ?? [];
     }
   } catch {
+    workspaces = [];
     workSessions = [];
     detectedSessions = [];
   }
@@ -5186,12 +5723,27 @@ serviceCommand.command("menu-state").description("Return JSON state for the macO
       pid: status.pid,
       config: status.config,
       sessionInfo: buildMenuSessionInfo(session),
+      activeProfile: profile,
+      defaultProfile,
+      profiles,
+      workspaces,
       workSessions,
       detectedSessions
     },
     Boolean(globalOptions.json)
   );
 });
+serviceCommand.command("set-default-workspace").description("Set the default workspace for this device").requiredOption("--workspace-id <id>").action(async (options, command) => {
+  const { client, runtime } = await getClient(command);
+  const workspaceId = await runMutation(
+    client,
+    api.agentBridge.mutations.setDefaultWorkspace,
+    {
+      workspaceId: options.workspaceId
+    }
+  );
+  printOutput({ ok: true, workspaceId }, runtime.json);
+});
 serviceCommand.command("search-issues <query>").description("Search issues for tray attach actions").option("--limit <n>").action(async (query, options, command) => {
   const { client, runtime } = await getClient(command);
   const orgSlug = requireOrg(runtime);