@rehpic/vcli 0.1.0-beta.5.1 → 0.1.0-beta.51.1

package/dist/index.js

@@ -1,8 +1,745 @@
 #!/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 } 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;
+  }
+});
 
-// ../../src/cli/index.ts
+// ../../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/index.ts
+import { readFileSync as readFileSync2 } from "fs";
 import { readFile as readFile2 } from "fs/promises";
-import { extname } from "path";
+import { dirname, extname, join as join2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 import { config as loadEnv } from "dotenv";
 import { Command } from "commander";
 import { makeFunctionReference } from "convex/server";
@@ -12,7 +749,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 +789,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 +886,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 +910,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 +989,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 +1007,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;
@@ -255,7 +1054,7 @@ function printOutput(data, json = false) {
   console.log(String(data));
 }
 
-// ../../src/cli/session.ts
+// src/session.ts
 import { mkdir, readFile, rm, writeFile } from "fs/promises";
 import { homedir } from "os";
 import path from "path";
@@ -295,7 +1094,487 @@ function createEmptySession() {
   };
 }
 
-// ../../src/cli/index.ts
+// src/bridge-service.ts
+import { ConvexHttpClient as ConvexHttpClient2 } from "convex/browser";
+import { execSync } from "child_process";
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+  unlinkSync
+} from "fs";
+import { homedir as homedir2, hostname, platform } from "os";
+import { join } from "path";
+import { randomUUID } from "crypto";
+var CONFIG_DIR = join(homedir2(), ".vector");
+var BRIDGE_CONFIG_FILE = join(CONFIG_DIR, "bridge.json");
+var PID_FILE = join(CONFIG_DIR, "bridge.pid");
+var LIVE_ACTIVITIES_CACHE = join(CONFIG_DIR, "live-activities.json");
+var LAUNCHAGENT_DIR = join(homedir2(), "Library", "LaunchAgents");
+var LAUNCHAGENT_PLIST = join(LAUNCHAGENT_DIR, "com.vector.bridge.plist");
+var LAUNCHAGENT_LABEL = "com.vector.bridge";
+var HEARTBEAT_INTERVAL_MS = 3e4;
+var COMMAND_POLL_INTERVAL_MS = 5e3;
+var PROCESS_DISCOVERY_INTERVAL_MS = 6e4;
+function loadBridgeConfig() {
+  if (!existsSync(BRIDGE_CONFIG_FILE)) return null;
+  try {
+    return JSON.parse(readFileSync(BRIDGE_CONFIG_FILE, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function saveBridgeConfig(config) {
+  if (!existsSync(CONFIG_DIR)) mkdirSync(CONFIG_DIR, { recursive: true });
+  writeFileSync(BRIDGE_CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+function discoverLocalProcesses() {
+  const processes = [];
+  const patterns = [
+    {
+      grep: "[c]laude",
+      provider: "claude_code",
+      label: "Claude",
+      prefix: "claude"
+    },
+    { grep: "[c]odex", provider: "codex", label: "Codex", prefix: "codex" }
+  ];
+  for (const { grep, provider, label, prefix } of patterns) {
+    try {
+      const ps = execSync(
+        `ps aux | grep -E '${grep}' | grep -v vector-bridge | grep -v grep`,
+        { encoding: "utf-8", timeout: 5e3 }
+      );
+      for (const line of ps.trim().split("\n").filter(Boolean)) {
+        const pid = line.split(/\s+/)[1];
+        if (!pid) continue;
+        let cwd;
+        try {
+          cwd = execSync(
+            `lsof -p ${pid} 2>/dev/null | grep cwd | awk '{print $NF}'`,
+            { encoding: "utf-8", timeout: 3e3 }
+          ).trim() || void 0;
+        } catch {
+        }
+        const gitInfo = cwd ? getGitInfo(cwd) : {};
+        processes.push({
+          provider,
+          providerLabel: label,
+          localProcessId: pid,
+          sessionKey: `${prefix}-${pid}`,
+          cwd,
+          ...gitInfo,
+          mode: "observed",
+          status: "observed",
+          supportsInboundMessages: false
+        });
+      }
+    } catch {
+    }
+  }
+  return processes;
+}
+function getGitInfo(cwd) {
+  try {
+    const branch = execSync("git rev-parse --abbrev-ref HEAD", {
+      encoding: "utf-8",
+      cwd,
+      timeout: 3e3
+    }).trim();
+    const repoRoot = execSync("git rev-parse --show-toplevel", {
+      encoding: "utf-8",
+      cwd,
+      timeout: 3e3
+    }).trim();
+    return { branch, repoRoot };
+  } catch {
+    return {};
+  }
+}
+function generateReply(userMessage) {
+  const lower = userMessage.toLowerCase().trim();
+  if (["hey", "hi", "hello"].includes(lower)) {
+    return "Hey! I'm running on your local machine via the Vector bridge. What would you like me to work on?";
+  }
+  if (lower.includes("status") || lower.includes("progress")) {
+    return "I'm making good progress. Currently reviewing the changes and running tests.";
+  }
+  if (lower.includes("stop") || lower.includes("cancel")) {
+    return "Understood \u2014 wrapping up the current step.";
+  }
+  return `Got it \u2014 "${userMessage}". I'll incorporate that into my current work.`;
+}
+var BridgeService = class {
+  constructor(config) {
+    this.timers = [];
+    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(`[${ts()}] ${commands.length} pending command(s)`);
+    }
+    for (const cmd of commands) {
+      await this.handleCommand(cmd);
+    }
+  }
+  async handleCommand(cmd) {
+    console.log(`  ${cmd.kind}: ${cmd._id}`);
+    if (cmd.kind === "message" && cmd.liveActivityId) {
+      const payload = cmd.payload;
+      const body = payload?.body ?? "";
+      console.log(`  > "${body}"`);
+      const reply = generateReply(body);
+      await this.client.mutation(
+        api.agentBridge.bridgePublic.postAgentMessage,
+        {
+          deviceId: this.config.deviceId,
+          deviceSecret: this.config.deviceSecret,
+          liveActivityId: cmd.liveActivityId,
+          role: "assistant",
+          body: reply
+        }
+      );
+      console.log(`  < "${reply.slice(0, 60)}..."`);
+    }
+    await this.client.mutation(api.agentBridge.bridgePublic.completeCommand, {
+      deviceId: this.config.deviceId,
+      deviceSecret: this.config.deviceSecret,
+      commandId: cmd._id,
+      status: "delivered"
+    });
+  }
+  async reportProcesses() {
+    const processes = discoverLocalProcesses();
+    for (const proc of processes) {
+      try {
+        await this.client.mutation(api.agentBridge.bridgePublic.reportProcess, {
+          deviceId: this.config.deviceId,
+          deviceSecret: this.config.deviceSecret,
+          ...proc
+        });
+      } catch {
+      }
+    }
+    if (processes.length > 0) {
+      console.log(`[${ts()}] Discovered ${processes.length} local process(es)`);
+    }
+  }
+  async refreshLiveActivities() {
+    try {
+      const activities = await this.client.query(
+        api.agentBridge.bridgePublic.getDeviceLiveActivities,
+        {
+          deviceId: this.config.deviceId,
+          deviceSecret: this.config.deviceSecret
+        }
+      );
+      writeFileSync(LIVE_ACTIVITIES_CACHE, JSON.stringify(activities, null, 2));
+    } catch {
+    }
+  }
+  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 (!existsSync(CONFIG_DIR)) mkdirSync(CONFIG_DIR, { recursive: true });
+    writeFileSync(PID_FILE, String(process.pid));
+    await this.heartbeat();
+    await this.reportProcesses();
+    await this.refreshLiveActivities();
+    console.log(`[${ts()}] Service running. Ctrl+C to stop.
+`);
+    this.timers.push(
+      setInterval(() => {
+        this.heartbeat().catch(
+          (e) => console.error(`[${ts()}] Heartbeat error:`, e.message)
+        );
+        this.refreshLiveActivities().catch(() => {
+        });
+      }, HEARTBEAT_INTERVAL_MS)
+    );
+    this.timers.push(
+      setInterval(() => {
+        this.pollCommands().catch(
+          (e) => console.error(`[${ts()}] Command poll error:`, e.message)
+        );
+      }, COMMAND_POLL_INTERVAL_MS)
+    );
+    this.timers.push(
+      setInterval(() => {
+        this.reportProcesses().catch(
+          (e) => console.error(`[${ts()}] Discovery error:`, e.message)
+        );
+      }, PROCESS_DISCOVERY_INTERVAL_MS)
+    );
+    const shutdown = () => {
+      console.log(`
+[${ts()}] Shutting down...`);
+      for (const t of this.timers) clearInterval(t);
+      try {
+        unlinkSync(PID_FILE);
+      } catch {
+      }
+      process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    await new Promise(() => {
+    });
+  }
+};
+async function setupBridgeDevice(convexUrl, userId) {
+  const client = new ConvexHttpClient2(convexUrl);
+  const deviceKey = `${hostname()}-${randomUUID().slice(0, 8)}`;
+  const deviceSecret = randomUUID();
+  const displayName = `${process.env.USER ?? "user"}'s ${platform() === "darwin" ? "Mac" : "machine"}`;
+  const result = await client.mutation(
+    api.agentBridge.bridgePublic.setupDevice,
+    {
+      userId,
+      deviceKey,
+      deviceSecret,
+      displayName,
+      hostname: hostname(),
+      platform: platform(),
+      cliVersion: "0.1.0",
+      capabilities: ["codex", "claude_code"]
+    }
+  );
+  const config = {
+    deviceId: result.deviceId,
+    deviceKey,
+    deviceSecret,
+    userId,
+    displayName,
+    convexUrl,
+    registeredAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  saveBridgeConfig(config);
+  return config;
+}
+function installLaunchAgent(vcliPath) {
+  if (platform() !== "darwin") {
+    console.error("LaunchAgent is macOS only. Use systemd on Linux.");
+    return;
+  }
+  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>
+  <array>
+    <string>${vcliPath}</string>
+    <string>service</string>
+    <string>run</string>
+  </array>
+  <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>
+    <key>PATH</key>
+    <string>/usr/local/bin:/opt/homebrew/bin:/usr/bin:/bin</string>
+  </dict>
+</dict>
+</plist>`;
+  const menuBarCandidates = [
+    join(CONFIG_DIR, "VectorMenuBar"),
+    "/usr/local/bin/VectorMenuBar",
+    join(homedir2(), ".local", "bin", "VectorMenuBar")
+  ];
+  const menuBarBinary = menuBarCandidates.find((p) => existsSync(p));
+  if (menuBarBinary) {
+    const menuBarPlist = `<?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>com.vector.menubar</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${menuBarBinary}</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <false/>
+</dict>
+</plist>`;
+    const menuBarPlistPath = join(LAUNCHAGENT_DIR, "com.vector.menubar.plist");
+    writeFileSync(menuBarPlistPath, menuBarPlist);
+    try {
+      execSync(`launchctl load ${menuBarPlistPath}`, { stdio: "pipe" });
+      console.log("Menu bar helper installed.");
+    } catch {
+    }
+  }
+  if (!existsSync(LAUNCHAGENT_DIR)) {
+    mkdirSync(LAUNCHAGENT_DIR, { recursive: true });
+  }
+  writeFileSync(LAUNCHAGENT_PLIST, plist);
+  console.log(`Installed LaunchAgent: ${LAUNCHAGENT_PLIST}`);
+}
+function loadLaunchAgent() {
+  try {
+    execSync(`launchctl load ${LAUNCHAGENT_PLIST}`, { stdio: "inherit" });
+    console.log(
+      "LaunchAgent loaded. Bridge will start automatically on login."
+    );
+  } catch {
+    console.error("Failed to load LaunchAgent");
+  }
+}
+function unloadLaunchAgent() {
+  try {
+    execSync(`launchctl unload ${LAUNCHAGENT_PLIST}`, { stdio: "inherit" });
+    console.log("LaunchAgent unloaded.");
+  } catch {
+    console.error("Failed to unload LaunchAgent (may not be loaded)");
+  }
+}
+function uninstallLaunchAgent() {
+  unloadLaunchAgent();
+  try {
+    unlinkSync(LAUNCHAGENT_PLIST);
+    console.log("LaunchAgent removed.");
+  } catch {
+  }
+}
+var MENUBAR_BINARY = join(CONFIG_DIR, "VectorMenuBar");
+var MENUBAR_SWIFT_URL = "https://raw.githubusercontent.com/xrehpicx/vector/main/cli/macos/VectorMenuBar.swift";
+async function ensureMenuBarBinary() {
+  if (platform() !== "darwin") return null;
+  if (existsSync(MENUBAR_BINARY)) return MENUBAR_BINARY;
+  try {
+    execSync("which swiftc", { stdio: "pipe" });
+  } catch {
+    return null;
+  }
+  const localSource = join(
+    process.cwd(),
+    "cli",
+    "macos",
+    "VectorMenuBar.swift"
+  );
+  let swiftSource;
+  if (existsSync(localSource)) {
+    swiftSource = localSource;
+  } else {
+    const downloadPath = join(CONFIG_DIR, "VectorMenuBar.swift");
+    try {
+      execSync(`curl -fsSL "${MENUBAR_SWIFT_URL}" -o "${downloadPath}"`, {
+        stdio: "pipe",
+        timeout: 15e3
+      });
+      swiftSource = downloadPath;
+    } catch {
+      return null;
+    }
+  }
+  try {
+    execSync(
+      `swiftc -o "${MENUBAR_BINARY}" "${swiftSource}" -framework AppKit`,
+      { stdio: "pipe", timeout: 3e4 }
+    );
+    const assetsSource = join(swiftSource, "..", "assets");
+    const assetsDest = join(CONFIG_DIR, "assets");
+    if (existsSync(assetsSource)) {
+      mkdirSync(assetsDest, { recursive: true });
+      for (const f of ["vector-menubar.png", "vector-menubar@2x.png"]) {
+        const src = join(assetsSource, f);
+        if (existsSync(src))
+          writeFileSync(join(assetsDest, f), readFileSync(src));
+      }
+    }
+    return MENUBAR_BINARY;
+  } catch {
+    return null;
+  }
+}
+async function launchMenuBar() {
+  if (platform() !== "darwin") return;
+  const binary = await ensureMenuBarBinary();
+  if (!binary) return;
+  try {
+    const { spawn: spawnChild } = await import("child_process");
+    const child = spawnChild(binary, [], { detached: true, stdio: "ignore" });
+    child.unref();
+    console.log("Menu bar started.");
+  } catch {
+  }
+}
+function getBridgeStatus() {
+  const config = loadBridgeConfig();
+  if (!config) return { configured: false, running: false, starting: false };
+  let running = false;
+  let starting = false;
+  let pid;
+  if (existsSync(PID_FILE)) {
+    const pidStr = readFileSync(PID_FILE, "utf-8").trim();
+    pid = Number(pidStr);
+    try {
+      process.kill(pid, 0);
+      running = true;
+    } catch {
+      running = false;
+    }
+  }
+  if (!running && platform() === "darwin") {
+    try {
+      const result = execSync(
+        `launchctl list ${LAUNCHAGENT_LABEL} 2>/dev/null`,
+        { encoding: "utf-8", timeout: 3e3 }
+      );
+      if (result.includes(LAUNCHAGENT_LABEL)) {
+        starting = true;
+      }
+    } catch {
+    }
+  }
+  return { configured: true, running, starting, pid, config };
+}
+function stopBridge() {
+  if (!existsSync(PID_FILE)) return false;
+  const pid = Number(readFileSync(PID_FILE, "utf-8").trim());
+  try {
+    process.kill(pid, "SIGTERM");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function ts() {
+  return (/* @__PURE__ */ new Date()).toLocaleTimeString();
+}
+
+// src/index.ts
+import { platform as osPlatform } from "os";
 loadEnv({ path: ".env.local", override: false });
 loadEnv({ path: ".env", override: false });
 var cliApi = {
@@ -404,13 +1683,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 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 +1815,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;
@@ -620,7 +2014,16 @@ 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 = readFileSync2(join2(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");
@@ -664,19 +2067,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(
@@ -1047,6 +2479,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 +3004,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 +3105,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 +3213,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 +3420,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 +3519,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 +3564,216 @@ folderCommand.command("delete <folderId>").action(async (folderId, _options, com
   });
   printOutput(result, runtime.json);
 });
+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();
+  let config = loadBridgeConfig();
+  if (!config) {
+    s.start("Registering device...");
+    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) {
+      s.stop("Failed");
+      throw new Error("Not logged in. Run `vcli auth login` first.");
+    }
+    config = await setupBridgeDevice(runtime.convexUrl, user._id);
+    s.stop(`Device registered: ${config.displayName}`);
+  }
+  if (osPlatform() === "darwin") {
+    s.start("Starting bridge service...");
+    const vcliPath = process.argv[1] ?? "vcli";
+    installLaunchAgent(vcliPath);
+    loadLaunchAgent();
+    await launchMenuBar();
+    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) => {
+  let config = loadBridgeConfig();
+  if (!config) {
+    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.");
+    config = await setupBridgeDevice(runtime.convexUrl, user._id);
+  }
+  const bridge = new BridgeService(config);
+  await bridge.run();
+});
+serviceCommand.command("stop").description("Stop the bridge service and menu bar").action(() => {
+  if (osPlatform() === "darwin") {
+    unloadLaunchAgent();
+  }
+  if (stopBridge()) {
+    console.log("Bridge stopped.");
+  } else if (osPlatform() !== "darwin") {
+    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/bridge.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();
+  let config = loadBridgeConfig();
+  if (!config) {
+    s.start("Registering device...");
+    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) {
+      s.stop("Failed");
+      throw new Error("Not logged in. Run `vcli auth login` first.");
+    }
+    config = await setupBridgeDevice(runtime.convexUrl, user._id);
+    s.stop(`Device registered: ${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");
+  s.start("Launching menu bar...");
+  await launchMenuBar();
+  s.stop("Menu bar ready");
+  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();
+  uninstallLaunchAgent();
+  console.log("Bridge stopped and service uninstalled.");
+});
+serviceCommand.command("logs").description("Show bridge service logs").action(async () => {
+  const fs7 = await import("fs");
+  const os2 = await import("os");
+  const p = await import("path");
+  const logPath = p.join(os2.homedir(), ".vector", "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 ~/.vector/bridge.log");
+  }
+});
+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();
+  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) => {
+  let config = loadBridgeConfig();
+  if (!config) {
+    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.");
+    config = await setupBridgeDevice(runtime.convexUrl, user._id);
+    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(() => {
+  if (osPlatform() === "darwin") {
+    uninstallLaunchAgent();
+  }
+  if (stopBridge()) {
+    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);
 }