@rehpic/vcli 0.1.0-beta.13.1 → 0.1.0-beta.18.1

package/dist/index.js

@@ -1,4 +1,739 @@
 #!/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;
+  }
+});
+
+// ../../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({ [platform]: platformBinary }, { wsl } = {}) {
+  if (wsl && is_wsl_default) {
+    return detectArchBinary(wsl);
+  }
+  if (!platformBinary) {
+    throw new Error(`${platform} is not supported`);
+  }
+  return detectArchBinary(platformBinary);
+}
+var fallbackAttemptSymbol, __dirname, localXdgOpenPath, platform, 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, 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 (platform === "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 (platform === "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 ?? (platform === "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 (platform === "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
 import { readFile as readFile2 } from "fs/promises";
@@ -170,6 +905,64 @@ 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) {
+        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*$/, "")
@@ -404,6 +1197,84 @@ 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)) {
@@ -700,19 +1571,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}${deviceResp.verification_uri}?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(
@@ -1539,13 +2439,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) => {
@@ -1639,14 +2540,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) => {
@@ -1746,15 +2648,16 @@ 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("--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
+    teamKey: options.team
   });
+  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) => {
@@ -1952,14 +2855,29 @@ issueCommand.command("comment <issueKey>").requiredOption("--body <body>").actio
   printOutput(result, 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) => {
@@ -2025,10 +2943,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) => {