@rehpic/vcli 0.1.0-beta.6.1 → 0.1.0-beta.68.1

package/dist/index.js

@@ -1,10 +1,748 @@
 #!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// ../../node_modules/.pnpm/is-docker@3.0.0/node_modules/is-docker/index.js
+import fs from "fs";
+function hasDockerEnv() {
+  try {
+    fs.statSync("/.dockerenv");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function hasDockerCGroup() {
+  try {
+    return fs.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
+  } catch {
+    return false;
+  }
+}
+function isDocker() {
+  if (isDockerCached === void 0) {
+    isDockerCached = hasDockerEnv() || hasDockerCGroup();
+  }
+  return isDockerCached;
+}
+var isDockerCached;
+var init_is_docker = __esm({
+  "../../node_modules/.pnpm/is-docker@3.0.0/node_modules/is-docker/index.js"() {
+    "use strict";
+  }
+});
+
+// ../../node_modules/.pnpm/is-inside-container@1.0.0/node_modules/is-inside-container/index.js
+import fs2 from "fs";
+function isInsideContainer() {
+  if (cachedResult === void 0) {
+    cachedResult = hasContainerEnv() || isDocker();
+  }
+  return cachedResult;
+}
+var cachedResult, hasContainerEnv;
+var init_is_inside_container = __esm({
+  "../../node_modules/.pnpm/is-inside-container@1.0.0/node_modules/is-inside-container/index.js"() {
+    "use strict";
+    init_is_docker();
+    hasContainerEnv = () => {
+      try {
+        fs2.statSync("/run/.containerenv");
+        return true;
+      } catch {
+        return false;
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/is-wsl@3.1.1/node_modules/is-wsl/index.js
+import process2 from "process";
+import os from "os";
+import fs3 from "fs";
+var isWsl, is_wsl_default;
+var init_is_wsl = __esm({
+  "../../node_modules/.pnpm/is-wsl@3.1.1/node_modules/is-wsl/index.js"() {
+    "use strict";
+    init_is_inside_container();
+    isWsl = () => {
+      if (process2.platform !== "linux") {
+        return false;
+      }
+      if (os.release().toLowerCase().includes("microsoft")) {
+        if (isInsideContainer()) {
+          return false;
+        }
+        return true;
+      }
+      try {
+        if (fs3.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft")) {
+          return !isInsideContainer();
+        }
+      } catch {
+      }
+      if (fs3.existsSync("/proc/sys/fs/binfmt_misc/WSLInterop") || fs3.existsSync("/run/WSL")) {
+        return !isInsideContainer();
+      }
+      return false;
+    };
+    is_wsl_default = process2.env.__IS_WSL_TEST__ ? isWsl : isWsl();
+  }
+});
+
+// ../../node_modules/.pnpm/powershell-utils@0.1.0/node_modules/powershell-utils/index.js
+import process3 from "process";
+import { Buffer as Buffer2 } from "buffer";
+import { promisify } from "util";
+import childProcess from "child_process";
+import fs4, { constants as fsConstants } from "fs/promises";
+var execFile, powerShellPath, executePowerShell;
+var init_powershell_utils = __esm({
+  "../../node_modules/.pnpm/powershell-utils@0.1.0/node_modules/powershell-utils/index.js"() {
+    "use strict";
+    execFile = promisify(childProcess.execFile);
+    powerShellPath = () => `${process3.env.SYSTEMROOT || process3.env.windir || String.raw`C:\Windows`}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe`;
+    executePowerShell = async (command, options = {}) => {
+      const {
+        powerShellPath: psPath,
+        ...execFileOptions
+      } = options;
+      const encodedCommand = executePowerShell.encodeCommand(command);
+      return execFile(
+        psPath ?? powerShellPath(),
+        [
+          ...executePowerShell.argumentsPrefix,
+          encodedCommand
+        ],
+        {
+          encoding: "utf8",
+          ...execFileOptions
+        }
+      );
+    };
+    executePowerShell.argumentsPrefix = [
+      "-NoProfile",
+      "-NonInteractive",
+      "-ExecutionPolicy",
+      "Bypass",
+      "-EncodedCommand"
+    ];
+    executePowerShell.encodeCommand = (command) => Buffer2.from(command, "utf16le").toString("base64");
+    executePowerShell.escapeArgument = (value) => `'${String(value).replaceAll("'", "''")}'`;
+  }
+});
+
+// ../../node_modules/.pnpm/wsl-utils@0.3.1/node_modules/wsl-utils/utilities.js
+function parseMountPointFromConfig(content) {
+  for (const line of content.split("\n")) {
+    if (/^\s*#/.test(line)) {
+      continue;
+    }
+    const match = /^\s*root\s*=\s*(?<mountPoint>"[^"]*"|'[^']*'|[^#]*)/.exec(line);
+    if (!match) {
+      continue;
+    }
+    return match.groups.mountPoint.trim().replaceAll(/^["']|["']$/g, "");
+  }
+}
+var init_utilities = __esm({
+  "../../node_modules/.pnpm/wsl-utils@0.3.1/node_modules/wsl-utils/utilities.js"() {
+    "use strict";
+  }
+});
+
+// ../../node_modules/.pnpm/wsl-utils@0.3.1/node_modules/wsl-utils/index.js
+import { promisify as promisify2 } from "util";
+import childProcess2 from "child_process";
+import fs5, { constants as fsConstants2 } from "fs/promises";
+var execFile2, wslDrivesMountPoint, powerShellPathFromWsl, powerShellPath2, canAccessPowerShellPromise, canAccessPowerShell, wslDefaultBrowser, convertWslPathToWindows;
+var init_wsl_utils = __esm({
+  "../../node_modules/.pnpm/wsl-utils@0.3.1/node_modules/wsl-utils/index.js"() {
+    "use strict";
+    init_is_wsl();
+    init_powershell_utils();
+    init_utilities();
+    init_is_wsl();
+    execFile2 = promisify2(childProcess2.execFile);
+    wslDrivesMountPoint = /* @__PURE__ */ (() => {
+      const defaultMountPoint = "/mnt/";
+      let mountPoint;
+      return async function() {
+        if (mountPoint) {
+          return mountPoint;
+        }
+        const configFilePath = "/etc/wsl.conf";
+        let isConfigFileExists = false;
+        try {
+          await fs5.access(configFilePath, fsConstants2.F_OK);
+          isConfigFileExists = true;
+        } catch {
+        }
+        if (!isConfigFileExists) {
+          return defaultMountPoint;
+        }
+        const configContent = await fs5.readFile(configFilePath, { encoding: "utf8" });
+        const parsedMountPoint = parseMountPointFromConfig(configContent);
+        if (parsedMountPoint === void 0) {
+          return defaultMountPoint;
+        }
+        mountPoint = parsedMountPoint;
+        mountPoint = mountPoint.endsWith("/") ? mountPoint : `${mountPoint}/`;
+        return mountPoint;
+      };
+    })();
+    powerShellPathFromWsl = async () => {
+      const mountPoint = await wslDrivesMountPoint();
+      return `${mountPoint}c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe`;
+    };
+    powerShellPath2 = is_wsl_default ? powerShellPathFromWsl : powerShellPath;
+    canAccessPowerShell = async () => {
+      canAccessPowerShellPromise ??= (async () => {
+        try {
+          const psPath = await powerShellPath2();
+          await fs5.access(psPath, fsConstants2.X_OK);
+          return true;
+        } catch {
+          return false;
+        }
+      })();
+      return canAccessPowerShellPromise;
+    };
+    wslDefaultBrowser = async () => {
+      const psPath = await powerShellPath2();
+      const command = String.raw`(Get-ItemProperty -Path "HKCU:\Software\Microsoft\Windows\Shell\Associations\UrlAssociations\http\UserChoice").ProgId`;
+      const { stdout } = await executePowerShell(command, { powerShellPath: psPath });
+      return stdout.trim();
+    };
+    convertWslPathToWindows = async (path3) => {
+      if (/^[a-z]+:\/\//i.test(path3)) {
+        return path3;
+      }
+      try {
+        const { stdout } = await execFile2("wslpath", ["-aw", path3], { encoding: "utf8" });
+        return stdout.trim();
+      } catch {
+        return path3;
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/define-lazy-prop@3.0.0/node_modules/define-lazy-prop/index.js
+function defineLazyProperty(object, propertyName, valueGetter) {
+  const define = (value) => Object.defineProperty(object, propertyName, { value, enumerable: true, writable: true });
+  Object.defineProperty(object, propertyName, {
+    configurable: true,
+    enumerable: true,
+    get() {
+      const result = valueGetter();
+      define(result);
+      return result;
+    },
+    set(value) {
+      define(value);
+    }
+  });
+  return object;
+}
+var init_define_lazy_prop = __esm({
+  "../../node_modules/.pnpm/define-lazy-prop@3.0.0/node_modules/define-lazy-prop/index.js"() {
+    "use strict";
+  }
+});
+
+// ../../node_modules/.pnpm/default-browser-id@5.0.1/node_modules/default-browser-id/index.js
+import { promisify as promisify3 } from "util";
+import process4 from "process";
+import { execFile as execFile3 } from "child_process";
+async function defaultBrowserId() {
+  if (process4.platform !== "darwin") {
+    throw new Error("macOS only");
+  }
+  const { stdout } = await execFileAsync("defaults", ["read", "com.apple.LaunchServices/com.apple.launchservices.secure", "LSHandlers"]);
+  const match = /LSHandlerRoleAll = "(?!-)(?<id>[^"]+?)";\s+?LSHandlerURLScheme = (?:http|https);/.exec(stdout);
+  const browserId = match?.groups.id ?? "com.apple.Safari";
+  if (browserId === "com.apple.safari") {
+    return "com.apple.Safari";
+  }
+  return browserId;
+}
+var execFileAsync;
+var init_default_browser_id = __esm({
+  "../../node_modules/.pnpm/default-browser-id@5.0.1/node_modules/default-browser-id/index.js"() {
+    "use strict";
+    execFileAsync = promisify3(execFile3);
+  }
+});
+
+// ../../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";
+async function runAppleScript(script, { humanReadableOutput = true, signal } = {}) {
+  if (process5.platform !== "darwin") {
+    throw new Error("macOS only");
+  }
+  const outputArguments = humanReadableOutput ? [] : ["-ss"];
+  const execOptions = {};
+  if (signal) {
+    execOptions.signal = signal;
+  }
+  const { stdout } = await execFileAsync2("osascript", ["-e", script, outputArguments], execOptions);
+  return stdout.trim();
+}
+var execFileAsync2;
+var init_run_applescript = __esm({
+  "../../node_modules/.pnpm/run-applescript@7.1.0/node_modules/run-applescript/index.js"() {
+    "use strict";
+    execFileAsync2 = promisify4(execFile4);
+  }
+});
+
+// ../../node_modules/.pnpm/bundle-name@4.1.0/node_modules/bundle-name/index.js
+async function bundleName(bundleId) {
+  return runAppleScript(`tell application "Finder" to set app_path to application file id "${bundleId}" as string
+tell application "System Events" to get value of property list item "CFBundleName" of property list file (app_path & ":Contents:Info.plist")`);
+}
+var init_bundle_name = __esm({
+  "../../node_modules/.pnpm/bundle-name@4.1.0/node_modules/bundle-name/index.js"() {
+    "use strict";
+    init_run_applescript();
+  }
+});
+
+// ../../node_modules/.pnpm/default-browser@5.5.0/node_modules/default-browser/windows.js
+import { promisify as promisify5 } from "util";
+import { execFile as execFile5 } from "child_process";
+async function defaultBrowser(_execFileAsync = execFileAsync3) {
+  const { stdout } = await _execFileAsync("reg", [
+    "QUERY",
+    " HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\Shell\\Associations\\UrlAssociations\\http\\UserChoice",
+    "/v",
+    "ProgId"
+  ]);
+  const match = /ProgId\s*REG_SZ\s*(?<id>\S+)/.exec(stdout);
+  if (!match) {
+    throw new UnknownBrowserError(`Cannot find Windows browser in stdout: ${JSON.stringify(stdout)}`);
+  }
+  const { id } = match.groups;
+  const dotIndex = id.lastIndexOf(".");
+  const hyphenIndex = id.lastIndexOf("-");
+  const baseIdByDot = dotIndex === -1 ? void 0 : id.slice(0, dotIndex);
+  const baseIdByHyphen = hyphenIndex === -1 ? void 0 : id.slice(0, hyphenIndex);
+  return windowsBrowserProgIds[id] ?? windowsBrowserProgIds[baseIdByDot] ?? windowsBrowserProgIds[baseIdByHyphen] ?? { name: id, id };
+}
+var execFileAsync3, windowsBrowserProgIds, _windowsBrowserProgIdMap, UnknownBrowserError;
+var init_windows = __esm({
+  "../../node_modules/.pnpm/default-browser@5.5.0/node_modules/default-browser/windows.js"() {
+    "use strict";
+    execFileAsync3 = promisify5(execFile5);
+    windowsBrowserProgIds = {
+      MSEdgeHTM: { name: "Edge", id: "com.microsoft.edge" },
+      // The missing `L` is correct.
+      MSEdgeBHTML: { name: "Edge Beta", id: "com.microsoft.edge.beta" },
+      MSEdgeDHTML: { name: "Edge Dev", id: "com.microsoft.edge.dev" },
+      AppXq0fevzme2pys62n3e0fbqa7peapykr8v: { name: "Edge", id: "com.microsoft.edge.old" },
+      ChromeHTML: { name: "Chrome", id: "com.google.chrome" },
+      ChromeBHTML: { name: "Chrome Beta", id: "com.google.chrome.beta" },
+      ChromeDHTML: { name: "Chrome Dev", id: "com.google.chrome.dev" },
+      ChromiumHTM: { name: "Chromium", id: "org.chromium.Chromium" },
+      BraveHTML: { name: "Brave", id: "com.brave.Browser" },
+      BraveBHTML: { name: "Brave Beta", id: "com.brave.Browser.beta" },
+      BraveDHTML: { name: "Brave Dev", id: "com.brave.Browser.dev" },
+      BraveSSHTM: { name: "Brave Nightly", id: "com.brave.Browser.nightly" },
+      FirefoxURL: { name: "Firefox", id: "org.mozilla.firefox" },
+      OperaStable: { name: "Opera", id: "com.operasoftware.Opera" },
+      VivaldiHTM: { name: "Vivaldi", id: "com.vivaldi.Vivaldi" },
+      "IE.HTTP": { name: "Internet Explorer", id: "com.microsoft.ie" }
+    };
+    _windowsBrowserProgIdMap = new Map(Object.entries(windowsBrowserProgIds));
+    UnknownBrowserError = class extends Error {
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/default-browser@5.5.0/node_modules/default-browser/index.js
+import { promisify as promisify6 } from "util";
+import process6 from "process";
+import { execFile as execFile6 } from "child_process";
+async function defaultBrowser2() {
+  if (process6.platform === "darwin") {
+    const id = await defaultBrowserId();
+    const name = await bundleName(id);
+    return { name, id };
+  }
+  if (process6.platform === "linux") {
+    const { stdout } = await execFileAsync4("xdg-mime", ["query", "default", "x-scheme-handler/http"]);
+    const id = stdout.trim();
+    const name = titleize(id.replace(/.desktop$/, "").replace("-", " "));
+    return { name, id };
+  }
+  if (process6.platform === "win32") {
+    return defaultBrowser();
+  }
+  throw new Error("Only macOS, Linux, and Windows are supported");
+}
+var execFileAsync4, titleize;
+var init_default_browser = __esm({
+  "../../node_modules/.pnpm/default-browser@5.5.0/node_modules/default-browser/index.js"() {
+    "use strict";
+    init_default_browser_id();
+    init_bundle_name();
+    init_windows();
+    init_windows();
+    execFileAsync4 = promisify6(execFile6);
+    titleize = (string) => string.toLowerCase().replaceAll(/(?:^|\s|-)\S/g, (x) => x.toUpperCase());
+  }
+});
+
+// ../../node_modules/.pnpm/is-in-ssh@1.0.0/node_modules/is-in-ssh/index.js
+import process7 from "process";
+var isInSsh, is_in_ssh_default;
+var init_is_in_ssh = __esm({
+  "../../node_modules/.pnpm/is-in-ssh@1.0.0/node_modules/is-in-ssh/index.js"() {
+    "use strict";
+    isInSsh = Boolean(process7.env.SSH_CONNECTION || process7.env.SSH_CLIENT || process7.env.SSH_TTY);
+    is_in_ssh_default = isInSsh;
+  }
+});
+
+// ../../node_modules/.pnpm/open@11.0.0/node_modules/open/index.js
+var open_exports = {};
+__export(open_exports, {
+  apps: () => apps,
+  default: () => open_default,
+  openApp: () => openApp
+});
+import process8 from "process";
+import path2 from "path";
+import { fileURLToPath } from "url";
+import childProcess3 from "child_process";
+import fs6, { constants as fsConstants3 } from "fs/promises";
+function detectArchBinary(binary) {
+  if (typeof binary === "string" || Array.isArray(binary)) {
+    return binary;
+  }
+  const { [arch]: archBinary } = binary;
+  if (!archBinary) {
+    throw new Error(`${arch} is not supported`);
+  }
+  return archBinary;
+}
+function detectPlatformBinary({ [platform2]: platformBinary }, { wsl } = {}) {
+  if (wsl && is_wsl_default) {
+    return detectArchBinary(wsl);
+  }
+  if (!platformBinary) {
+    throw new Error(`${platform2} is not supported`);
+  }
+  return detectArchBinary(platformBinary);
+}
+var fallbackAttemptSymbol, __dirname, localXdgOpenPath, platform2, arch, tryEachApp, baseOpen, open, openApp, apps, open_default;
+var init_open = __esm({
+  "../../node_modules/.pnpm/open@11.0.0/node_modules/open/index.js"() {
+    "use strict";
+    init_wsl_utils();
+    init_powershell_utils();
+    init_define_lazy_prop();
+    init_default_browser();
+    init_is_inside_container();
+    init_is_in_ssh();
+    fallbackAttemptSymbol = Symbol("fallbackAttempt");
+    __dirname = import.meta.url ? path2.dirname(fileURLToPath(import.meta.url)) : "";
+    localXdgOpenPath = path2.join(__dirname, "xdg-open");
+    ({ platform: platform2, arch } = process8);
+    tryEachApp = async (apps2, opener) => {
+      if (apps2.length === 0) {
+        return;
+      }
+      const errors = [];
+      for (const app of apps2) {
+        try {
+          return await opener(app);
+        } catch (error) {
+          errors.push(error);
+        }
+      }
+      throw new AggregateError(errors, "Failed to open in all supported apps");
+    };
+    baseOpen = async (options) => {
+      options = {
+        wait: false,
+        background: false,
+        newInstance: false,
+        allowNonzeroExitCode: false,
+        ...options
+      };
+      const isFallbackAttempt = options[fallbackAttemptSymbol] === true;
+      delete options[fallbackAttemptSymbol];
+      if (Array.isArray(options.app)) {
+        return tryEachApp(options.app, (singleApp) => baseOpen({
+          ...options,
+          app: singleApp,
+          [fallbackAttemptSymbol]: true
+        }));
+      }
+      let { name: app, arguments: appArguments = [] } = options.app ?? {};
+      appArguments = [...appArguments];
+      if (Array.isArray(app)) {
+        return tryEachApp(app, (appName) => baseOpen({
+          ...options,
+          app: {
+            name: appName,
+            arguments: appArguments
+          },
+          [fallbackAttemptSymbol]: true
+        }));
+      }
+      if (app === "browser" || app === "browserPrivate") {
+        const ids = {
+          "com.google.chrome": "chrome",
+          "google-chrome.desktop": "chrome",
+          "com.brave.browser": "brave",
+          "org.mozilla.firefox": "firefox",
+          "firefox.desktop": "firefox",
+          "com.microsoft.msedge": "edge",
+          "com.microsoft.edge": "edge",
+          "com.microsoft.edgemac": "edge",
+          "microsoft-edge.desktop": "edge",
+          "com.apple.safari": "safari"
+        };
+        const flags = {
+          chrome: "--incognito",
+          brave: "--incognito",
+          firefox: "--private-window",
+          edge: "--inPrivate"
+          // Safari doesn't support private mode via command line
+        };
+        let browser;
+        if (is_wsl_default) {
+          const progId = await wslDefaultBrowser();
+          const browserInfo = _windowsBrowserProgIdMap.get(progId);
+          browser = browserInfo ?? {};
+        } else {
+          browser = await defaultBrowser2();
+        }
+        if (browser.id in ids) {
+          const browserName = ids[browser.id.toLowerCase()];
+          if (app === "browserPrivate") {
+            if (browserName === "safari") {
+              throw new Error("Safari doesn't support opening in private mode via command line");
+            }
+            appArguments.push(flags[browserName]);
+          }
+          return baseOpen({
+            ...options,
+            app: {
+              name: apps[browserName],
+              arguments: appArguments
+            }
+          });
+        }
+        throw new Error(`${browser.name} is not supported as a default browser`);
+      }
+      let command;
+      const cliArguments = [];
+      const childProcessOptions = {};
+      let shouldUseWindowsInWsl = false;
+      if (is_wsl_default && !isInsideContainer() && !is_in_ssh_default && !app) {
+        shouldUseWindowsInWsl = await canAccessPowerShell();
+      }
+      if (platform2 === "darwin") {
+        command = "open";
+        if (options.wait) {
+          cliArguments.push("--wait-apps");
+        }
+        if (options.background) {
+          cliArguments.push("--background");
+        }
+        if (options.newInstance) {
+          cliArguments.push("--new");
+        }
+        if (app) {
+          cliArguments.push("-a", app);
+        }
+      } else if (platform2 === "win32" || shouldUseWindowsInWsl) {
+        command = await powerShellPath2();
+        cliArguments.push(...executePowerShell.argumentsPrefix);
+        if (!is_wsl_default) {
+          childProcessOptions.windowsVerbatimArguments = true;
+        }
+        if (is_wsl_default && options.target) {
+          options.target = await convertWslPathToWindows(options.target);
+        }
+        const encodedArguments = ["$ProgressPreference = 'SilentlyContinue';", "Start"];
+        if (options.wait) {
+          encodedArguments.push("-Wait");
+        }
+        if (app) {
+          encodedArguments.push(executePowerShell.escapeArgument(app));
+          if (options.target) {
+            appArguments.push(options.target);
+          }
+        } else if (options.target) {
+          encodedArguments.push(executePowerShell.escapeArgument(options.target));
+        }
+        if (appArguments.length > 0) {
+          appArguments = appArguments.map((argument) => executePowerShell.escapeArgument(argument));
+          encodedArguments.push("-ArgumentList", appArguments.join(","));
+        }
+        options.target = executePowerShell.encodeCommand(encodedArguments.join(" "));
+        if (!options.wait) {
+          childProcessOptions.stdio = "ignore";
+        }
+      } else {
+        if (app) {
+          command = app;
+        } else {
+          const isBundled = !__dirname || __dirname === "/";
+          let exeLocalXdgOpen = false;
+          try {
+            await fs6.access(localXdgOpenPath, fsConstants3.X_OK);
+            exeLocalXdgOpen = true;
+          } catch {
+          }
+          const useSystemXdgOpen = process8.versions.electron ?? (platform2 === "android" || isBundled || !exeLocalXdgOpen);
+          command = useSystemXdgOpen ? "xdg-open" : localXdgOpenPath;
+        }
+        if (appArguments.length > 0) {
+          cliArguments.push(...appArguments);
+        }
+        if (!options.wait) {
+          childProcessOptions.stdio = "ignore";
+          childProcessOptions.detached = true;
+        }
+      }
+      if (platform2 === "darwin" && appArguments.length > 0) {
+        cliArguments.push("--args", ...appArguments);
+      }
+      if (options.target) {
+        cliArguments.push(options.target);
+      }
+      const subprocess = childProcess3.spawn(command, cliArguments, childProcessOptions);
+      if (options.wait) {
+        return new Promise((resolve, reject) => {
+          subprocess.once("error", reject);
+          subprocess.once("close", (exitCode) => {
+            if (!options.allowNonzeroExitCode && exitCode !== 0) {
+              reject(new Error(`Exited with code ${exitCode}`));
+              return;
+            }
+            resolve(subprocess);
+          });
+        });
+      }
+      if (isFallbackAttempt) {
+        return new Promise((resolve, reject) => {
+          subprocess.once("error", reject);
+          subprocess.once("spawn", () => {
+            subprocess.once("close", (exitCode) => {
+              subprocess.off("error", reject);
+              if (exitCode !== 0) {
+                reject(new Error(`Exited with code ${exitCode}`));
+                return;
+              }
+              subprocess.unref();
+              resolve(subprocess);
+            });
+          });
+        });
+      }
+      subprocess.unref();
+      return new Promise((resolve, reject) => {
+        subprocess.once("error", reject);
+        subprocess.once("spawn", () => {
+          subprocess.off("error", reject);
+          resolve(subprocess);
+        });
+      });
+    };
+    open = (target, options) => {
+      if (typeof target !== "string") {
+        throw new TypeError("Expected a `target`");
+      }
+      return baseOpen({
+        ...options,
+        target
+      });
+    };
+    openApp = (name, options) => {
+      if (typeof name !== "string" && !Array.isArray(name)) {
+        throw new TypeError("Expected a valid `name`");
+      }
+      const { arguments: appArguments = [] } = options ?? {};
+      if (appArguments !== void 0 && appArguments !== null && !Array.isArray(appArguments)) {
+        throw new TypeError("Expected `appArguments` as Array type");
+      }
+      return baseOpen({
+        ...options,
+        app: {
+          name,
+          arguments: appArguments
+        }
+      });
+    };
+    apps = {
+      browser: "browser",
+      browserPrivate: "browserPrivate"
+    };
+    defineLazyProperty(apps, "chrome", () => detectPlatformBinary({
+      darwin: "google chrome",
+      win32: "chrome",
+      // `chromium-browser` is the older deb package name used by Ubuntu/Debian before snap.
+      linux: ["google-chrome", "google-chrome-stable", "chromium", "chromium-browser"]
+    }, {
+      wsl: {
+        ia32: "/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe",
+        x64: ["/mnt/c/Program Files/Google/Chrome/Application/chrome.exe", "/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe"]
+      }
+    }));
+    defineLazyProperty(apps, "brave", () => detectPlatformBinary({
+      darwin: "brave browser",
+      win32: "brave",
+      linux: ["brave-browser", "brave"]
+    }, {
+      wsl: {
+        ia32: "/mnt/c/Program Files (x86)/BraveSoftware/Brave-Browser/Application/brave.exe",
+        x64: ["/mnt/c/Program Files/BraveSoftware/Brave-Browser/Application/brave.exe", "/mnt/c/Program Files (x86)/BraveSoftware/Brave-Browser/Application/brave.exe"]
+      }
+    }));
+    defineLazyProperty(apps, "firefox", () => detectPlatformBinary({
+      darwin: "firefox",
+      win32: String.raw`C:\Program Files\Mozilla Firefox\firefox.exe`,
+      linux: "firefox"
+    }, {
+      wsl: "/mnt/c/Program Files/Mozilla Firefox/firefox.exe"
+    }));
+    defineLazyProperty(apps, "edge", () => detectPlatformBinary({
+      darwin: "microsoft edge",
+      win32: "msedge",
+      linux: ["microsoft-edge", "microsoft-edge-dev"]
+    }, {
+      wsl: "/mnt/c/Program Files (x86)/Microsoft/Edge/Application/msedge.exe"
+    }));
+    defineLazyProperty(apps, "safari", () => detectPlatformBinary({
+      darwin: "Safari"
+    }));
+    open_default = open;
+  }
+});
 
-// ../../src/cli/index.ts
+// src/index.ts
+import { readFileSync as readFileSync3 } from "fs";
 import { readFile as readFile2 } from "fs/promises";
-import { extname } from "path";
+import { dirname, extname, join as join3 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 import { config as loadEnv } from "dotenv";
 import { Command } from "commander";
+import { ConvexHttpClient as ConvexHttpClient3 } from "convex/browser";
 import { makeFunctionReference } from "convex/server";
 
 // ../../convex/_generated/api.js
@@ -12,7 +750,7 @@ import { anyApi, componentsGeneric } from "convex/server";
 var api = anyApi;
 var components = componentsGeneric();
 
-// ../../src/cli/auth.ts
+// src/auth.ts
 import { isCancel, password as passwordPrompt, text } from "@clack/prompts";
 function buildUrl(appUrl, pathname) {
   return new URL(pathname, appUrl).toString();
@@ -52,6 +790,9 @@ function applySetCookieHeaders(session, response) {
 async function authRequest(session, appUrl, pathname, init = {}) {
   const headers = new Headers(init.headers);
   const origin = new URL(appUrl).origin;
+  if (session.bearerToken && !headers.has("authorization")) {
+    headers.set("authorization", `Bearer ${session.bearerToken}`);
+  }
   if (Object.keys(session.cookies).length > 0) {
     headers.set("cookie", cookieHeader(session.cookies));
   }
@@ -146,7 +887,7 @@ async function fetchAuthSession(session, appUrl) {
   const data = await response.json();
   return {
     session: nextSession,
-    user: data.user ?? null
+    user: data?.user ?? null
   };
 }
 async function fetchConvexToken(session, appUrl) {
@@ -170,6 +911,65 @@ async function fetchConvexToken(session, appUrl) {
     token: data.token
   };
 }
+async function requestDeviceCode(appUrl, clientId) {
+  const response = await fetch(buildUrl(appUrl, "/api/auth/device/code"), {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ client_id: clientId })
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to request device code: HTTP ${response.status}`);
+  }
+  return await response.json();
+}
+async function pollDeviceToken(session, appUrl, deviceCode, clientId, interval, expiresIn) {
+  const deadline = Date.now() + expiresIn * 1e3;
+  let pollInterval = interval * 1e3;
+  while (Date.now() < deadline) {
+    await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    const { response, session: nextSession } = await authRequest(
+      session,
+      appUrl,
+      "/api/auth/device/token",
+      {
+        method: "POST",
+        body: JSON.stringify({
+          grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+          device_code: deviceCode,
+          client_id: clientId
+        })
+      }
+    );
+    session = nextSession;
+    if (response.ok) {
+      const data = await response.json();
+      if (data.access_token) {
+        session.bearerToken = data.access_token;
+        return session;
+      }
+    }
+    let errorData;
+    try {
+      errorData = await response.json();
+    } catch {
+      errorData = { error: `HTTP ${response.status}` };
+    }
+    switch (errorData.error) {
+      case "authorization_pending":
+        break;
+      case "slow_down":
+        pollInterval += 5e3;
+        break;
+      case "access_denied":
+        throw new Error("Authorization denied by user.");
+      case "expired_token":
+        throw new Error("Device code expired. Please try again.");
+      default:
+        throw new Error(`Device auth error: ${errorData.error}`);
+    }
+  }
+  throw new Error("Device code expired. Please try again.");
+}
 async function prompt(question) {
   const value = await text({
     message: question.replace(/:\s*$/, "")
@@ -190,7 +990,7 @@ async function promptSecret(question) {
   return String(value);
 }
 
-// ../../src/cli/convex.ts
+// src/convex.ts
 import { ConvexHttpClient } from "convex/browser";
 async function createConvexClient(session, appUrl, convexUrl) {
   const { token } = await fetchConvexToken(session, appUrl);
@@ -208,7 +1008,7 @@ async function runAction(client, ref, ...args) {
   return await client.action(ref, ...args);
 }
 
-// ../../src/cli/output.ts
+// src/output.ts
 function simplify(value) {
   if (value === null || value === void 0) {
     return value;
@@ -232,70 +1032,2393 @@ function printOutput(data, json = false) {
     console.log(JSON.stringify(data, null, 2));
     return;
   }
-  if (Array.isArray(data)) {
-    if (data.length === 0) {
-      console.log("No results.");
-      return;
+  if (Array.isArray(data)) {
+    if (data.length === 0) {
+      console.log("No results.");
+      return;
+    }
+    if (data.every((item) => typeof item === "object" && item !== null)) {
+      console.table(
+        data.map(
+          (item) => Object.fromEntries(
+            Object.entries(item).map(([key, value]) => [key, simplify(value)])
+          )
+        )
+      );
+      return;
+    }
+  }
+  if (typeof data === "object" && data !== null) {
+    console.dir(data, { depth: null, colors: true });
+    return;
+  }
+  console.log(String(data));
+}
+
+// src/session.ts
+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");
+    const parsed = JSON.parse(raw);
+    return {
+      version: 1,
+      cookies: {},
+      ...parsed
+    };
+  } catch {
+    return null;
+  }
+}
+async function writeSession(session, profile = "default") {
+  await mkdir(getSessionRoot(), { recursive: true });
+  await writeFile(
+    getSessionPath(profile),
+    `${JSON.stringify(session, null, 2)}
+`,
+    "utf8"
+  );
+}
+async function clearSession(profile = "default") {
+  await rm(getSessionPath(profile), { force: true });
+}
+function createEmptySession() {
+  return {
+    version: 1,
+    cookies: {}
+  };
+}
+
+// src/bridge-service.ts
+import { ConvexHttpClient as ConvexHttpClient2 } from "convex/browser";
+import { execFileSync, 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 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";
+}
+function ts() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(11, 19);
+}
+function findPort(start = 9100) {
+  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 : start;
+      srv.close(() => resolve(port));
+    });
+    srv.on("error", reject);
+  });
+}
+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) {
+    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,
+            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, cols, rows) {
+    if (this.terminals.has(workSessionId)) return;
+    const tmuxBin = findTmuxPath();
+    try {
+      const port = await findPort();
+      console.log(
+        `[${ts()}] Spawning PTY: ${tmuxBin} attach-session -t ${tmuxSessionName}`
+      );
+      const ptyProcess = pty.spawn(
+        tmuxBin,
+        ["attach-session", "-t", tmuxSessionName],
+        {
+          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 for ${tmuxSessionName}`);
+      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 WebSocket connection`);
+          ws.close(4401, "Unauthorized");
+          return;
+        }
+        console.log(
+          `[${ts()}] WebSocket 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()}] WebSocket client disconnected (${tmuxSessionName})`
+          );
+          dataHandler.dispose();
+        });
+      });
+      await new Promise((resolve) => {
+        httpServer.listen(port, "127.0.0.1", resolve);
+      });
+      console.log(`[${ts()}] WS server on port ${port}`);
+      console.log(`[${ts()}] Opening tunnel...`);
+      const tunnel = await localtunnel({ port });
+      const tunnelUrl = tunnel.url;
+      console.log(`[${ts()}] Tunnel: ${tunnelUrl}`);
+      const wsUrl = tunnelUrl.replace(/^https?:\/\//, "wss://");
+      const terminal = {
+        ptyProcess,
+        httpServer,
+        wss,
+        tunnel,
+        tunnelUrl: wsUrl,
+        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
+        }
+      );
+      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 {
+    }
+    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 existsSync3,
+  mkdirSync,
+  readFileSync as readFileSync2,
+  writeFileSync,
+  unlinkSync
+} from "fs";
+import { homedir as homedir3, hostname, platform } from "os";
+import { join as join2 } from "path";
+import { randomUUID as randomUUID2 } from "crypto";
+
+// src/agent-adapters.ts
+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()
+  ]);
+}
+async function resumeProviderSession(provider, sessionKey, cwd, prompt2) {
+  if (provider === "codex") {
+    return runCodexAppServerTurn({
+      cwd,
+      prompt: prompt2,
+      sessionKey,
+      launchCommand: "codex app-server (thread/resume)"
+    });
+  }
+  return runClaudeSdkTurn({
+    cwd,
+    prompt: prompt2,
+    sessionKey,
+    launchCommand: "@anthropic-ai/claude-agent-sdk query(resume)"
+  });
+}
+async function runCodexAppServerTurn(args) {
+  const child = spawn2("codex", ["app-server"], {
+    cwd: args.cwd,
+    env: { ...process.env },
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  let stderr = "";
+  let stdoutBuffer = "";
+  let sessionKey = args.sessionKey;
+  let finalAssistantText = "";
+  let completed = false;
+  let nextRequestId = 1;
+  const pending = /* @__PURE__ */ new Map();
+  let completeTurn;
+  let failTurn;
+  const turnCompleted = new Promise((resolve, reject) => {
+    completeTurn = () => {
+      completed = true;
+      resolve();
+    };
+    failTurn = (error) => {
+      completed = true;
+      reject(error);
+    };
+  });
+  child.stdout.on("data", (chunk) => {
+    stdoutBuffer += chunk.toString();
+    while (true) {
+      const newlineIndex = stdoutBuffer.indexOf("\n");
+      if (newlineIndex < 0) {
+        break;
+      }
+      const line = stdoutBuffer.slice(0, newlineIndex).trim();
+      stdoutBuffer = stdoutBuffer.slice(newlineIndex + 1);
+      if (!line) {
+        continue;
+      }
+      const payload = tryParseJson(line);
+      if (!payload || typeof payload !== "object") {
+        continue;
+      }
+      const responseId = payload.id;
+      if (typeof responseId === "number" && pending.has(responseId)) {
+        const entry = pending.get(responseId);
+        pending.delete(responseId);
+        const errorRecord = asObject(payload.error);
+        if (errorRecord) {
+          entry.reject(
+            new Error(
+              `codex app-server error: ${asString(errorRecord.message) ?? "Unknown JSON-RPC error"}`
+            )
+          );
+          continue;
+        }
+        entry.resolve(payload.result);
+        continue;
+      }
+      const method = asString(payload.method);
+      const params = asObject(payload.params);
+      if (!method || !params) {
+        continue;
+      }
+      if (method === "thread/started") {
+        sessionKey = asString(asObject(params.thread)?.id) ?? asString(asObject(params.thread)?.threadId) ?? sessionKey;
+        continue;
+      }
+      if (method === "item/agentMessage/delta") {
+        finalAssistantText += asString(params.delta) ?? "";
+        continue;
+      }
+      if (method === "item/completed") {
+        const item = asObject(params.item);
+        if (asString(item?.type) === "agentMessage") {
+          finalAssistantText = asString(item?.text) ?? finalAssistantText;
+        }
+        continue;
+      }
+      if (method === "turn/completed") {
+        const turn = asObject(params.turn);
+        const status = asString(turn?.status);
+        if (status === "failed") {
+          const turnError = asObject(turn?.error);
+          failTurn?.(
+            new Error(
+              asString(turnError?.message) ?? "Codex turn failed without an error message"
+            )
+          );
+        } else if (status === "interrupted") {
+          failTurn?.(new Error("Codex turn was interrupted"));
+        } else {
+          completeTurn?.();
+        }
+      }
+    }
+  });
+  child.stderr.on("data", (chunk) => {
+    stderr += chunk.toString();
+  });
+  const request = (method, params) => new Promise((resolve, reject) => {
+    const id = nextRequestId++;
+    pending.set(id, { resolve, reject });
+    child.stdin.write(`${JSON.stringify({ method, id, params })}
+`);
+  });
+  const notify = (method, params) => {
+    child.stdin.write(`${JSON.stringify({ method, params })}
+`);
+  };
+  const waitForExit = new Promise((_, reject) => {
+    child.on("error", (error) => reject(error));
+    child.on("close", (code) => {
+      if (!completed) {
+        const detail = stderr.trim() || `codex app-server exited with code ${code}`;
+        reject(new Error(detail));
+      }
+    });
+  });
+  try {
+    await Promise.race([
+      request("initialize", {
+        clientInfo: {
+          name: "vector_bridge",
+          title: "Vector Bridge",
+          version: VECTOR_BRIDGE_CLIENT_VERSION
+        }
+      }),
+      waitForExit
+    ]);
+    notify("initialized", {});
+    const threadResult = await Promise.race([
+      args.sessionKey ? request("thread/resume", {
+        threadId: args.sessionKey,
+        cwd: args.cwd,
+        approvalPolicy: "never",
+        personality: "pragmatic"
+      }) : request("thread/start", {
+        cwd: args.cwd,
+        approvalPolicy: "never",
+        personality: "pragmatic",
+        serviceName: "vector_bridge"
+      }),
+      waitForExit
+    ]);
+    sessionKey = asString(asObject(threadResult.thread)?.id) ?? asString(asObject(threadResult.thread)?.threadId) ?? sessionKey;
+    if (!sessionKey) {
+      throw new Error("Codex app-server did not return a thread id");
+    }
+    await Promise.race([
+      request("turn/start", {
+        threadId: sessionKey,
+        input: [{ type: "text", text: args.prompt }],
+        cwd: args.cwd,
+        approvalPolicy: "never",
+        personality: "pragmatic"
+      }),
+      waitForExit
+    ]);
+    await Promise.race([turnCompleted, waitForExit]);
+    const gitInfo = getGitInfo(args.cwd);
+    return {
+      provider: "codex",
+      providerLabel: "Codex",
+      sessionKey,
+      cwd: args.cwd,
+      ...gitInfo,
+      title: summarizeTitle(void 0, args.cwd),
+      mode: "managed",
+      status: "waiting",
+      supportsInboundMessages: true,
+      responseText: finalAssistantText.trim() || void 0,
+      launchCommand: args.launchCommand
+    };
+  } finally {
+    for (const entry of pending.values()) {
+      entry.reject(
+        new Error("codex app-server closed before request resolved")
+      );
+    }
+    pending.clear();
+    child.kill();
+  }
+}
+async function runClaudeSdkTurn(args) {
+  const { query } = await import("@anthropic-ai/claude-agent-sdk");
+  const stream = query({
+    prompt: args.prompt,
+    options: {
+      cwd: args.cwd,
+      resume: args.sessionKey,
+      persistSession: true,
+      permissionMode: "bypassPermissions",
+      allowDangerouslySkipPermissions: true,
+      env: {
+        ...process.env,
+        CLAUDE_AGENT_SDK_CLIENT_APP: `vector-bridge/${VECTOR_BRIDGE_CLIENT_VERSION}`
+      }
+    }
+  });
+  let sessionKey = args.sessionKey;
+  let responseText = "";
+  let model;
+  try {
+    for await (const message of stream) {
+      if (!message || typeof message !== "object") {
+        continue;
+      }
+      sessionKey = asString(message.session_id) ?? sessionKey;
+      if (message.type === "assistant") {
+        const assistantText = extractClaudeMessageTexts(
+          message.message
+        ).join("\n\n").trim();
+        if (assistantText) {
+          responseText = assistantText;
+        }
+        continue;
+      }
+      if (message.type !== "result") {
+        continue;
+      }
+      if (message.subtype === "success") {
+        const resultText = asString(message.result);
+        if (resultText) {
+          responseText = resultText;
+        }
+        model = firstObjectKey(
+          message.modelUsage
+        );
+        continue;
+      }
+      const errors = message.errors;
+      const detail = Array.isArray(errors) && errors.length > 0 ? errors.join("\n") : "Claude execution failed";
+      throw new Error(detail);
+    }
+  } finally {
+    stream.close();
+  }
+  if (!sessionKey) {
+    throw new Error("Claude Agent SDK did not return a session id");
+  }
+  const gitInfo = getGitInfo(args.cwd);
+  return {
+    provider: "claude_code",
+    providerLabel: "Claude",
+    sessionKey,
+    cwd: args.cwd,
+    ...gitInfo,
+    title: summarizeTitle(void 0, args.cwd),
+    model,
+    mode: "managed",
+    status: "waiting",
+    supportsInboundMessages: true,
+    responseText: responseText.trim() || void 0,
+    launchCommand: args.launchCommand
+  };
+}
+function discoverCodexSessions() {
+  const historyBySession = buildCodexHistoryIndex();
+  return listLiveProcessIds("codex").flatMap((pid) => {
+    const transcriptPath = getCodexTranscriptPath(pid);
+    if (!transcriptPath) {
+      return [];
+    }
+    const processCwd = getProcessCwd(pid);
+    const parsed = parseObservedCodexSession(
+      pid,
+      transcriptPath,
+      processCwd,
+      historyBySession
+    );
+    return parsed ? [parsed] : [];
+  }).sort(compareObservedSessions);
+}
+function discoverClaudeSessions() {
+  const historyBySession = buildClaudeHistoryIndex();
+  return listLiveProcessIds("claude").flatMap((pid) => {
+    const sessionMeta = readClaudePidSession(pid);
+    if (!sessionMeta?.sessionId) {
+      return [];
+    }
+    const transcriptPath = findClaudeTranscriptPath(sessionMeta.sessionId);
+    const parsed = parseObservedClaudeSession(
+      pid,
+      sessionMeta,
+      transcriptPath,
+      historyBySession
+    );
+    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");
+}
+function getClaudeProjectsDir() {
+  return join(getRealHomeDir(), ".claude", "projects");
+}
+function getClaudeSessionStateDir() {
+  return join(getRealHomeDir(), ".claude", "sessions");
+}
+function getClaudeHistoryFile() {
+  return join(getRealHomeDir(), ".claude", "history.jsonl");
+}
+function getRealHomeDir() {
+  try {
+    const realHome = userInfo().homedir?.trim();
+    if (realHome) {
+      return realHome;
+    }
+  } catch {
+  }
+  return homedir2();
+}
+function resolveExecutable(fallbackCommand, absoluteCandidates) {
+  for (const candidate of absoluteCandidates) {
+    if (existsSync2(candidate)) {
+      return candidate;
+    }
+  }
+  try {
+    const output = execSync(`command -v ${fallbackCommand}`, {
+      encoding: "utf-8",
+      timeout: 1e3
+    }).trim();
+    return output || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function listLiveProcessIds(commandName) {
+  try {
+    const output = execSync("ps -axo pid=,comm=", {
+      encoding: "utf-8",
+      timeout: 3e3
+    });
+    return output.split("\n").map((line) => line.trim()).filter(Boolean).map((line) => line.split(/\s+/, 2)).filter(([, command]) => command === commandName).map(([pid]) => pid).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+function getProcessCwd(pid) {
+  const lsofCommand = resolveExecutable("lsof", LSOF_PATHS);
+  if (!lsofCommand) {
+    return void 0;
+  }
+  try {
+    const output = execSync(`${lsofCommand} -a -p ${pid} -Fn -d cwd`, {
+      encoding: "utf-8",
+      timeout: 3e3
+    });
+    return output.split("\n").map((line) => line.trim()).find((line) => line.startsWith("n"))?.slice(1);
+  } catch {
+    return void 0;
+  }
+}
+function getCodexTranscriptPath(pid) {
+  const lsofCommand = resolveExecutable("lsof", LSOF_PATHS);
+  if (!lsofCommand) {
+    return void 0;
+  }
+  try {
+    const output = execSync(`${lsofCommand} -p ${pid} -Fn`, {
+      encoding: "utf-8",
+      timeout: 3e3
+    });
+    return output.split("\n").map((line) => line.trim()).find(
+      (line) => line.startsWith("n") && line.includes("/.codex/sessions/") && line.endsWith(".jsonl")
+    )?.slice(1);
+  } catch {
+    return void 0;
+  }
+}
+function readClaudePidSession(pid) {
+  const path3 = join(getClaudeSessionStateDir(), `${pid}.json`);
+  if (!existsSync2(path3)) {
+    return null;
+  }
+  try {
+    const payload = JSON.parse(readFileSync(path3, "utf-8"));
+    const sessionId = asString(payload.sessionId);
+    if (!sessionId) {
+      return null;
+    }
+    return {
+      sessionId,
+      cwd: asString(payload.cwd),
+      startedAt: typeof payload.startedAt === "number" ? payload.startedAt : void 0
+    };
+  } catch {
+    return null;
+  }
+}
+function findClaudeTranscriptPath(sessionId) {
+  return findJsonlFileByStem(getClaudeProjectsDir(), sessionId);
+}
+function findJsonlFileByStem(root, stem) {
+  if (!existsSync2(root)) {
+    return void 0;
+  }
+  for (const entry of readdirSync(root, { withFileTypes: true })) {
+    const path3 = join(root, entry.name);
+    if (entry.isDirectory()) {
+      const nested = findJsonlFileByStem(path3, stem);
+      if (nested) {
+        return nested;
+      }
+      continue;
+    }
+    if (entry.isFile() && entry.name === `${stem}.jsonl`) {
+      return path3;
+    }
+  }
+  return void 0;
+}
+function readJsonLines(path3) {
+  try {
+    return readFileSync(path3, "utf-8").split("\n").map((line) => line.trim()).filter(Boolean).map(tryParseJson).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+function tryParseJson(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return null;
+  }
+}
+function dedupeSessions(sessions) {
+  const seen = /* @__PURE__ */ new Set();
+  return sessions.filter((session) => {
+    const key = `${session.provider}:${session.localProcessId ?? session.sessionKey}`;
+    if (seen.has(key)) {
+      return false;
+    }
+    seen.add(key);
+    return true;
+  });
+}
+function compareObservedSessions(a, b) {
+  return Number(b.localProcessId ?? 0) - Number(a.localProcessId ?? 0);
+}
+function parseObservedCodexSession(pid, transcriptPath, processCwd, historyBySession) {
+  const entries = readJsonLines(transcriptPath);
+  let sessionKey;
+  let cwd = processCwd;
+  const userMessages = [];
+  const assistantMessages = [];
+  for (const rawEntry of entries) {
+    const entry = asObject(rawEntry);
+    if (!entry) {
+      continue;
+    }
+    if (entry.type === "session_meta") {
+      const payload = asObject(entry.payload);
+      sessionKey = asString(payload?.id) ?? sessionKey;
+      cwd = asString(payload?.cwd) ?? cwd;
+    }
+    if (entry.type === "event_msg") {
+      const payload = asObject(entry.payload);
+      if (payload?.type === "user_message") {
+        pushIfPresent(userMessages, payload.message);
+      }
+    }
+    if (entry.type === "response_item" && asObject(entry.payload)?.type === "message" && asObject(entry.payload)?.role === "user") {
+      userMessages.push(
+        ...extractTextSegments(asObject(entry.payload)?.content)
+      );
+    }
+    if (entry.type === "event_msg") {
+      const payload = asObject(entry.payload);
+      if (payload?.type === "agent_message") {
+        pushIfPresent(assistantMessages, payload.message);
+      }
+    }
+    if (entry.type === "response_item" && asObject(entry.payload)?.type === "message" && asObject(entry.payload)?.role === "assistant") {
+      assistantMessages.push(
+        ...extractTextSegments(asObject(entry.payload)?.content)
+      );
+    }
+  }
+  if (!sessionKey) {
+    return null;
+  }
+  const gitInfo = cwd ? getGitInfo(cwd) : {};
+  const historyTitle = sessionKey ? selectSessionTitle(historyBySession?.get(sessionKey) ?? []) : void 0;
+  return {
+    provider: "codex",
+    providerLabel: "Codex",
+    localProcessId: pid,
+    sessionKey,
+    cwd,
+    ...gitInfo,
+    title: summarizeTitle(
+      historyTitle ?? selectSessionTitle(userMessages) ?? selectSessionTitle(assistantMessages),
+      cwd
+    ),
+    mode: "observed",
+    status: "observed",
+    supportsInboundMessages: true
+  };
+}
+function parseObservedClaudeSession(pid, sessionMeta, transcriptPath, historyBySession) {
+  const entries = transcriptPath ? readJsonLines(transcriptPath) : [];
+  let cwd = sessionMeta.cwd;
+  let branch;
+  let model;
+  const userMessages = [];
+  const assistantMessages = [];
+  for (const rawEntry of entries) {
+    const entry = asObject(rawEntry);
+    if (!entry) {
+      continue;
+    }
+    cwd = asString(entry.cwd) ?? cwd;
+    branch = asString(entry.gitBranch) ?? branch;
+    if (entry.type === "user") {
+      userMessages.push(...extractClaudeMessageTexts(entry.message));
+    }
+    if (entry.type === "assistant") {
+      const message = asObject(entry.message);
+      model = asString(message?.model) ?? model;
+      assistantMessages.push(...extractClaudeMessageTexts(entry.message));
+    }
+  }
+  const gitInfo = cwd ? getGitInfo(cwd) : {};
+  const historyTitle = selectSessionTitle(
+    historyBySession?.get(sessionMeta.sessionId) ?? []
+  );
+  return {
+    provider: "claude_code",
+    providerLabel: "Claude",
+    localProcessId: pid,
+    sessionKey: sessionMeta.sessionId,
+    cwd,
+    repoRoot: gitInfo.repoRoot,
+    branch: branch ?? gitInfo.branch,
+    title: summarizeTitle(
+      historyTitle ?? selectSessionTitle(userMessages) ?? selectSessionTitle(assistantMessages),
+      cwd
+    ),
+    model,
+    mode: "observed",
+    status: "observed",
+    supportsInboundMessages: true
+  };
+}
+function summarizeTitle(message, cwd) {
+  if (message) {
+    return truncate(message.replace(/\s+/g, " ").trim(), 96);
+  }
+  if (cwd) {
+    return basename(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;
+}
+function firstObjectKey(value) {
+  if (!value || typeof value !== "object") {
+    return void 0;
+  }
+  const [firstKey] = Object.keys(value);
+  return firstKey ? normalizeModelKey(firstKey) : void 0;
+}
+function normalizeModelKey(value) {
+  const normalized = stripAnsi(value).replace(/\[\d+(?:;\d+)*m$/g, "").trim();
+  return normalized || void 0;
+}
+function asObject(value) {
+  return value && typeof value === "object" ? value : void 0;
+}
+function asString(value) {
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+function pushIfPresent(target, value) {
+  const text2 = asString(value);
+  if (text2) {
+    target.push(text2);
+  }
+}
+function extractClaudeMessageTexts(message) {
+  if (!message || typeof message !== "object") {
+    return [];
+  }
+  return extractTextSegments(message.content);
+}
+function extractTextSegments(value) {
+  if (typeof value === "string") {
+    return [value];
+  }
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.flatMap(extractTextSegmentFromBlock).filter(Boolean);
+}
+function extractTextSegmentFromBlock(block) {
+  if (!block || typeof block !== "object") {
+    return [];
+  }
+  const typedBlock = block;
+  const blockType = asString(typedBlock.type);
+  if (blockType && isIgnoredContentBlockType(blockType)) {
+    return [];
+  }
+  const directText = asString(typedBlock.text);
+  if (directText) {
+    return [directText];
+  }
+  if (typeof typedBlock.content === "string") {
+    return [typedBlock.content];
+  }
+  return [];
+}
+function isIgnoredContentBlockType(blockType) {
+  return [
+    "tool_result",
+    "tool_use",
+    "image",
+    "thinking",
+    "reasoning",
+    "contextCompaction"
+  ].includes(blockType);
+}
+function buildCodexHistoryIndex() {
+  const historyBySession = /* @__PURE__ */ new Map();
+  for (const rawEntry of readJsonLines(getCodexHistoryFile())) {
+    const entry = asObject(rawEntry);
+    if (!entry) {
+      continue;
+    }
+    const sessionId = asString(entry.session_id);
+    const text2 = asString(entry.text);
+    if (!sessionId || !text2) {
+      continue;
+    }
+    appendHistoryEntry(historyBySession, sessionId, text2);
+  }
+  return historyBySession;
+}
+function buildClaudeHistoryIndex() {
+  const historyBySession = /* @__PURE__ */ new Map();
+  for (const rawEntry of readJsonLines(getClaudeHistoryFile())) {
+    const entry = asObject(rawEntry);
+    if (!entry) {
+      continue;
+    }
+    const sessionId = asString(entry.sessionId);
+    if (!sessionId) {
+      continue;
+    }
+    const texts = extractClaudeHistoryTexts(entry);
+    for (const text2 of texts) {
+      appendHistoryEntry(historyBySession, sessionId, text2);
+    }
+  }
+  return historyBySession;
+}
+function appendHistoryEntry(historyBySession, sessionId, text2) {
+  const existing = historyBySession.get(sessionId);
+  if (existing) {
+    existing.push(text2);
+    return;
+  }
+  historyBySession.set(sessionId, [text2]);
+}
+function extractClaudeHistoryTexts(entry) {
+  if (!entry || typeof entry !== "object") {
+    return [];
+  }
+  const record = entry;
+  const pastedTexts = extractClaudePastedTexts(record.pastedContents);
+  if (pastedTexts.length > 0) {
+    return pastedTexts;
+  }
+  const display = asString(record.display);
+  return display ? [display] : [];
+}
+function extractClaudePastedTexts(value) {
+  if (!value || typeof value !== "object") {
+    return [];
+  }
+  return Object.values(value).flatMap((item) => {
+    if (!item || typeof item !== "object") {
+      return [];
+    }
+    const record = item;
+    return record.type === "text" && typeof record.content === "string" ? [record.content] : [];
+  }).filter(Boolean);
+}
+function selectSessionTitle(messages) {
+  for (const message of messages) {
+    const cleaned = cleanSessionTitleCandidate(message);
+    if (cleaned) {
+      return cleaned;
+    }
+  }
+  return void 0;
+}
+function cleanSessionTitleCandidate(message) {
+  const normalized = stripAnsi(message).replace(/\s+/g, " ").trim();
+  if (!normalized) {
+    return void 0;
+  }
+  if (normalized.length < 4) {
+    return void 0;
+  }
+  if (normalized.startsWith("/") || looksLikeGeneratedTagEnvelope(normalized) || looksLikeGeneratedImageSummary(normalized) || looksLikeStandaloneImagePath(normalized) || looksLikeInstructionScaffold(normalized)) {
+    return void 0;
+  }
+  return normalized;
+}
+function looksLikeGeneratedTagEnvelope(value) {
+  return /^<[\w:-]+>[\s\S]*<\/[\w:-]+>$/.test(value);
+}
+function looksLikeGeneratedImageSummary(value) {
+  return /^\[image:/i.test(value) || /displayed at/i.test(value) && /coordinates/i.test(value);
+}
+function looksLikeStandaloneImagePath(value) {
+  return /^\/\S+\.(png|jpe?g|gif|webp|heic|bmp)$/i.test(value) || /^file:\S+\.(png|jpe?g|gif|webp|heic|bmp)$/i.test(value);
+}
+function looksLikeInstructionScaffold(value) {
+  if (value.length < 700) {
+    return false;
+  }
+  const headingCount = value.match(/^#{1,3}\s/gm)?.length ?? 0;
+  const tagCount = value.match(/<\/?[\w:-]+>/g)?.length ?? 0;
+  const bulletCount = value.match(/^\s*[-*]\s/gm)?.length ?? 0;
+  return headingCount + tagCount + bulletCount >= 6;
+}
+function stripAnsi(value) {
+  return value.replace(/\u001B\[[0-9;]*m/g, "");
+}
+function getGitInfo(cwd) {
+  try {
+    const repoRoot = execSync("git rev-parse --show-toplevel", {
+      encoding: "utf-8",
+      cwd,
+      timeout: 3e3
+    }).trim();
+    const branch = execSync("git rev-parse --abbrev-ref HEAD", {
+      encoding: "utf-8",
+      cwd,
+      timeout: 3e3
+    }).trim();
+    return {
+      repoRoot: repoRoot || void 0,
+      branch: branch || void 0
+    };
+  } catch {
+    return {};
+  }
+}
+
+// src/bridge-service.ts
+var CONFIG_DIR = process.env.VECTOR_HOME?.trim() || join2(homedir3(), ".vector");
+var BRIDGE_CONFIG_FILE = join2(CONFIG_DIR, "bridge.json");
+var DEVICE_KEY_FILE = join2(CONFIG_DIR, "device-key");
+var PID_FILE = join2(CONFIG_DIR, "bridge.pid");
+var LIVE_ACTIVITIES_CACHE = join2(CONFIG_DIR, "live-activities.json");
+var LAUNCHAGENT_DIR = join2(homedir3(), "Library", "LaunchAgents");
+var LAUNCHAGENT_PLIST = join2(LAUNCHAGENT_DIR, "com.vector.bridge.plist");
+var LAUNCHAGENT_LABEL = "com.vector.bridge";
+var LEGACY_MENUBAR_LAUNCHAGENT_LABEL = "com.vector.menubar";
+var LEGACY_MENUBAR_LAUNCHAGENT_PLIST = join2(
+  LAUNCHAGENT_DIR,
+  `${LEGACY_MENUBAR_LAUNCHAGENT_LABEL}.plist`
+);
+var HEARTBEAT_INTERVAL_MS = 3e4;
+var COMMAND_POLL_INTERVAL_MS = 5e3;
+var LIVE_ACTIVITY_SYNC_INTERVAL_MS = 5e3;
+var PROCESS_DISCOVERY_INTERVAL_MS = 6e4;
+function loadBridgeConfig() {
+  if (!existsSync3(BRIDGE_CONFIG_FILE)) return null;
+  try {
+    return JSON.parse(readFileSync2(BRIDGE_CONFIG_FILE, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function saveBridgeConfig(config) {
+  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 (!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);
+  }
+  async heartbeat() {
+    await this.client.mutation(api.agentBridge.bridgePublic.heartbeat, {
+      deviceId: this.config.deviceId,
+      deviceSecret: this.config.deviceSecret
+    });
+  }
+  async pollCommands() {
+    const commands = await this.client.query(
+      api.agentBridge.bridgePublic.getPendingCommands,
+      {
+        deviceId: this.config.deviceId,
+        deviceSecret: this.config.deviceSecret
+      }
+    );
+    if (commands.length > 0) {
+      console.log(`[${ts2()}] ${commands.length} pending command(s)`);
+    }
+    for (const cmd of commands) {
+      await this.handleCommand(cmd);
+    }
+  }
+  async handleCommand(cmd) {
+    const claimed = await this.client.mutation(
+      api.agentBridge.bridgePublic.claimCommand,
+      {
+        deviceId: this.config.deviceId,
+        deviceSecret: this.config.deviceSecret,
+        commandId: cmd._id
+      }
+    );
+    if (!claimed) {
+      return;
+    }
+    console.log(`  ${cmd.kind}: ${cmd._id}`);
+    try {
+      switch (cmd.kind) {
+        case "message":
+          await this.handleMessageCommand(cmd);
+          await this.completeCommand(cmd._id, "delivered");
+          return;
+        case "launch":
+          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}`);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown bridge error";
+      console.error(`  ! ${message}`);
+      await this.postCommandError(cmd, message);
+      await this.completeCommand(cmd._id, "failed");
+    }
+  }
+  async reportProcesses() {
+    const processes = discoverAttachableSessions();
+    const activeSessionKeys = processes.map((proc) => proc.sessionKey).filter((value) => Boolean(value));
+    const activeLocalProcessIds = processes.map((proc) => proc.localProcessId).filter((value) => Boolean(value));
+    for (const proc of processes) {
+      try {
+        await this.reportProcess(proc);
+      } catch {
+      }
+    }
+    try {
+      await this.client.mutation(
+        api.agentBridge.bridgePublic.reconcileObservedProcesses,
+        {
+          deviceId: this.config.deviceId,
+          deviceSecret: this.config.deviceSecret,
+          activeSessionKeys,
+          activeLocalProcessIds
+        }
+      );
+    } catch {
+    }
+    if (processes.length > 0) {
+      console.log(
+        `[${ts2()}] Discovered ${processes.length} attachable session(s)`
+      );
+    }
+  }
+  async refreshLiveActivities() {
+    try {
+      const activities = await this.client.query(
+        api.agentBridge.bridgePublic.getDeviceLiveActivities,
+        {
+          deviceId: this.config.deviceId,
+          deviceSecret: this.config.deviceSecret
+        }
+      );
+      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
+            );
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  async syncWorkSessionTerminals(activities) {
+    for (const activity of activities) {
+      if (!activity.workSessionId || !activity.tmuxPaneId) {
+        continue;
+      }
+      try {
+        await this.refreshWorkSessionTerminal(activity.workSessionId, {
+          tmuxPaneId: activity.tmuxPaneId,
+          cwd: activity.cwd,
+          repoRoot: activity.repoRoot,
+          branch: activity.branch,
+          agentProvider: activity.agentProvider,
+          agentSessionKey: activity.agentSessionKey
+        });
+        await this.verifyManagedWorkSession(activity);
+      } catch {
+      }
+    }
+  }
+  async verifyManagedWorkSession(activity) {
+    if (!activity.workSessionId || !activity.tmuxPaneId || !activity.agentProvider || !isBridgeProvider(activity.agentProvider) || activity.agentProcessId) {
+      return;
+    }
+    const workspacePath = activity.workspacePath ?? activity.cwd ?? activity.repoRoot;
+    if (!workspacePath) {
+      return;
+    }
+    const attachedSession = await this.attachObservedAgentSession(
+      activity.agentProvider,
+      workspacePath
+    );
+    if (!attachedSession) {
+      return;
+    }
+    await this.refreshWorkSessionTerminal(activity.workSessionId, {
+      tmuxPaneId: activity.tmuxPaneId,
+      cwd: attachedSession.process.cwd ?? activity.cwd ?? workspacePath,
+      repoRoot: attachedSession.process.repoRoot ?? activity.repoRoot ?? workspacePath,
+      branch: attachedSession.process.branch ?? activity.branch,
+      agentProvider: attachedSession.process.provider,
+      agentSessionKey: attachedSession.process.sessionKey
+    });
+    await this.postAgentMessage(
+      activity._id,
+      "status",
+      `Verified ${providerLabel(attachedSession.process.provider)} in ${activity.tmuxPaneId}`
+    );
+    await this.updateLiveActivity(activity._id, {
+      status: "waiting_for_input",
+      latestSummary: `Verified ${providerLabel(attachedSession.process.provider)} in ${activity.tmuxPaneId}`,
+      processId: attachedSession.processId,
+      title: activity.title
+    });
+  }
+  async refreshWorkSessionTerminal(workSessionId, metadata) {
+    if (!workSessionId || !metadata.tmuxPaneId) {
+      return;
+    }
+    const terminalSnapshot = captureTmuxPane(metadata.tmuxPaneId);
+    await this.client.mutation(
+      api.agentBridge.bridgePublic.updateWorkSessionTerminal,
+      {
+        deviceId: this.config.deviceId,
+        deviceSecret: this.config.deviceSecret,
+        workSessionId,
+        terminalSnapshot,
+        tmuxSessionName: metadata.tmuxSessionName,
+        tmuxWindowName: metadata.tmuxWindowName,
+        tmuxPaneId: metadata.tmuxPaneId,
+        cwd: metadata.cwd,
+        repoRoot: metadata.repoRoot,
+        branch: metadata.branch,
+        agentProvider: metadata.agentProvider,
+        agentSessionKey: metadata.agentSessionKey
+      }
+    );
+  }
+  async run() {
+    console.log("Vector Bridge Service");
+    console.log(
+      `  Device:  ${this.config.displayName} (${this.config.deviceId})`
+    );
+    console.log(`  Convex:  ${this.config.convexUrl}`);
+    console.log(`  PID:     ${process.pid}`);
+    console.log("");
+    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
+      });
+      console.log(`  WebRTC:  ready`);
+    } 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(`[${ts2()}] Service running. Ctrl+C to stop.
+`);
+    this.timers.push(
+      setInterval(() => {
+        this.heartbeat().catch(
+          (e) => console.error(`[${ts2()}] Heartbeat error:`, e.message)
+        );
+      }, HEARTBEAT_INTERVAL_MS)
+    );
+    this.timers.push(
+      setInterval(() => {
+        this.pollCommands().catch(
+          (e) => console.error(`[${ts2()}] Command poll error:`, e.message)
+        );
+      }, COMMAND_POLL_INTERVAL_MS)
+    );
+    this.timers.push(
+      setInterval(() => {
+        this.refreshLiveActivities().catch(
+          (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(`[${ts2()}] Discovery error:`, e.message)
+        );
+      }, PROCESS_DISCOVERY_INTERVAL_MS)
+    );
+    const shutdown = () => {
+      console.log(`
+[${ts2()}] Shutting down...`);
+      for (const t of this.timers) clearInterval(t);
+      this.terminalPeer?.stop();
+      try {
+        unlinkSync(PID_FILE);
+      } catch {
+      }
+      try {
+        writeLiveActivitiesCache([]);
+      } catch {
+      }
+      process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    await new Promise(() => {
+    });
+  }
+  async handleMessageCommand(cmd) {
+    if (!cmd.liveActivityId) {
+      throw new Error("Message command is missing liveActivityId");
+    }
+    const payload = cmd.payload;
+    const body = payload?.body?.trim();
+    if (!body) {
+      throw new Error("Message command is missing a body");
+    }
+    const process9 = cmd.process;
+    console.log(`  > "${truncateForLog(body)}"`);
+    if (cmd.workSession?.tmuxPaneId) {
+      sendTextToTmuxPane(cmd.workSession.tmuxPaneId, body);
+      const attachedSession = cmd.workSession.agentProvider && isBridgeProvider(cmd.workSession.agentProvider) ? await this.attachObservedAgentSession(
+        cmd.workSession.agentProvider,
+        cmd.workSession.workspacePath ?? cmd.workSession.cwd ?? process9?.cwd
+      ) : null;
+      await this.postAgentMessage(
+        cmd.liveActivityId,
+        "status",
+        "Sent input to work session terminal"
+      );
+      await this.refreshWorkSessionTerminal(cmd.workSession._id, {
+        tmuxSessionName: cmd.workSession.tmuxSessionName,
+        tmuxWindowName: cmd.workSession.tmuxWindowName,
+        tmuxPaneId: cmd.workSession.tmuxPaneId,
+        cwd: cmd.workSession.cwd,
+        repoRoot: cmd.workSession.repoRoot,
+        branch: cmd.workSession.branch,
+        agentProvider: attachedSession?.process.provider ?? cmd.workSession.agentProvider,
+        agentSessionKey: attachedSession?.process.sessionKey ?? cmd.workSession.agentSessionKey
+      });
+      await this.updateLiveActivity(cmd.liveActivityId, {
+        status: "waiting_for_input",
+        latestSummary: `Input sent to ${cmd.workSession.tmuxPaneId}`,
+        title: cmd.liveActivity?.title,
+        processId: attachedSession?.processId ?? process9?._id
+      });
+      return;
+    }
+    if (!process9 || !process9.supportsInboundMessages || !process9.sessionKey || !process9.cwd || !isBridgeProvider(process9.provider)) {
+      throw new Error("No resumable local session is attached to this issue");
+    }
+    await this.reportProcess({
+      provider: process9.provider,
+      providerLabel: process9.providerLabel ?? providerLabel(process9.provider),
+      sessionKey: process9.sessionKey,
+      cwd: process9.cwd,
+      repoRoot: process9.repoRoot,
+      branch: process9.branch,
+      title: process9.title,
+      model: process9.model,
+      mode: "managed",
+      status: "waiting",
+      supportsInboundMessages: true
+    });
+    await this.updateLiveActivity(cmd.liveActivityId, {
+      status: "active",
+      processId: process9._id,
+      title: cmd.liveActivity?.title ?? process9.title
+    });
+    const result = await resumeProviderSession(
+      process9.provider,
+      process9.sessionKey,
+      process9.cwd,
+      body
+    );
+    const processId = await this.reportProcess(result);
+    if (result.responseText) {
+      await this.postAgentMessage(
+        cmd.liveActivityId,
+        "assistant",
+        result.responseText
+      );
+      console.log(`  < "${truncateForLog(result.responseText)}"`);
+    }
+    await this.updateLiveActivity(cmd.liveActivityId, {
+      processId,
+      status: "waiting_for_input",
+      latestSummary: summarizeMessage(result.responseText),
+      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");
+    }
+    const payload = cmd.payload;
+    const workspacePath = payload?.workspacePath?.trim();
+    if (!workspacePath) {
+      throw new Error("Launch command is missing workspacePath");
+    }
+    const requestedProvider = payload?.provider;
+    const provider = requestedProvider && isBridgeProvider(requestedProvider) ? requestedProvider : void 0;
+    const issueKey = payload?.issueKey ?? cmd.liveActivity?.issueKey ?? "ISSUE";
+    const issueTitle = payload?.issueTitle ?? cmd.liveActivity?.issueTitle ?? "Untitled issue";
+    const prompt2 = buildLaunchPrompt(issueKey, issueTitle, workspacePath);
+    const launchLabel = provider ? providerLabel(provider) : "shell session";
+    const workSessionTitle = `${issueKey}: ${issueTitle}`;
+    const sessionsBeforeLaunch = provider ? listObservedSessionsForWorkspace(provider, workspacePath) : [];
+    await this.updateLiveActivity(cmd.liveActivityId, {
+      status: "active",
+      latestSummary: `Launching ${launchLabel} in ${workspacePath}`,
+      delegatedRunId: payload?.delegatedRunId,
+      launchStatus: "launching",
+      title: workSessionTitle
+    });
+    await this.postAgentMessage(
+      cmd.liveActivityId,
+      "status",
+      `Launching ${launchLabel} in ${workspacePath}`
+    );
+    const tmuxSession = createTmuxWorkSession({
+      workspacePath,
+      issueKey,
+      issueTitle,
+      provider,
+      prompt: prompt2
+    });
+    const attachedSession = provider ? await this.attachObservedAgentSession(
+      provider,
+      workspacePath,
+      sessionsBeforeLaunch,
+      tmuxSession.paneProcessId
+    ) : null;
+    await this.refreshWorkSessionTerminal(cmd.workSession?._id, {
+      tmuxSessionName: tmuxSession.sessionName,
+      tmuxWindowName: tmuxSession.windowName,
+      tmuxPaneId: tmuxSession.paneId,
+      cwd: workspacePath,
+      repoRoot: workspacePath,
+      branch: currentGitBranch(workspacePath),
+      agentProvider: provider,
+      agentSessionKey: attachedSession?.process.sessionKey
+    });
+    if (provider && !attachedSession) {
+      await this.postAgentMessage(
+        cmd.liveActivityId,
+        "status",
+        `Started tmux session ${tmuxSession.sessionName}:${tmuxSession.windowName}. Waiting to verify ${providerLabel(provider)} in ${tmuxSession.paneId}.`
+      );
+      await this.updateLiveActivity(cmd.liveActivityId, {
+        status: "waiting_for_input",
+        latestSummary: `Running in ${tmuxSession.sessionName}:${tmuxSession.windowName}; waiting to verify ${providerLabel(provider)}`,
+        delegatedRunId: payload?.delegatedRunId,
+        launchStatus: "running",
+        title: `${providerLabel(provider)} on ${this.config.displayName}`
+      });
+      return;
+    }
+    await this.updateLiveActivity(cmd.liveActivityId, {
+      status: "waiting_for_input",
+      latestSummary: `Running in ${tmuxSession.sessionName}:${tmuxSession.windowName}`,
+      delegatedRunId: payload?.delegatedRunId,
+      launchStatus: "running",
+      processId: attachedSession?.processId,
+      title: workSessionTitle
+    });
+  }
+  async attachObservedAgentSession(provider, workspacePath, sessionsBeforeLaunch = [], paneProcessId) {
+    if (!workspacePath) {
+      return null;
+    }
+    const existingKeys = new Set(
+      sessionsBeforeLaunch.map(sessionIdentityKey).filter(Boolean)
+    );
+    for (let attempt = 0; attempt < 10; attempt += 1) {
+      const observedSessions = listObservedSessionsForWorkspace(
+        provider,
+        workspacePath
+      );
+      const candidate = (paneProcessId ? findObservedSessionInProcessTree(observedSessions, paneProcessId) : void 0) ?? observedSessions.find(
+        (session) => !existingKeys.has(sessionIdentityKey(session))
+      ) ?? (attempt === 9 ? observedSessions[0] : void 0);
+      if (candidate) {
+        const processId = await this.reportProcess(candidate);
+        return {
+          process: candidate,
+          processId
+        };
+      }
+      await sleep(750);
+    }
+    return null;
+  }
+  async reportProcess(process9) {
+    const {
+      provider,
+      providerLabel: providerLabel2,
+      localProcessId,
+      sessionKey,
+      cwd,
+      repoRoot,
+      branch,
+      title,
+      model,
+      tmuxSessionName,
+      tmuxWindowName,
+      tmuxPaneId,
+      mode,
+      status,
+      supportsInboundMessages
+    } = process9;
+    return await this.client.mutation(
+      api.agentBridge.bridgePublic.reportProcess,
+      {
+        deviceId: this.config.deviceId,
+        deviceSecret: this.config.deviceSecret,
+        provider,
+        providerLabel: providerLabel2,
+        localProcessId,
+        sessionKey,
+        cwd,
+        repoRoot,
+        branch,
+        title,
+        model,
+        tmuxSessionName,
+        tmuxWindowName,
+        tmuxPaneId,
+        mode,
+        status,
+        supportsInboundMessages
+      }
+    );
+  }
+  async updateLiveActivity(liveActivityId, args) {
+    await this.client.mutation(
+      api.agentBridge.bridgePublic.updateLiveActivityState,
+      {
+        deviceId: this.config.deviceId,
+        deviceSecret: this.config.deviceSecret,
+        liveActivityId,
+        ...args
+      }
+    );
+  }
+  async postAgentMessage(liveActivityId, role, body) {
+    await this.client.mutation(api.agentBridge.bridgePublic.postAgentMessage, {
+      deviceId: this.config.deviceId,
+      deviceSecret: this.config.deviceSecret,
+      liveActivityId,
+      role,
+      body
+    });
+  }
+  async completeCommand(commandId, status) {
+    await this.client.mutation(api.agentBridge.bridgePublic.completeCommand, {
+      deviceId: this.config.deviceId,
+      deviceSecret: this.config.deviceSecret,
+      commandId,
+      status
+    });
+  }
+  async postCommandError(cmd, errorMessage) {
+    if (cmd.kind === "launch" && cmd.liveActivityId) {
+      const payload = cmd.payload;
+      await this.updateLiveActivity(cmd.liveActivityId, {
+        status: "failed",
+        latestSummary: errorMessage,
+        delegatedRunId: payload?.delegatedRunId,
+        launchStatus: "failed"
+      });
+      await this.postAgentMessage(cmd.liveActivityId, "status", errorMessage);
+      return;
+    }
+    if (cmd.kind === "message" && cmd.liveActivityId) {
+      await this.postAgentMessage(cmd.liveActivityId, "status", errorMessage);
+      await this.updateLiveActivity(cmd.liveActivityId, {
+        status: "waiting_for_input",
+        latestSummary: errorMessage
+      });
+    }
+  }
+};
+function createTmuxWorkSession(args) {
+  const slug = sanitizeTmuxName(args.issueKey.toLowerCase());
+  const sessionName = `vector-${slug}-${randomUUID2().slice(0, 8)}`;
+  const windowName = sanitizeTmuxName(
+    args.provider === "codex" ? "codex" : args.provider === "claude_code" ? "claude" : "shell"
+  );
+  execFileSync("tmux", [
+    "new-session",
+    "-d",
+    "-s",
+    sessionName,
+    "-n",
+    windowName,
+    "-c",
+    args.workspacePath
+  ]);
+  const paneId = execFileSync(
+    "tmux",
+    [
+      "display-message",
+      "-p",
+      "-t",
+      `${sessionName}:${windowName}.0`,
+      "#{pane_id}"
+    ],
+    { encoding: "utf-8" }
+  ).trim();
+  const paneProcessId = execFileSync(
+    "tmux",
+    ["display-message", "-p", "-t", paneId, "#{pane_pid}"],
+    { encoding: "utf-8" }
+  ).trim();
+  if (args.provider) {
+    execFileSync("tmux", [
+      "send-keys",
+      "-t",
+      paneId,
+      buildManagedLaunchCommand(args.provider, args.prompt),
+      "Enter"
+    ]);
+  } else {
+    execFileSync("tmux", [
+      "send-keys",
+      "-t",
+      paneId,
+      `printf '%s\\n\\n' ${shellQuote(args.prompt)}`,
+      "Enter"
+    ]);
+  }
+  return {
+    sessionName,
+    windowName,
+    paneId,
+    paneProcessId
+  };
+}
+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"]);
+}
+function captureTmuxPane(paneId) {
+  return execFileSync(
+    "tmux",
+    ["capture-pane", "-p", "-e", "-t", paneId, "-S", "-120"],
+    { encoding: "utf-8" }
+  ).trimEnd();
+}
+function resizeTmuxPane(paneId, cols, rows) {
+  try {
+    execFileSync("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 {
+    return execSync2("git rev-parse --abbrev-ref HEAD", {
+      encoding: "utf-8",
+      cwd,
+      timeout: 3e3
+    }).trim();
+  } catch {
+    return void 0;
+  }
+}
+function buildManagedLaunchCommand(provider, prompt2) {
+  if (provider === "codex") {
+    return `codex --no-alt-screen -a never ${shellQuote(prompt2)}`;
+  }
+  return `claude --permission-mode bypassPermissions --dangerously-skip-permissions ${shellQuote(prompt2)}`;
+}
+function sanitizeTmuxName(value) {
+  return value.replace(/[^a-z0-9_-]+/gi, "-").replace(/^-+|-+$/g, "") || "work";
+}
+function shellQuote(value) {
+  return `'${value.replace(/'/g, `'"'"'`)}'`;
+}
+async function setupBridgeDevice(client, convexUrl) {
+  const deviceKey = getStableDeviceKey();
+  const displayName = `${process.env.USER ?? "user"}'s ${platform() === "darwin" ? "Mac" : "machine"}`;
+  const result = await client.mutation(
+    api.agentBridge.mutations.registerBridgeDevice,
+    {
+      deviceKey,
+      displayName,
+      hostname: hostname(),
+      platform: platform(),
+      serviceType: "foreground",
+      cliVersion: "0.1.0",
+      capabilities: ["codex", "claude_code"]
+    }
+  );
+  const config = {
+    deviceId: result.deviceId,
+    deviceKey,
+    deviceSecret: result.deviceSecret,
+    userId: result.userId,
+    displayName,
+    convexUrl,
+    registeredAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  saveBridgeConfig(config);
+  return config;
+}
+function getStableDeviceKey() {
+  const existingConfig = loadBridgeConfig();
+  const existingKey = existingConfig?.deviceKey?.trim();
+  if (existingKey) {
+    persistDeviceKey(existingKey);
+    return existingKey;
+  }
+  if (existsSync3(DEVICE_KEY_FILE)) {
+    const savedKey = readFileSync2(DEVICE_KEY_FILE, "utf-8").trim();
+    if (savedKey) {
+      return savedKey;
+    }
+  }
+  const generatedKey = `${hostname()}-${randomUUID2().slice(0, 8)}`;
+  persistDeviceKey(generatedKey);
+  return generatedKey;
+}
+function persistDeviceKey(deviceKey) {
+  if (!existsSync3(CONFIG_DIR)) mkdirSync(CONFIG_DIR, { recursive: true });
+  writeFileSync(DEVICE_KEY_FILE, `${deviceKey}
+`);
+}
+function buildLaunchPrompt(issueKey, issueTitle, workspacePath) {
+  return [
+    `You are working on Vector issue ${issueKey}: ${issueTitle}.`,
+    `The repository is already checked out at ${workspacePath}.`,
+    "Inspect the codebase, identify the relevant implementation area, and start the work.",
+    "In your first reply, summarize your plan and the first concrete step you are taking."
+  ].join("\n\n");
+}
+function summarizeMessage(message) {
+  if (!message) {
+    return void 0;
+  }
+  return message.length > 120 ? `${message.slice(0, 117).trimEnd()}...` : message;
+}
+function truncateForLog(message) {
+  return message.length > 80 ? `${message.slice(0, 77).trimEnd()}...` : message;
+}
+function listObservedSessionsForWorkspace(provider, workspacePath) {
+  return discoverAttachableSessions().filter(
+    (session) => session.provider === provider && matchesWorkspacePath(session, workspacePath)
+  ).sort(compareLocalSessionRecency);
+}
+function findObservedSessionInProcessTree(sessions, paneProcessId) {
+  const descendantIds = listDescendantProcessIds(paneProcessId);
+  if (descendantIds.size === 0) {
+    return void 0;
+  }
+  return sessions.find(
+    (session) => session.localProcessId ? descendantIds.has(session.localProcessId) : false
+  );
+}
+function listDescendantProcessIds(rootPid) {
+  const descendants = /* @__PURE__ */ new Set([rootPid]);
+  try {
+    const output = execSync2("ps -axo pid=,ppid=", {
+      encoding: "utf-8",
+      timeout: 3e3
+    });
+    const parentToChildren = /* @__PURE__ */ new Map();
+    for (const line of output.split("\n").map((value) => value.trim()).filter(Boolean)) {
+      const [pid, ppid] = line.split(/\s+/, 2);
+      if (!pid || !ppid) {
+        continue;
+      }
+      const children = parentToChildren.get(ppid) ?? [];
+      children.push(pid);
+      parentToChildren.set(ppid, children);
+    }
+    const queue = [rootPid];
+    while (queue.length > 0) {
+      const currentPid = queue.shift();
+      if (!currentPid) {
+        continue;
+      }
+      for (const childPid of parentToChildren.get(currentPid) ?? []) {
+        if (descendants.has(childPid)) {
+          continue;
+        }
+        descendants.add(childPid);
+        queue.push(childPid);
+      }
+    }
+  } catch {
+    return descendants;
+  }
+  return descendants;
+}
+function matchesWorkspacePath(session, workspacePath) {
+  const normalizedWorkspace = normalizePath(workspacePath);
+  const candidatePaths = [session.cwd, session.repoRoot].filter((value) => Boolean(value)).map(normalizePath);
+  return candidatePaths.some((path3) => path3 === normalizedWorkspace);
+}
+function normalizePath(value) {
+  return value.replace(/\/+$/, "");
+}
+function sessionIdentityKey(session) {
+  return [
+    session.provider,
+    session.sessionKey,
+    session.localProcessId,
+    session.cwd
+  ].filter(Boolean).join("::");
+}
+function compareLocalSessionRecency(a, b) {
+  return Number(b.localProcessId ?? 0) - Number(a.localProcessId ?? 0);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isBridgeProvider(provider) {
+  return provider === "codex" || provider === "claude_code";
+}
+function providerLabel(provider) {
+  if (provider === "codex") {
+    return "Codex";
+  }
+  if (provider === "claude_code") {
+    return "Claude";
+  }
+  return "Vector CLI";
+}
+function installLaunchAgent(vcliPath) {
+  if (platform() !== "darwin") {
+    console.error("LaunchAgent is macOS only. Use systemd on Linux.");
+    return;
+  }
+  const programArguments = getLaunchAgentProgramArguments(vcliPath);
+  const environmentVariables = [
+    "  <key>PATH</key>",
+    "  <string>/usr/local/bin:/opt/homebrew/bin:/usr/bin:/bin:/usr/sbin:/sbin</string>",
+    ...process.env.VECTOR_HOME?.trim() ? [
+      "  <key>VECTOR_HOME</key>",
+      `  <string>${process.env.VECTOR_HOME.trim()}</string>`
+    ] : []
+  ].join("\n");
+  const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${LAUNCHAGENT_LABEL}</string>
+  <key>ProgramArguments</key>
+  ${programArguments}
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${CONFIG_DIR}/bridge.log</string>
+  <key>StandardErrorPath</key>
+  <string>${CONFIG_DIR}/bridge.err.log</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+${environmentVariables}
+  </dict>
+</dict>
+</plist>`;
+  if (!existsSync3(LAUNCHAGENT_DIR)) {
+    mkdirSync(LAUNCHAGENT_DIR, { recursive: true });
+  }
+  removeLegacyMenuBarLaunchAgent();
+  writeFileSync(LAUNCHAGENT_PLIST, plist);
+  console.log(`Installed LaunchAgent: ${LAUNCHAGENT_PLIST}`);
+}
+function getLaunchAgentProgramArguments(vcliPath) {
+  const args = resolveCliInvocation(vcliPath);
+  return [
+    "<array>",
+    ...args.map((arg) => `    <string>${arg}</string>`),
+    "    <string>service</string>",
+    "    <string>run</string>",
+    "  </array>"
+  ].join("\n");
+}
+function resolveCliInvocation(vcliPath) {
+  if (vcliPath.endsWith(".js")) {
+    return [process.execPath, vcliPath];
+  }
+  if (vcliPath.endsWith(".ts")) {
+    const tsxPath = join2(
+      import.meta.dirname ?? process.cwd(),
+      "..",
+      "..",
+      "..",
+      "node_modules",
+      ".bin",
+      "tsx"
+    );
+    if (existsSync3(tsxPath)) {
+      return [tsxPath, vcliPath];
+    }
+  }
+  return [vcliPath];
+}
+function loadLaunchAgent() {
+  if (runLaunchctl(["bootstrap", launchctlGuiDomain(), LAUNCHAGENT_PLIST])) {
+    runLaunchctl([
+      "kickstart",
+      "-k",
+      `${launchctlGuiDomain()}/${LAUNCHAGENT_LABEL}`
+    ]);
+    console.log(
+      "LaunchAgent loaded. Bridge will start automatically on login."
+    );
+    return;
+  }
+  if (runLaunchctl([
+    "kickstart",
+    "-k",
+    `${launchctlGuiDomain()}/${LAUNCHAGENT_LABEL}`
+  ]) || runLaunchctl(["load", LAUNCHAGENT_PLIST])) {
+    console.log(
+      "LaunchAgent loaded. Bridge will start automatically on login."
+    );
+    return;
+  }
+  console.error("Failed to load LaunchAgent");
+}
+function unloadLaunchAgent() {
+  if (runLaunchctl(["bootout", `${launchctlGuiDomain()}/${LAUNCHAGENT_LABEL}`]) || runLaunchctl(["bootout", launchctlGuiDomain(), LAUNCHAGENT_PLIST]) || runLaunchctl(["unload", LAUNCHAGENT_PLIST])) {
+    console.log("LaunchAgent unloaded.");
+    return true;
+  }
+  console.error("Failed to unload LaunchAgent (may not be loaded)");
+  return false;
+}
+function uninstallLaunchAgent() {
+  unloadLaunchAgent();
+  removeLegacyMenuBarLaunchAgent();
+  try {
+    unlinkSync(LAUNCHAGENT_PLIST);
+    console.log("LaunchAgent removed.");
+  } catch {
+  }
+}
+var MENUBAR_PID_FILE = join2(CONFIG_DIR, "menubar.pid");
+function removeLegacyMenuBarLaunchAgent() {
+  if (platform() !== "darwin" || !existsSync3(LEGACY_MENUBAR_LAUNCHAGENT_PLIST)) {
+    return;
+  }
+  try {
+    execSync2(`launchctl unload ${LEGACY_MENUBAR_LAUNCHAGENT_PLIST}`, {
+      stdio: "pipe"
+    });
+  } catch {
+  }
+  try {
+    unlinkSync(LEGACY_MENUBAR_LAUNCHAGENT_PLIST);
+  } catch {
+  }
+}
+function launchctlGuiDomain() {
+  const uid = typeof process.getuid === "function" ? process.getuid() : typeof process.geteuid === "function" ? process.geteuid() : 0;
+  return `gui/${uid}`;
+}
+function runLaunchctl(args) {
+  try {
+    execFileSync("launchctl", args, {
+      stdio: "ignore"
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function findCliEntrypoint() {
+  const candidates = [
+    join2(import.meta.dirname ?? "", "index.js"),
+    join2(import.meta.dirname ?? "", "index.ts"),
+    join2(import.meta.dirname ?? "", "..", "dist", "index.js")
+  ];
+  for (const p of candidates) {
+    if (existsSync3(p)) return p;
+  }
+  return null;
+}
+function getCurrentCliInvocation() {
+  const entrypoint = findCliEntrypoint();
+  if (!entrypoint) {
+    return null;
+  }
+  return resolveCliInvocation(entrypoint);
+}
+function findMenuBarExecutable() {
+  const candidates = [
+    join2(
+      import.meta.dirname ?? "",
+      "..",
+      "native",
+      "VectorMenuBar.app",
+      "Contents",
+      "MacOS",
+      "VectorMenuBar"
+    ),
+    join2(
+      import.meta.dirname ?? "",
+      "native",
+      "VectorMenuBar.app",
+      "Contents",
+      "MacOS",
+      "VectorMenuBar"
+    )
+  ];
+  for (const p of candidates) {
+    if (existsSync3(p)) {
+      return p;
+    }
+  }
+  return null;
+}
+function isKnownMenuBarProcess(pid) {
+  try {
+    const command = execSync2(`ps -p ${pid} -o args=`, {
+      encoding: "utf-8",
+      timeout: 3e3
+    });
+    return command.includes("menubar.js") || command.includes("menubar.ts") || command.includes("VectorMenuBar");
+  } catch {
+    return false;
+  }
+}
+function killExistingMenuBar() {
+  if (existsSync3(MENUBAR_PID_FILE)) {
+    try {
+      const pid = Number(readFileSync2(MENUBAR_PID_FILE, "utf-8").trim());
+      if (Number.isFinite(pid) && pid > 0 && isKnownMenuBarProcess(pid)) {
+        process.kill(pid, "SIGTERM");
+      }
+    } catch {
+    }
+    try {
+      unlinkSync(MENUBAR_PID_FILE);
+    } catch {
+    }
+  }
+}
+function getRunningMenuBarPid() {
+  if (!existsSync3(MENUBAR_PID_FILE)) {
+    return null;
+  }
+  try {
+    const pid = Number(readFileSync2(MENUBAR_PID_FILE, "utf-8").trim());
+    if (Number.isFinite(pid) && pid > 0 && isKnownMenuBarProcess(pid)) {
+      process.kill(pid, 0);
+      return pid;
+    }
+  } catch {
+  }
+  try {
+    unlinkSync(MENUBAR_PID_FILE);
+  } catch {
+  }
+  return null;
+}
+async function launchMenuBar() {
+  if (platform() !== "darwin") return;
+  removeLegacyMenuBarLaunchAgent();
+  const executable = findMenuBarExecutable();
+  const cliInvocation = getCurrentCliInvocation();
+  if (!executable || !cliInvocation) return;
+  const existingPid = getRunningMenuBarPid();
+  if (existingPid) {
+    return;
+  }
+  killExistingMenuBar();
+  try {
+    const { spawn: spawnChild } = await import("child_process");
+    const child = spawnChild(executable, [], {
+      detached: true,
+      stdio: "ignore",
+      env: {
+        ...process.env,
+        VECTOR_CLI_COMMAND: cliInvocation[0],
+        VECTOR_CLI_ARGS_JSON: JSON.stringify(cliInvocation.slice(1))
+      }
+    });
+    child.unref();
+    if (child.pid) {
+      writeFileSync(MENUBAR_PID_FILE, String(child.pid));
     }
-    if (data.every((item) => typeof item === "object" && item !== null)) {
-      console.table(
-        data.map(
-          (item) => Object.fromEntries(
-            Object.entries(item).map(([key, value]) => [key, simplify(value)])
-          )
-        )
-      );
-      return;
+  } catch {
+  }
+}
+function stopMenuBar() {
+  killExistingMenuBar();
+}
+function getBridgeStatus() {
+  const config = loadBridgeConfig();
+  if (!config) return { configured: false, running: false, starting: false };
+  let running = false;
+  let starting = false;
+  let pid;
+  if (existsSync3(PID_FILE)) {
+    const pidStr = readFileSync2(PID_FILE, "utf-8").trim();
+    pid = Number(pidStr);
+    try {
+      process.kill(pid, 0);
+      running = true;
+    } catch {
+      running = false;
     }
   }
-  if (typeof data === "object" && data !== null) {
-    console.dir(data, { depth: null, colors: true });
-    return;
+  if (!running && platform() === "darwin") {
+    starting = runLaunchctl(["print", `${launchctlGuiDomain()}/${LAUNCHAGENT_LABEL}`]) || runLaunchctl(["list", LAUNCHAGENT_LABEL]);
   }
-  console.log(String(data));
-}
-
-// ../../src/cli/session.ts
-import { mkdir, readFile, rm, writeFile } from "fs/promises";
-import { homedir } from "os";
-import path from "path";
-var SESSION_ROOT = path.join(homedir(), ".vector");
-function getSessionPath(profile = "default") {
-  return path.join(SESSION_ROOT, `cli-${profile}.json`);
+  return { configured: true, running, starting, pid, config };
 }
-async function readSession(profile = "default") {
+function stopBridge(options) {
+  if (options?.includeMenuBar) {
+    killExistingMenuBar();
+  }
   try {
-    const raw = await readFile(getSessionPath(profile), "utf8");
-    const parsed = JSON.parse(raw);
-    return {
-      version: 1,
-      cookies: {},
-      ...parsed
-    };
+    writeLiveActivitiesCache([]);
   } catch {
-    return null;
+  }
+  if (!existsSync3(PID_FILE)) return false;
+  const pid = Number(readFileSync2(PID_FILE, "utf-8").trim());
+  try {
+    process.kill(pid, "SIGTERM");
+    return true;
+  } catch {
+    return false;
   }
 }
-async function writeSession(session, profile = "default") {
-  await mkdir(SESSION_ROOT, { recursive: true });
-  await writeFile(
-    getSessionPath(profile),
-    `${JSON.stringify(session, null, 2)}
-`,
-    "utf8"
-  );
-}
-async function clearSession(profile = "default") {
-  await rm(getSessionPath(profile), { force: true });
-}
-function createEmptySession() {
-  return {
-    version: 1,
-    cookies: {}
-  };
+function ts2() {
+  return (/* @__PURE__ */ new Date()).toLocaleTimeString();
 }
 
-// ../../src/cli/index.ts
+// src/index.ts
+import { platform as osPlatform } from "os";
 loadEnv({ path: ".env.local", override: false });
 loadEnv({ path: ".env", override: false });
 var cliApi = {
@@ -404,13 +3527,128 @@ function buildPaginationOptions(limit, cursor) {
 function normalizeMatch(value) {
   return value?.trim().toLowerCase();
 }
+function parseDate(value) {
+  const ms = Date.parse(value);
+  if (!Number.isFinite(ms)) {
+    throw new Error(`Invalid date: ${value}`);
+  }
+  return ms;
+}
+function applyListFilters(items, options) {
+  let result = [...items];
+  if (options.createdAfter) {
+    const threshold = parseDate(options.createdAfter);
+    result = result.filter(
+      (item) => typeof item.createdAt === "number" && item.createdAt >= threshold
+    );
+  }
+  if (options.createdBefore) {
+    const threshold = parseDate(options.createdBefore);
+    result = result.filter(
+      (item) => typeof item.createdAt === "number" && item.createdAt <= threshold
+    );
+  }
+  if (options.updatedAfter) {
+    const threshold = parseDate(options.updatedAfter);
+    result = result.filter(
+      (item) => typeof item.lastEditedAt === "number" && item.lastEditedAt >= threshold
+    );
+  }
+  if (options.updatedBefore) {
+    const threshold = parseDate(options.updatedBefore);
+    result = result.filter(
+      (item) => typeof item.lastEditedAt === "number" && item.lastEditedAt <= threshold
+    );
+  }
+  if (options.sort) {
+    const field = options.sort;
+    const desc = options.order?.toLowerCase() === "desc";
+    result.sort((a, b) => {
+      const aVal = a[field];
+      const bVal = b[field];
+      if (aVal == null && bVal == null) return 0;
+      if (aVal == null) return 1;
+      if (bVal == null) return -1;
+      if (typeof aVal === "number" && typeof bVal === "number")
+        return desc ? bVal - aVal : aVal - bVal;
+      return desc ? String(bVal).localeCompare(String(aVal)) : String(aVal).localeCompare(String(bVal));
+    });
+  }
+  if (options.limit) {
+    const limit = Number(options.limit);
+    if (Number.isFinite(limit) && limit > 0) {
+      result = result.slice(0, limit);
+    }
+  }
+  return result;
+}
+function addEntityUrls(items, appUrl, orgSlug, entityType) {
+  return items.map((item) => {
+    let path3;
+    switch (entityType) {
+      case "issues":
+        path3 = `/${orgSlug}/issues/${item.key}`;
+        break;
+      case "projects":
+        path3 = `/${orgSlug}/projects/${item.key}`;
+        break;
+      case "teams":
+        path3 = `/${orgSlug}/teams/${item.key}`;
+        break;
+      case "documents":
+        path3 = `/${orgSlug}/documents/${item.id}`;
+        break;
+      case "folders":
+        path3 = `/${orgSlug}/documents/folders/${item.id}`;
+        break;
+    }
+    return { ...item, url: `${appUrl}${path3}` };
+  });
+}
+function normalizeAppUrl(raw) {
+  let url = raw.trim();
+  if (!/^https?:\/\//i.test(url)) {
+    const isLocal = /^localhost(:\d+)?/i.test(url) || /^127\.0\.0\.1(:\d+)?/.test(url);
+    url = isLocal ? `http://${url}` : `https://${url}`;
+  }
+  return url.replace(/\/+$/, "");
+}
+async function resolveAppUrl(raw) {
+  const url = normalizeAppUrl(raw);
+  try {
+    const response = await fetch(url, { method: "HEAD", redirect: "follow" });
+    const resolved = new URL(response.url).origin;
+    return resolved;
+  } catch {
+    return url;
+  }
+}
+async function fetchConvexUrl(appUrl) {
+  try {
+    const url = new URL("/api/config", appUrl).toString();
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}`);
+    }
+    const data = await response.json();
+    if (data.convexUrl) {
+      return data.convexUrl;
+    }
+  } catch {
+  }
+  return "http://127.0.0.1:3210";
+}
 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 = requiredString(appUrlSource, "app URL");
-  const convexUrl = options.convexUrl ?? session?.convexUrl ?? process.env.NEXT_PUBLIC_CONVEX_URL ?? process.env.CONVEX_URL ?? "http://127.0.0.1:3210";
+  const appUrl = await resolveAppUrl(requiredString(appUrlSource, "app URL"));
+  let convexUrl = options.convexUrl ?? session?.convexUrl;
+  if (!convexUrl) {
+    const fetchedUrl = await fetchConvexUrl(appUrl);
+    convexUrl = fetchedUrl !== "http://127.0.0.1:3210" ? fetchedUrl : process.env.NEXT_PUBLIC_CONVEX_URL ?? process.env.CONVEX_URL ?? fetchedUrl;
+  }
   return {
     appUrl,
     convexUrl,
@@ -421,7 +3659,7 @@ async function getRuntime(command) {
   };
 }
 function requireSession(runtime) {
-  if (!runtime.session || Object.keys(runtime.session.cookies).length === 0) {
+  if (!runtime.session || Object.keys(runtime.session.cookies).length === 0 && !runtime.session.bearerToken) {
     throw new Error("Not logged in. Run `vcli auth login` first.");
   }
   return runtime.session;
@@ -435,6 +3673,80 @@ function requireOrg(runtime, explicit) {
   }
   return orgSlug;
 }
+function hostForAppUrl(appUrl) {
+  if (!appUrl) {
+    return void 0;
+  }
+  try {
+    const url = new URL(appUrl);
+    return url.port ? `${url.hostname}:${url.port}` : url.hostname;
+  } catch {
+    return void 0;
+  }
+}
+function decodeSessionClaims(session) {
+  const jwt = session?.cookies?.["__Secure-better-auth.convex_jwt"];
+  if (!jwt) {
+    return {};
+  }
+  const parts = jwt.split(".");
+  if (parts.length < 2) {
+    return {};
+  }
+  let payload = parts[1].replace(/-/g, "+").replace(/_/g, "/");
+  while (payload.length % 4 !== 0) {
+    payload += "=";
+  }
+  try {
+    const decoded = JSON.parse(
+      Buffer.from(payload, "base64").toString("utf8")
+    );
+    return {
+      email: decoded.email,
+      userId: decoded.sub ?? decoded.userId
+    };
+  } catch {
+    return {};
+  }
+}
+function buildMenuSessionInfo(session) {
+  const claims = decodeSessionClaims(session);
+  return {
+    orgSlug: session?.activeOrgSlug ?? "oss-lab",
+    appUrl: session?.appUrl,
+    appDomain: hostForAppUrl(session?.appUrl),
+    email: claims.email,
+    userId: claims.userId
+  };
+}
+function parseAgentProvider(value) {
+  if (value === "codex" || value === "claude_code" || value === "vector_cli") {
+    return value;
+  }
+  throw new Error("provider must be one of: codex, claude_code, vector_cli");
+}
+function isBridgeDeviceAuthError(error) {
+  if (!error || typeof error !== "object") {
+    return false;
+  }
+  const maybeData = error.data;
+  return maybeData === "INVALID_DEVICE_SECRET" || maybeData === "DEVICE_NOT_FOUND";
+}
+async function validateStoredBridgeConfig(config) {
+  const client = new ConvexHttpClient3(config.convexUrl);
+  try {
+    await client.mutation(api.agentBridge.bridgePublic.heartbeat, {
+      deviceId: config.deviceId,
+      deviceSecret: config.deviceSecret
+    });
+    return true;
+  } catch (error) {
+    if (isBridgeDeviceAuthError(error)) {
+      return false;
+    }
+    throw error;
+  }
+}
 async function getClient(command) {
   const runtime = await getRuntime(command);
   const session = requireSession(runtime);
@@ -445,6 +3757,39 @@ async function getClient(command) {
   );
   return { client, runtime, session };
 }
+async function ensureBridgeConfig(command) {
+  let config = loadBridgeConfig();
+  try {
+    const runtime = await getRuntime(command);
+    const session = requireSession(runtime);
+    const client = await createConvexClient(
+      session,
+      runtime.appUrl,
+      runtime.convexUrl
+    );
+    const user = await runQuery(client, api.users.currentUser);
+    if (!user) {
+      throw new Error("Not logged in. Run `vcli auth login` first.");
+    }
+    const backendDevice = config ? await runQuery(client, api.agentBridge.queries.getDevice, {
+      deviceId: config.deviceId
+    }) : null;
+    const needsRegistration = !config || config.userId !== user._id || config.convexUrl !== runtime.convexUrl || !backendDevice || !await validateStoredBridgeConfig(config);
+    if (needsRegistration) {
+      config = await setupBridgeDevice(client, runtime.convexUrl);
+    }
+    if (!config) {
+      throw new Error("Bridge device is not configured.");
+    }
+    saveBridgeConfig(config);
+    return config;
+  } catch (error) {
+    if (config) {
+      return config;
+    }
+    throw error;
+  }
+}
 async function resolveMemberId(client, orgSlug, ref) {
   const members = await runQuery(
     client,
@@ -620,10 +3965,19 @@ async function parseEstimatedTimes(client, orgSlug, value) {
   return estimatedTimes;
 }
 var program = new Command();
-program.name("vcli").description("Vector CLI").showHelpAfterError().option(
+function readPackageVersionSync() {
+  try {
+    const dir = import.meta.dirname ?? dirname(fileURLToPath2(import.meta.url));
+    const raw = readFileSync3(join3(dir, "..", "package.json"), "utf8");
+    return JSON.parse(raw).version ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+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);
@@ -664,19 +4018,48 @@ authCommand.command("signup").option("--email <email>", "Email address").option(
     runtime.json
   );
 });
-authCommand.command("login [identifier]").option("--password <password>", "Password").action(async (identifier, options, command) => {
+authCommand.command("login [identifier]").option("--password <password>", "Password (uses device flow if omitted)").action(async (identifier, options, command) => {
   const runtime = await getRuntime(command);
-  const loginId = identifier?.trim() || await prompt("Email or username: ");
-  const password = options.password?.trim() || await promptSecret("Password: ");
   let session = createEmptySession();
   session.appUrl = runtime.appUrl;
   session.convexUrl = runtime.convexUrl;
-  session = await loginWithPassword(
-    session,
-    runtime.appUrl,
-    loginId,
-    password
-  );
+  const usePassword = Boolean(identifier || options.password);
+  if (usePassword) {
+    const loginId = identifier?.trim() || await prompt("Email or username: ");
+    const password = options.password?.trim() || await promptSecret("Password: ");
+    session = await loginWithPassword(
+      session,
+      runtime.appUrl,
+      loginId,
+      password
+    );
+  } else {
+    const deviceResp = await requestDeviceCode(runtime.appUrl, "vcli");
+    const verifyUrl = `${runtime.appUrl}/device?user_code=${deviceResp.user_code}`;
+    console.log();
+    console.log(`  Open this URL in your browser to log in:`);
+    console.log();
+    console.log(`    ${verifyUrl}`);
+    console.log();
+    console.log(`  Or go to ${runtime.appUrl}/device and enter code:`);
+    console.log();
+    console.log(`    ${deviceResp.user_code}`);
+    console.log();
+    const open2 = await Promise.resolve().then(() => (init_open(), open_exports)).then((m) => m.default).catch(() => null);
+    if (open2) {
+      await open2(verifyUrl).catch(() => {
+      });
+    }
+    console.log("  Waiting for authorization...");
+    session = await pollDeviceToken(
+      session,
+      runtime.appUrl,
+      deviceResp.device_code,
+      "vcli",
+      deviceResp.interval,
+      deviceResp.expires_in
+    );
+  }
   const authState = await fetchAuthSession(session, runtime.appUrl);
   session = authState.session;
   const client = await createConvexClient(
@@ -717,6 +4100,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);
@@ -1047,6 +4462,75 @@ permissionCommand.command("check-many <permissions>").option("--team <teamKey>")
   printOutput(result, runtime.json);
 });
 var activityCommand = program.command("activity").description("Activity feed");
+activityCommand.command("list").description(
+  "List org-wide activity with optional filters by entity type, event type, and time range"
+).option(
+  "--entity-type <type>",
+  "Filter by entity type: issue, project, team, document"
+).option(
+  "--event-type <type>",
+  "Filter by event type (e.g. issue_created, issue_priority_changed)"
+).option(
+  "--since <datetime>",
+  "Start of time range (ISO date or shorthand: today, yesterday, 7d, 30d)"
+).option(
+  "--until <datetime>",
+  "End of time range (ISO date or shorthand: today, now)"
+).option("--limit <n>").option("--cursor <cursor>").action(async (options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  function parseTimeArg(value, bound) {
+    if (!value) return void 0;
+    const now = /* @__PURE__ */ new Date();
+    const startOfToday = new Date(
+      now.getFullYear(),
+      now.getMonth(),
+      now.getDate()
+    );
+    const endOfToday = new Date(
+      now.getFullYear(),
+      now.getMonth(),
+      now.getDate(),
+      23,
+      59,
+      59,
+      999
+    );
+    switch (value) {
+      case "now":
+        return now.getTime();
+      case "today":
+        return bound === "start" ? startOfToday.getTime() : endOfToday.getTime();
+      case "yesterday":
+        return bound === "start" ? startOfToday.getTime() - 864e5 : startOfToday.getTime() - 1;
+      default: {
+        const daysMatch = value.match(/^(\d+)d$/);
+        if (daysMatch) {
+          return now.getTime() - Number(daysMatch[1]) * 864e5;
+        }
+        const parsed = new Date(value).getTime();
+        if (Number.isNaN(parsed)) {
+          throw new Error(`Invalid time value: ${value}`);
+        }
+        return parsed;
+      }
+    }
+  }
+  const result = await runQuery(
+    client,
+    api.activities.queries.listOrgActivity,
+    {
+      orgSlug,
+      entityType: options.entityType ?? void 0,
+      eventType: options.eventType ?? void 0,
+      since: parseTimeArg(options.since, "start"),
+      until: parseTimeArg(options.until, "end"),
+      limit: optionalNumber(options.limit, "limit") ?? void 0,
+      cursor: options.cursor ?? void 0
+    }
+  );
+  printOutput(result, runtime.json);
+});
 activityCommand.command("project <projectKey>").option("--limit <n>").option("--cursor <cursor>").action(async (projectKey, options, command) => {
   const { client, runtime } = await getClient(command);
   const orgSlug = requireOrg(runtime);
@@ -1503,13 +4987,14 @@ adminCommand.command("sync-disposable-domains").action(async (_options, command)
   printOutput(result, runtime.json);
 });
 var teamCommand = program.command("team").description("Teams");
-teamCommand.command("list [slug]").option("--limit <n>").action(async (slug, options, command) => {
+teamCommand.command("list [slug]").option("--limit <n>").option("--created-after <date>", "Filter: created on or after date (ISO)").option("--created-before <date>", "Filter: created on or before date (ISO)").option("--sort <field>", "Sort by field (e.g. createdAt, name, key)").option("--order <direction>", "Sort order: asc or desc (default: asc)").action(async (slug, options, command) => {
   const { client, runtime } = await getClient(command);
   const orgSlug = requireOrg(runtime, slug);
-  const result = await runAction(client, cliApi.listTeams, {
-    orgSlug,
-    limit: options.limit ? Number(options.limit) : void 0
+  const raw = await runAction(client, cliApi.listTeams, {
+    orgSlug
   });
+  const filtered = applyListFilters(raw, options);
+  const result = addEntityUrls(filtered, runtime.appUrl, orgSlug, "teams");
   printOutput(result, runtime.json);
 });
 teamCommand.command("get <teamKey>").action(async (teamKey, _options, command) => {
@@ -1603,14 +5088,15 @@ teamCommand.command("set-lead <teamKey> <member>").action(async (teamKey, member
   printOutput(result, runtime.json);
 });
 var projectCommand = program.command("project").description("Projects");
-projectCommand.command("list [slug]").option("--team <teamKey>").option("--limit <n>").action(async (slug, options, command) => {
+projectCommand.command("list [slug]").option("--team <teamKey>").option("--limit <n>").option("--created-after <date>", "Filter: created on or after date (ISO)").option("--created-before <date>", "Filter: created on or before date (ISO)").option("--sort <field>", "Sort by field (e.g. createdAt, name, key)").option("--order <direction>", "Sort order: asc or desc (default: asc)").action(async (slug, options, command) => {
   const { client, runtime } = await getClient(command);
   const orgSlug = requireOrg(runtime, slug);
-  const result = await runAction(client, cliApi.listProjects, {
+  const raw = await runAction(client, cliApi.listProjects, {
     orgSlug,
-    teamKey: options.team,
-    limit: options.limit ? Number(options.limit) : void 0
+    teamKey: options.team
   });
+  const filtered = applyListFilters(raw, options);
+  const result = addEntityUrls(filtered, runtime.appUrl, orgSlug, "projects");
   printOutput(result, runtime.json);
 });
 projectCommand.command("get <projectKey>").action(async (projectKey, _options, command) => {
@@ -1710,15 +5196,17 @@ projectCommand.command("set-lead <projectKey> <member>").action(async (projectKe
   printOutput(result, runtime.json);
 });
 var issueCommand = program.command("issue").description("Issues");
-issueCommand.command("list [slug]").option("--project <projectKey>").option("--team <teamKey>").option("--limit <n>").action(async (slug, options, command) => {
+issueCommand.command("list [slug]").option("--project <projectKey>").option("--team <teamKey>").option("--assignee <name>", "Filter by assignee name or email").option("--limit <n>").option("--created-after <date>", "Filter: created on or after date (ISO)").option("--created-before <date>", "Filter: created on or before date (ISO)").option("--sort <field>", "Sort by field (e.g. createdAt, title, key)").option("--order <direction>", "Sort order: asc or desc (default: asc)").action(async (slug, options, command) => {
   const { client, runtime } = await getClient(command);
   const orgSlug = requireOrg(runtime, slug);
-  const result = await runAction(client, cliApi.listIssues, {
+  const raw = await runAction(client, cliApi.listIssues, {
     orgSlug,
     projectKey: options.project,
     teamKey: options.team,
-    limit: options.limit ? Number(options.limit) : void 0
+    assigneeName: options.assignee
   });
+  const filtered = applyListFilters(raw, options);
+  const result = addEntityUrls(filtered, runtime.appUrl, orgSlug, "issues");
   printOutput(result, runtime.json);
 });
 issueCommand.command("get <issueKey>").action(async (issueKey, _options, command) => {
@@ -1915,15 +5403,40 @@ issueCommand.command("comment <issueKey>").requiredOption("--body <body>").actio
   });
   printOutput(result, runtime.json);
 });
+issueCommand.command("link-github <issueKey> <url>").description("Link a GitHub pull request, issue, or commit URL to an issue").action(async (issueKey, url, _options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  await runAction(client, api.github.actions.linkArtifactByUrl, {
+    orgSlug,
+    issueKey,
+    url
+  });
+  printOutput({ success: true, issueKey, url }, runtime.json);
+});
 var documentCommand = program.command("document").description("Documents");
-documentCommand.command("list [slug]").option("--folder-id <id>").option("--limit <n>").action(async (slug, options, command) => {
+documentCommand.command("list [slug]").option("--folder-id <id>").option("--limit <n>").option("--created-after <date>", "Filter: created on or after date (ISO)").option("--created-before <date>", "Filter: created on or before date (ISO)").option(
+  "--updated-after <date>",
+  "Filter: last edited on or after date (ISO)"
+).option(
+  "--updated-before <date>",
+  "Filter: last edited on or before date (ISO)"
+).option(
+  "--sort <field>",
+  "Sort by field (e.g. createdAt, title, lastEditedAt)"
+).option("--order <direction>", "Sort order: asc or desc (default: asc)").action(async (slug, options, command) => {
   const { client, runtime } = await getClient(command);
   const orgSlug = requireOrg(runtime, slug);
-  const result = await runAction(client, cliApi.listDocuments, {
+  const raw = await runAction(client, cliApi.listDocuments, {
     orgSlug,
-    folderId: options.folderId,
-    limit: options.limit ? Number(options.limit) : void 0
+    folderId: options.folderId
   });
+  const filtered = applyListFilters(raw, options);
+  const result = addEntityUrls(
+    filtered,
+    runtime.appUrl,
+    orgSlug,
+    "documents"
+  );
   printOutput(result, runtime.json);
 });
 documentCommand.command("get <documentId>").action(async (documentId, _options, command) => {
@@ -1989,10 +5502,12 @@ documentCommand.command("delete <documentId>").action(async (documentId, _option
   printOutput(result, runtime.json);
 });
 var folderCommand = program.command("folder").description("Document folders");
-folderCommand.command("list [slug]").action(async (slug, _options, command) => {
+folderCommand.command("list [slug]").option("--limit <n>").option("--created-after <date>", "Filter: created on or after date (ISO)").option("--created-before <date>", "Filter: created on or before date (ISO)").option("--sort <field>", "Sort by field (e.g. createdAt, name)").option("--order <direction>", "Sort order: asc or desc (default: asc)").action(async (slug, options, command) => {
   const { client, runtime } = await getClient(command);
   const orgSlug = requireOrg(runtime, slug);
-  const result = await runAction(client, cliApi.listFolders, { orgSlug });
+  const raw = await runAction(client, cliApi.listFolders, { orgSlug });
+  const filtered = applyListFilters(raw, options);
+  const result = addEntityUrls(filtered, runtime.appUrl, orgSlug, "folders");
   printOutput(result, runtime.json);
 });
 folderCommand.command("create").requiredOption("--name <name>").option("--description <description>").option("--icon <icon>").option("--color <color>").action(async (options, command) => {
@@ -2032,6 +5547,272 @@ folderCommand.command("delete <folderId>").action(async (folderId, _options, com
   });
   printOutput(result, runtime.json);
 });
+var VECTOR_HOME = process.env.VECTOR_HOME?.trim() || `${process.env.HOME ?? "~"}/.vector`;
+var serviceCommand = program.command("service").description("Manage the local bridge service");
+serviceCommand.command("start").description("Start the bridge service via LaunchAgent (macOS) or foreground").action(async (_options, command) => {
+  const existing = getBridgeStatus();
+  if (existing.running) {
+    console.log(`Bridge is already running (PID ${existing.pid}).`);
+    return;
+  }
+  const { spinner } = await import("@clack/prompts");
+  const s = spinner();
+  s.start("Ensuring device registration...");
+  const config = await ensureBridgeConfig(command);
+  s.stop(`Device ready: ${config.displayName}`);
+  if (osPlatform() === "darwin") {
+    s.start("Starting bridge service...");
+    const vcliPath = process.argv[1] ?? "vcli";
+    installLaunchAgent(vcliPath);
+    loadLaunchAgent();
+    s.stop("Bridge service started.");
+  } else {
+    console.log(
+      "Starting bridge in foreground (use systemd for background)..."
+    );
+    const bridge = new BridgeService(config);
+    await bridge.run();
+  }
+});
+serviceCommand.command("run").description("Run the bridge service in the foreground (used by LaunchAgent)").action(async (_options, command) => {
+  const config = await ensureBridgeConfig(command);
+  if (osPlatform() === "darwin") {
+    await launchMenuBar();
+  }
+  const bridge = new BridgeService(config);
+  await bridge.run();
+});
+serviceCommand.command("stop").description("Stop the bridge service").action(() => {
+  let unloaded = false;
+  if (osPlatform() === "darwin") {
+    unloaded = unloadLaunchAgent();
+  }
+  if (stopBridge() || unloaded) {
+    console.log("Bridge stopped.");
+  } else if (osPlatform() !== "darwin") {
+    console.log("Bridge is not running.");
+  } else {
+    console.log("Bridge is not running.");
+  }
+});
+serviceCommand.command("status").description("Show bridge service status").action((_options, command) => {
+  const status = getBridgeStatus();
+  if (!status.configured) {
+    console.log("Bridge not configured. Run: vcli service start");
+    return;
+  }
+  console.log("Vector Bridge");
+  console.log(
+    `  Device:  ${status.config.displayName} (${status.config.deviceId})`
+  );
+  console.log(`  User:    ${status.config.userId}`);
+  const statusLabel = status.running ? `Running (PID ${status.pid})` : status.starting ? "Starting..." : "Not running";
+  console.log(`  Status:  ${statusLabel}`);
+  console.log(`  Config:  ${VECTOR_HOME}/bridge.json`);
+});
+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 ?? await readDefaultProfile();
+  const session = await readSession(profile);
+  const profiles = await listProfiles();
+  const defaultProfile = await readDefaultProfile();
+  let workspaces = [];
+  let workSessions = [];
+  let detectedSessions = [];
+  try {
+    const runtime = await getRuntime(command);
+    if (runtime.session && status.config?.deviceId) {
+      const client = await createConvexClient(
+        runtime.session,
+        runtime.appUrl,
+        runtime.convexUrl
+      );
+      workspaces = await runQuery(
+        client,
+        api.agentBridge.queries.listDeviceWorkspaces,
+        {
+          deviceId: status.config.deviceId
+        }
+      );
+      workSessions = await runQuery(
+        client,
+        api.agentBridge.queries.listDeviceWorkSessions,
+        {
+          deviceId: status.config.deviceId
+        }
+      );
+      const devices = await runQuery(
+        client,
+        api.agentBridge.queries.listProcessesForAttach,
+        {}
+      );
+      const currentDevice = devices.find(
+        (entry) => entry.device._id === status.config?.deviceId
+      );
+      detectedSessions = currentDevice?.processes ?? [];
+    }
+  } catch {
+    workspaces = [];
+    workSessions = [];
+    detectedSessions = [];
+  }
+  printOutput(
+    {
+      configured: status.configured,
+      running: status.running,
+      starting: status.starting,
+      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);
+  const result = await runQuery(client, api.search.queries.searchEntities, {
+    orgSlug,
+    query,
+    limit: optionalNumber(options.limit, "limit") ?? 8
+  });
+  printOutput(result.issues ?? [], runtime.json);
+});
+serviceCommand.command("attach-process").description("Attach a detected local process to an issue").requiredOption("--issue-id <id>").requiredOption("--device-id <id>").requiredOption("--process-id <id>").requiredOption("--provider <provider>").option("--title <title>").action(async (options, command) => {
+  const { client, runtime } = await getClient(command);
+  const liveActivityId = await runMutation(
+    client,
+    api.agentBridge.mutations.attachLiveActivity,
+    {
+      issueId: options.issueId,
+      deviceId: options.deviceId,
+      processId: options.processId,
+      provider: parseAgentProvider(options.provider),
+      title: options.title?.trim() || void 0
+    }
+  );
+  printOutput({ ok: true, liveActivityId }, runtime.json);
+});
+serviceCommand.command("install").description("Install the bridge as a system service (macOS LaunchAgent)").action(async (_options, command) => {
+  if (osPlatform() !== "darwin") {
+    console.error("Service install is currently macOS only (LaunchAgent).");
+    console.error("On Linux, use systemd --user manually for now.");
+    return;
+  }
+  const { spinner } = await import("@clack/prompts");
+  const s = spinner();
+  s.start("Ensuring device registration...");
+  const config = await ensureBridgeConfig(command);
+  s.stop(`Device ready: ${config.displayName}`);
+  s.start("Installing LaunchAgent...");
+  const vcliPath = process.argv[1] ?? "vcli";
+  installLaunchAgent(vcliPath);
+  s.stop("LaunchAgent installed");
+  s.start("Starting bridge service...");
+  loadLaunchAgent();
+  s.stop("Bridge service started");
+  console.log("");
+  console.log(
+    "Bridge installed and running. Will start automatically on login."
+  );
+});
+serviceCommand.command("uninstall").description("Stop the bridge and uninstall the system service").action(() => {
+  stopBridge({ includeMenuBar: true });
+  uninstallLaunchAgent();
+  stopMenuBar();
+  console.log("Bridge stopped and service uninstalled.");
+});
+serviceCommand.command("logs").description("Show bridge service logs").action(async () => {
+  const fs7 = await import("fs");
+  const p = await import("path");
+  const logPath = p.join(VECTOR_HOME, "bridge.log");
+  if (fs7.existsSync(logPath)) {
+    const content = fs7.readFileSync(logPath, "utf-8");
+    const lines = content.split("\n");
+    console.log(lines.slice(-50).join("\n"));
+  } else {
+    console.log(`No log file found at ${logPath}`);
+  }
+});
+serviceCommand.command("enable").description("Enable bridge to start at login (macOS LaunchAgent)").action(async () => {
+  if (osPlatform() !== "darwin") {
+    console.error("Login item is macOS only.");
+    return;
+  }
+  const vcliPath = process.argv[1] ?? "vcli";
+  installLaunchAgent(vcliPath);
+  loadLaunchAgent();
+  console.log("Bridge will start automatically on login.");
+});
+serviceCommand.command("disable").description("Disable bridge from starting at login").action(() => {
+  uninstallLaunchAgent();
+  stopMenuBar();
+  console.log("Bridge will no longer start at login.");
+});
+var bridgeCommand = program.command("bridge").description("Start/stop the local agent bridge");
+bridgeCommand.command("start").description("Register device, install service, and start the bridge").action(async (_options, command) => {
+  const existingConfig = loadBridgeConfig();
+  const config = await ensureBridgeConfig(command);
+  if (!existingConfig || existingConfig.deviceId !== config.deviceId || existingConfig.userId !== config.userId) {
+    console.log(
+      `Device registered: ${config.displayName} (${config.deviceId})`
+    );
+  }
+  if (osPlatform() === "darwin") {
+    const vcliPath = process.argv[1] ?? "vcli";
+    installLaunchAgent(vcliPath);
+    loadLaunchAgent();
+    console.log("\nBridge installed and started as LaunchAgent.");
+    console.log("It will restart automatically on login.");
+    console.log("Run `vcli service status` to check.");
+  } else {
+    console.log("Starting bridge in foreground...");
+    const bridge = new BridgeService(config);
+    await bridge.run();
+  }
+});
+bridgeCommand.command("stop").description("Stop the bridge service").action(() => {
+  let unloaded = false;
+  if (osPlatform() === "darwin") {
+    uninstallLaunchAgent();
+    unloaded = true;
+  }
+  if (stopBridge() || unloaded) {
+    console.log("Bridge stopped.");
+  } else {
+    console.log("Bridge is not running.");
+  }
+});
+bridgeCommand.command("status").description("Show bridge status").action(() => {
+  const s = getBridgeStatus();
+  if (!s.configured) {
+    console.log("Bridge not configured. Run: vcli bridge start");
+    return;
+  }
+  console.log("Vector Bridge");
+  console.log(`  Device:  ${s.config.displayName} (${s.config.deviceId})`);
+  console.log(
+    `  Status:  ${s.running ? `Running (PID ${s.pid})` : "Not running"}`
+  );
+});
 async function main() {
   await program.parseAsync(process.argv);
 }