@wingman-ai/gateway 0.3.0 → 0.3.1

package/dist/cli/commands/browser.cjs

@@ -0,0 +1,603 @@
+"use strict";
+const __rslib_import_meta_url__ = /*#__PURE__*/ function() {
+    return "u" < typeof document ? new (require('url'.replace('', ''))).URL('file:' + __filename).href : document.currentScript && document.currentScript.src || new URL('main.js', document.baseURI).href;
+}();
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    executeBrowserCommand: ()=>executeBrowserCommand
+});
+const external_node_fs_namespaceObject = require("node:fs");
+const external_node_child_process_namespaceObject = require("node:child_process");
+const external_node_crypto_namespaceObject = require("node:crypto");
+const external_node_path_namespaceObject = require("node:path");
+const external_node_url_namespaceObject = require("node:url");
+const external_logger_cjs_namespaceObject = require("../../logger.cjs");
+const outputManager_cjs_namespaceObject = require("../core/outputManager.cjs");
+const DEFAULT_CONFIG_DIR = ".wingman";
+const DEFAULT_PROFILES_DIR = ".wingman/browser-profiles";
+const DEFAULT_EXTENSIONS_DIR = ".wingman/browser-extensions";
+const DEFAULT_BUNDLED_EXTENSION_ID = "wingman";
+const BUNDLED_EXTENSION_RELATIVE_PATH = "../../../extensions/wingman-browser-extension";
+const PROFILE_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
+async function executeBrowserCommand(args, options = {}) {
+    const outputManager = new outputManager_cjs_namespaceObject.OutputManager(args.outputMode);
+    try {
+        switch(args.subcommand){
+            case "profile":
+                await executeBrowserProfileCommand(args, outputManager, options);
+                break;
+            case "extension":
+                await executeBrowserExtensionCommand(args, outputManager, options);
+                break;
+            case "":
+            case "help":
+            case "--help":
+            case "-h":
+                showBrowserHelp(outputManager);
+                break;
+            default:
+                throw new Error(`Unknown subcommand: ${args.subcommand}. Run 'wingman browser help' for usage.`);
+        }
+    } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const logFile = (0, external_logger_cjs_namespaceObject.getLogFilePath)();
+        (0, external_logger_cjs_namespaceObject.createLogger)().error("Browser command failed", {
+            error: message
+        });
+        if ("interactive" === outputManager.getMode()) {
+            console.error(`\nError: ${message}`);
+            console.error(`Logs: ${logFile}`);
+            process.exit(1);
+        } else {
+            outputManager.emitAgentError(error);
+            process.exit(1);
+        }
+    }
+}
+async function executeBrowserProfileCommand(args, outputManager, options) {
+    const action = args.args[0] || "";
+    switch(action){
+        case "init":
+            await handleProfileInit(args, outputManager, options);
+            break;
+        case "open":
+            await handleProfileOpen(args, outputManager, options);
+            break;
+        case "":
+        case "help":
+        case "--help":
+        case "-h":
+            showBrowserProfileHelp(outputManager);
+            break;
+        default:
+            throw new Error(`Unknown browser profile subcommand: ${action}. Run 'wingman browser profile help' for usage.`);
+    }
+}
+async function executeBrowserExtensionCommand(args, outputManager, options) {
+    const action = args.args[0] || "";
+    switch(action){
+        case "install":
+            await handleExtensionInstall(args, outputManager, options);
+            break;
+        case "path":
+            await handleExtensionPath(args, outputManager, options);
+            break;
+        case "list":
+            await handleExtensionList(args, outputManager, options);
+            break;
+        case "pair":
+            await handleExtensionPair(args, outputManager, options);
+            break;
+        case "":
+        case "help":
+        case "--help":
+        case "-h":
+            showBrowserExtensionHelp(outputManager);
+            break;
+        default:
+            throw new Error(`Unknown browser extension subcommand: ${action}. Run 'wingman browser extension help' for usage.`);
+    }
+}
+async function handleProfileInit(args, outputManager, options) {
+    const profileArg = getPositionalArg(args.args, 1);
+    if (!profileArg) throw new Error("Profile ID required. Usage: wingman browser profile init <profile-id>");
+    const profileId = validateProfileId(profileArg);
+    const workspace = options.workspace || process.cwd();
+    const configDir = options.configDir || DEFAULT_CONFIG_DIR;
+    const configRoot = (0, external_node_path_namespaceObject.join)(workspace, configDir);
+    const configPath = (0, external_node_path_namespaceObject.join)(configRoot, "wingman.config.json");
+    const config = readConfigObject(configPath);
+    const browserConfig = readObject(config.browser);
+    const profiles = readStringRecord(browserConfig.profiles);
+    const force = getBooleanOption(args.options, "force");
+    const profilesDirOption = getStringOption(args.options, "profiles-dir") || getStringOption(args.options, "profilesDir");
+    if (profilesDirOption) browserConfig.profilesDir = profilesDirOption;
+    const baseProfilesDir = resolveProfilesDir(browserConfig.profilesDir);
+    const profilePathOption = getStringOption(args.options, "path");
+    const profilePath = profilePathOption ? profilePathOption : normalizePathForConfig((0, external_node_path_namespaceObject.join)(baseProfilesDir, profileId));
+    const existingProfilePath = profiles[profileId];
+    if (existingProfilePath && existingProfilePath !== profilePath && !force) throw new Error(`Browser profile "${profileId}" already exists at ${existingProfilePath}. Use --force to overwrite.`);
+    profiles[profileId] = profilePath;
+    browserConfig.profiles = profiles;
+    browserConfig.profilesDir = baseProfilesDir;
+    const requestedDefault = getBooleanOption(args.options, "default");
+    const shouldSetDefault = requestedDefault || "string" != typeof browserConfig.defaultProfile;
+    if (shouldSetDefault) browserConfig.defaultProfile = profileId;
+    config.browser = browserConfig;
+    const absoluteProfilePath = resolveProfilePath(workspace, profilePath);
+    (0, external_node_fs_namespaceObject.mkdirSync)(absoluteProfilePath, {
+        recursive: true
+    });
+    (0, external_node_fs_namespaceObject.mkdirSync)(configRoot, {
+        recursive: true
+    });
+    (0, external_node_fs_namespaceObject.writeFileSync)(configPath, JSON.stringify(config, null, 2));
+    writeLine(outputManager, `Initialized browser profile "${profileId}".`);
+    writeLine(outputManager, `Profile directory: ${absoluteProfilePath}`);
+    if (shouldSetDefault) writeLine(outputManager, `Default browser profile: ${profileId}`);
+    writeLine(outputManager, `Saved config: ${configPath}`);
+}
+async function handleProfileOpen(args, outputManager, options) {
+    const workspace = options.workspace || process.cwd();
+    const configDir = options.configDir || DEFAULT_CONFIG_DIR;
+    const configRoot = (0, external_node_path_namespaceObject.join)(workspace, configDir);
+    const configPath = (0, external_node_path_namespaceObject.join)(configRoot, "wingman.config.json");
+    const config = readConfigObject(configPath);
+    const browserConfig = readObject(config.browser);
+    const requestedProfile = getPositionalArg(args.args, 1);
+    const defaultProfile = "string" == typeof browserConfig.defaultProfile ? browserConfig.defaultProfile.trim() : "";
+    const resolvedProfileId = validateProfileId(requestedProfile || defaultProfile || "");
+    const profiles = readStringRecord(browserConfig.profiles);
+    const profilePath = profiles[resolvedProfileId] || normalizePathForConfig((0, external_node_path_namespaceObject.join)(resolveProfilesDir(browserConfig.profilesDir), resolvedProfileId));
+    const absoluteProfilePath = resolveProfilePath(workspace, profilePath);
+    (0, external_node_fs_namespaceObject.mkdirSync)(absoluteProfilePath, {
+        recursive: true
+    });
+    const url = getStringOption(args.options, "url") || getStringOption(args.options, "target-url") || "https://example.com";
+    const headless = getBooleanOption(args.options, "headless");
+    const explicitExecutablePath = getStringOption(args.options, "executable-path") || getStringOption(args.options, "executablePath");
+    const resolveExecutable = options.resolveExecutablePath || resolveChromeExecutablePath;
+    const executablePath = resolveExecutable(explicitExecutablePath);
+    const defaultExtensionIds = readStringArray(browserConfig.defaultExtensions);
+    const extensionArgs = resolveExtensionArgs(workspace, browserConfig, defaultExtensionIds);
+    const chromeArgs = [
+        `--user-data-dir=${absoluteProfilePath}`,
+        "--no-default-browser-check",
+        "--no-first-run",
+        "--disable-background-networking",
+        "--disable-sync",
+        "--mute-audio",
+        ...extensionArgs
+    ];
+    if (headless) chromeArgs.push("--headless=new");
+    chromeArgs.push(url);
+    const spawnProcess = options.spawnProcess || external_node_child_process_namespaceObject.spawn;
+    const chromeProcess = spawnProcess(executablePath, chromeArgs, {
+        detached: true,
+        stdio: "ignore"
+    });
+    chromeProcess.unref();
+    writeLine(outputManager, `Opened profile "${resolvedProfileId}" at ${url} using ${absoluteProfilePath}`);
+    if (defaultExtensionIds.length > 0) writeLine(outputManager, `Loaded default extension(s): ${defaultExtensionIds.join(", ")}`);
+}
+async function handleExtensionInstall(args, outputManager, options) {
+    const extensionArg = getPositionalArg(args.args, 1);
+    const extensionIdOption = getStringOption(args.options, "id");
+    const extensionPathOption = getStringOption(args.options, "path");
+    const sourcePathOption = getStringOption(args.options, "source") || getStringOption(args.options, "from");
+    const selectedId = extensionArg || extensionIdOption;
+    const shouldInstallBundled = !selectedId && !extensionPathOption && !sourcePathOption;
+    if (!selectedId && !shouldInstallBundled) throw new Error("Extension ID required when using --source/--path. Usage: wingman browser extension install [extension-id] [options]");
+    const extensionId = validateProfileId(selectedId || DEFAULT_BUNDLED_EXTENSION_ID);
+    const workspace = options.workspace || process.cwd();
+    const configDir = options.configDir || DEFAULT_CONFIG_DIR;
+    const configRoot = (0, external_node_path_namespaceObject.join)(workspace, configDir);
+    const configPath = (0, external_node_path_namespaceObject.join)(configRoot, "wingman.config.json");
+    const config = readConfigObject(configPath);
+    const browserConfig = readObject(config.browser);
+    const force = getBooleanOption(args.options, "force");
+    const extensions = readStringRecord(browserConfig.extensions);
+    const extensionsDirOption = getStringOption(args.options, "extensions-dir") || getStringOption(args.options, "extensionsDir");
+    if (extensionsDirOption) browserConfig.extensionsDir = extensionsDirOption;
+    const extensionsDir = resolveExtensionsDir(browserConfig.extensionsDir);
+    const extensionPath = extensionPathOption ? extensionPathOption : normalizePathForConfig((0, external_node_path_namespaceObject.join)(extensionsDir, extensionId));
+    const absoluteExtensionPath = resolveProfilePath(workspace, extensionPath);
+    const sourcePath = sourcePathOption || (shouldInstallBundled ? resolveBundledExtensionSourcePath() : void 0);
+    if (sourcePath) {
+        const absoluteSourcePath = resolveProfilePath(workspace, sourcePath);
+        if (!(0, external_node_fs_namespaceObject.existsSync)(absoluteSourcePath)) throw new Error(`Extension source does not exist: ${absoluteSourcePath}`);
+        if (!(0, external_node_fs_namespaceObject.statSync)(absoluteSourcePath).isDirectory()) throw new Error(`Extension source must be a directory: ${absoluteSourcePath}`);
+        if ((0, external_node_fs_namespaceObject.existsSync)(absoluteExtensionPath) && !force) throw new Error(`Extension target already exists at ${absoluteExtensionPath}. Use --force to overwrite.`);
+        (0, external_node_fs_namespaceObject.cpSync)(absoluteSourcePath, absoluteExtensionPath, {
+            recursive: true,
+            force
+        });
+    }
+    if (!(0, external_node_fs_namespaceObject.existsSync)(absoluteExtensionPath)) throw new Error(`Extension path does not exist: ${absoluteExtensionPath}. Provide --source or --path to an unpacked extension directory.`);
+    if (!(0, external_node_fs_namespaceObject.statSync)(absoluteExtensionPath).isDirectory()) throw new Error(`Extension path must be a directory: ${absoluteExtensionPath}.`);
+    const manifestPath = (0, external_node_path_namespaceObject.join)(absoluteExtensionPath, "manifest.json");
+    if (!(0, external_node_fs_namespaceObject.existsSync)(manifestPath)) throw new Error(`manifest.json not found in extension directory: ${absoluteExtensionPath}.`);
+    const existingExtensionPath = extensions[extensionId];
+    if (existingExtensionPath && existingExtensionPath !== extensionPath && !force) throw new Error(`Extension "${extensionId}" already exists at ${existingExtensionPath}. Use --force to overwrite.`);
+    extensions[extensionId] = extensionPath;
+    browserConfig.extensions = extensions;
+    browserConfig.extensionsDir = extensionsDir;
+    const setAsDefault = getBooleanOption(args.options, "default");
+    if (setAsDefault) {
+        const defaults = new Set(readStringArray(browserConfig.defaultExtensions));
+        defaults.add(extensionId);
+        browserConfig.defaultExtensions = Array.from(defaults);
+    }
+    config.browser = browserConfig;
+    (0, external_node_fs_namespaceObject.mkdirSync)(configRoot, {
+        recursive: true
+    });
+    (0, external_node_fs_namespaceObject.writeFileSync)(configPath, JSON.stringify(config, null, 2));
+    writeLine(outputManager, `Registered extension "${extensionId}".`);
+    writeLine(outputManager, `Extension directory: ${absoluteExtensionPath}`);
+    if (shouldInstallBundled) writeLine(outputManager, `Installed bundled Wingman extension as "${extensionId}".`);
+    if (setAsDefault) writeLine(outputManager, `Added "${extensionId}" to browser.defaultExtensions`);
+    writeLine(outputManager, `Saved config: ${configPath}`);
+}
+async function handleExtensionPath(args, outputManager, options) {
+    const extensionArg = getPositionalArg(args.args, 1);
+    if (!extensionArg) throw new Error("Extension ID required. Usage: wingman browser extension path <extension-id>");
+    const extensionId = validateProfileId(extensionArg);
+    const workspace = options.workspace || process.cwd();
+    const configDir = options.configDir || DEFAULT_CONFIG_DIR;
+    const configRoot = (0, external_node_path_namespaceObject.join)(workspace, configDir);
+    const configPath = (0, external_node_path_namespaceObject.join)(configRoot, "wingman.config.json");
+    const config = readConfigObject(configPath);
+    const browserConfig = readObject(config.browser);
+    const extensions = readStringRecord(browserConfig.extensions);
+    const configuredPath = extensions[extensionId];
+    if (!configuredPath) throw new Error(`Extension "${extensionId}" is not configured. Run wingman browser extension install ${extensionId} --path <dir> first.`);
+    const absoluteExtensionPath = resolveProfilePath(workspace, configuredPath);
+    writeLine(outputManager, absoluteExtensionPath);
+}
+async function handleExtensionList(args, outputManager, options) {
+    const workspace = options.workspace || process.cwd();
+    const configDir = options.configDir || DEFAULT_CONFIG_DIR;
+    const configRoot = (0, external_node_path_namespaceObject.join)(workspace, configDir);
+    const configPath = (0, external_node_path_namespaceObject.join)(configRoot, "wingman.config.json");
+    const config = readConfigObject(configPath);
+    const browserConfig = readObject(config.browser);
+    const extensions = readStringRecord(browserConfig.extensions);
+    const defaults = new Set(readStringArray(browserConfig.defaultExtensions));
+    const entries = Object.entries(extensions);
+    if (0 === entries.length) return void writeLine(outputManager, "No browser extensions configured.");
+    for (const [extensionId, extensionPath] of entries){
+        const marker = defaults.has(extensionId) ? " (default)" : "";
+        writeLine(outputManager, `${extensionId}${marker}: ${extensionPath}`);
+    }
+}
+async function handleExtensionPair(args, outputManager, options) {
+    const workspace = options.workspace || process.cwd();
+    const configDir = options.configDir || DEFAULT_CONFIG_DIR;
+    const configRoot = (0, external_node_path_namespaceObject.join)(workspace, configDir);
+    const configPath = (0, external_node_path_namespaceObject.join)(configRoot, "wingman.config.json");
+    const config = readConfigObject(configPath);
+    const browserConfig = readObject(config.browser);
+    const relayConfig = readObject(browserConfig.relay);
+    const relayHost = getStringOption(args.options, "host") || "127.0.0.1";
+    if (![
+        "127.0.0.1",
+        "localhost",
+        "::1"
+    ].includes(relayHost)) throw new Error(`Relay host must be loopback (127.0.0.1, localhost, ::1). Received "${relayHost}".`);
+    const relayPort = getNumberOption(args.options, "port") || ("number" == typeof relayConfig.port ? relayConfig.port : 18792);
+    if (!Number.isInteger(relayPort) || relayPort < 1 || relayPort > 65535) throw new Error("Relay port must be an integer between 1 and 65535.");
+    const configuredToken = getStringOption(args.options, "token");
+    const token = configuredToken || createRelayToken();
+    if (token.length < 16) throw new Error("Relay token must be at least 16 characters.");
+    relayConfig.enabled = true;
+    relayConfig.host = relayHost;
+    relayConfig.port = relayPort;
+    relayConfig.requireAuth = true;
+    relayConfig.authToken = token;
+    if ("number" != typeof relayConfig.maxMessageBytes) relayConfig.maxMessageBytes = 262144;
+    browserConfig.relay = relayConfig;
+    const extensionsDir = resolveExtensionsDir(browserConfig.extensionsDir);
+    const extensions = readStringRecord(browserConfig.extensions);
+    if (!extensions[DEFAULT_BUNDLED_EXTENSION_ID]) {
+        const extensionPath = normalizePathForConfig((0, external_node_path_namespaceObject.join)(extensionsDir, DEFAULT_BUNDLED_EXTENSION_ID));
+        const absoluteExtensionPath = resolveProfilePath(workspace, extensionPath);
+        const bundledSourcePath = resolveBundledExtensionSourcePath();
+        (0, external_node_fs_namespaceObject.mkdirSync)(absoluteExtensionPath, {
+            recursive: true
+        });
+        (0, external_node_fs_namespaceObject.cpSync)(bundledSourcePath, absoluteExtensionPath, {
+            recursive: true,
+            force: true
+        });
+        extensions[DEFAULT_BUNDLED_EXTENSION_ID] = extensionPath;
+    }
+    browserConfig.extensions = extensions;
+    browserConfig.extensionsDir = extensionsDir;
+    const defaults = new Set(readStringArray(browserConfig.defaultExtensions));
+    defaults.add(DEFAULT_BUNDLED_EXTENSION_ID);
+    browserConfig.defaultExtensions = Array.from(defaults);
+    config.browser = browserConfig;
+    (0, external_node_fs_namespaceObject.mkdirSync)(configRoot, {
+        recursive: true
+    });
+    (0, external_node_fs_namespaceObject.writeFileSync)(configPath, JSON.stringify(config, null, 2));
+    writeLine(outputManager, "Configured secure browser relay pairing.");
+    writeLine(outputManager, `Relay host: ${relayHost}`);
+    writeLine(outputManager, `Relay port: ${relayPort}`);
+    writeLine(outputManager, `Relay token: ${token}`);
+    writeLine(outputManager, `Saved config: ${configPath}`);
+    writeLine(outputManager, "Next: open the extension options page and set the same relay token.");
+}
+function showBrowserHelp(outputManager) {
+    if ("interactive" === outputManager.getMode()) return void console.log(`
+Wingman Browser Tools
+
+Usage:
+  wingman browser profile init <profile-id> [options]
+  wingman browser profile open [profile-id] [options]
+  wingman browser extension install [extension-id] [options]
+  wingman browser extension pair [options]
+  wingman browser extension path <extension-id>
+  wingman browser extension list
+  wingman browser extension help
+  wingman browser profile help
+  wingman browser help
+
+Examples:
+  wingman browser profile init trading
+  wingman browser profile open trading --url https://robinhood.com/login
+  wingman browser extension install --default
+  wingman browser extension pair
+  wingman browser extension install relay --source ./my-extension --default
+  wingman browser extension path relay
+  wingman browser profile init shopping --default
+  wingman browser profile init work --path .wingman/profiles/work
+
+Options:
+  --workspace <dir>          Workspace root (defaults to nearest ancestor with .wingman/)
+  --path <dir>               Path for profile/extension (relative to workspace or absolute)
+  --profiles-dir <dir>       Base profile directory used when --path is omitted
+  --extensions-dir <dir>     Base extension directory used when --path is omitted
+  --source <dir>             Source directory to copy from during extension install
+  --url <url>                Target URL for profile open
+  --headless                 Open profile in headless mode
+  --default                  Set as browser.defaultProfile or add to browser.defaultExtensions
+  --force                    Overwrite existing profile/extension mapping
+  --host <host>              Relay host for extension pairing (must be loopback)
+  --port <port>              Relay port for extension pairing
+  --token <token>            Explicit relay token for extension pairing
+`);
+    outputManager.emitLog("info", "Browser help requested");
+}
+function showBrowserProfileHelp(outputManager) {
+    if ("interactive" === outputManager.getMode()) return void console.log(`
+Wingman Browser Profile Manager
+
+Usage:
+  wingman browser profile init <profile-id> [options]
+  wingman browser profile open [profile-id] [options]
+  wingman browser profile help
+
+Examples:
+  wingman browser profile init trading
+  wingman browser profile init work --path .wingman/profiles/work --default
+  wingman browser profile open trading --url https://robinhood.com/login
+`);
+    outputManager.emitLog("info", "Browser profile help requested");
+}
+function showBrowserExtensionHelp(outputManager) {
+    if ("interactive" === outputManager.getMode()) return void console.log(`
+Wingman Browser Extension Manager
+
+Usage:
+  wingman browser extension install [extension-id] [options]
+  wingman browser extension pair [options]
+  wingman browser extension path <extension-id>
+  wingman browser extension list
+  wingman browser extension help
+
+Examples:
+  wingman browser extension install --default
+  wingman browser extension pair
+  wingman browser extension install relay --path .wingman/browser-extensions/relay
+  wingman browser extension install relay --source ./relay-extension --default
+  wingman browser extension path relay
+  wingman browser extension list
+`);
+    outputManager.emitLog("info", "Browser extension help requested");
+}
+function readConfigObject(configPath) {
+    if (!(0, external_node_fs_namespaceObject.existsSync)(configPath)) return {};
+    const raw = (0, external_node_fs_namespaceObject.readFileSync)(configPath, "utf-8");
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    } catch  {
+        throw new Error("Existing wingman.config.json is invalid JSON. Fix the file or run wingman init --force.");
+    }
+    if (!isObject(parsed)) throw new Error("Existing wingman.config.json must be a JSON object.");
+    return {
+        ...parsed
+    };
+}
+function resolveProfilesDir(rawProfilesDir) {
+    if ("string" == typeof rawProfilesDir && rawProfilesDir.trim()) return rawProfilesDir.trim();
+    return DEFAULT_PROFILES_DIR;
+}
+function resolveExtensionsDir(rawExtensionsDir) {
+    if ("string" == typeof rawExtensionsDir && rawExtensionsDir.trim()) return rawExtensionsDir.trim();
+    return DEFAULT_EXTENSIONS_DIR;
+}
+function validateProfileId(value) {
+    const profileId = value.trim();
+    if (!profileId) throw new Error("Profile ID cannot be empty.");
+    if (!PROFILE_ID_PATTERN.test(profileId)) throw new Error(`Invalid profile ID "${value}". Use letters, numbers, dot, underscore, or dash.`);
+    return profileId;
+}
+function isObject(value) {
+    return Boolean(value) && "object" == typeof value && !Array.isArray(value);
+}
+function readObject(value) {
+    if (!isObject(value)) return {};
+    return {
+        ...value
+    };
+}
+function readStringRecord(value) {
+    if (!isObject(value)) return {};
+    const result = {};
+    for (const [key, innerValue] of Object.entries(value))if (key.trim() && "string" == typeof innerValue) result[key] = innerValue;
+    return result;
+}
+function readStringArray(value) {
+    if (!Array.isArray(value)) return [];
+    return value.filter((item)=>"string" == typeof item).map((item)=>item.trim()).filter(Boolean);
+}
+function getStringOption(options, key) {
+    const value = options[key];
+    if ("string" == typeof value && value.trim()) return value.trim();
+}
+function getNumberOption(options, key) {
+    const value = options[key];
+    if ("number" == typeof value && Number.isFinite(value)) return value;
+    if ("string" == typeof value) {
+        const parsed = Number.parseInt(value.trim(), 10);
+        if (Number.isFinite(parsed)) return parsed;
+    }
+}
+function getBooleanOption(options, key) {
+    const value = options[key];
+    if ("boolean" == typeof value) return value;
+    if ("string" == typeof value) {
+        const normalized = value.trim().toLowerCase();
+        if ([
+            "true",
+            "1",
+            "yes",
+            "y",
+            "on"
+        ].includes(normalized)) return true;
+        [
+            "false",
+            "0",
+            "no",
+            "n",
+            "off"
+        ].includes(normalized);
+    }
+    return false;
+}
+function getPositionalArg(args, index) {
+    const value = args[index];
+    if ("string" != typeof value) return;
+    const trimmed = value.trim();
+    if (!trimmed || trimmed.startsWith("--")) return;
+    return trimmed;
+}
+function normalizePathForConfig(pathValue) {
+    if ((0, external_node_path_namespaceObject.isAbsolute)(pathValue)) return pathValue;
+    return pathValue.split("\\").join("/");
+}
+function resolveProfilePath(workspace, profilePath) {
+    if ((0, external_node_path_namespaceObject.isAbsolute)(profilePath)) return profilePath;
+    return (0, external_node_path_namespaceObject.resolve)(workspace, profilePath);
+}
+function resolveBundledExtensionSourcePath() {
+    const bundledPath = (0, external_node_path_namespaceObject.resolve)((0, external_node_url_namespaceObject.fileURLToPath)(new URL(BUNDLED_EXTENSION_RELATIVE_PATH, __rslib_import_meta_url__)));
+    const bundledManifest = (0, external_node_path_namespaceObject.join)(bundledPath, "manifest.json");
+    if ((0, external_node_fs_namespaceObject.existsSync)(bundledManifest)) return bundledPath;
+    throw new Error("Bundled Wingman extension assets were not found. Reinstall Wingman or provide --source <dir>.");
+}
+function createRelayToken() {
+    return (0, external_node_crypto_namespaceObject.randomBytes)(24).toString("base64url");
+}
+function resolveExtensionArgs(workspace, browserConfig, extensionIds) {
+    if (0 === extensionIds.length) return [
+        "--disable-extensions"
+    ];
+    const extensions = readStringRecord(browserConfig.extensions);
+    const dirs = extensionIds.map((extensionId)=>{
+        const configuredPath = extensions[extensionId];
+        if (!configuredPath) throw new Error(`Extension "${extensionId}" is not configured in browser.extensions.`);
+        const absolutePath = resolveProfilePath(workspace, configuredPath);
+        if (!(0, external_node_fs_namespaceObject.existsSync)(absolutePath)) throw new Error(`Configured extension path does not exist: ${absolutePath}.`);
+        return absolutePath;
+    });
+    const joined = dirs.join(",");
+    return [
+        `--disable-extensions-except=${joined}`,
+        `--load-extension=${joined}`
+    ];
+}
+function getChromeCandidates() {
+    const candidates = [
+        process.env.WINGMAN_CHROME_EXECUTABLE,
+        "google-chrome",
+        "chromium-browser",
+        "chromium"
+    ].filter((candidate)=>Boolean(candidate?.trim()));
+    if ("darwin" === process.platform) candidates.push("/Applications/Google Chrome.app/Contents/MacOS/Google Chrome", "/Applications/Chromium.app/Contents/MacOS/Chromium");
+    if ("linux" === process.platform) candidates.push("/usr/bin/google-chrome", "/usr/bin/google-chrome-stable", "/usr/bin/chromium-browser", "/usr/bin/chromium");
+    if ("win32" === process.platform) candidates.push("C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe", "C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe");
+    return candidates;
+}
+function resolveBinaryFromPath(binaryName) {
+    const locator = "win32" === process.platform ? "where" : "which";
+    const result = (0, external_node_child_process_namespaceObject.spawnSync)(locator, [
+        binaryName
+    ], {
+        encoding: "utf-8"
+    });
+    if (0 !== result.status || !result.stdout) return null;
+    const firstLine = result.stdout.split(/\r?\n/).map((line)=>line.trim()).find(Boolean);
+    return firstLine || null;
+}
+function resolveChromeExecutablePath(explicitPath) {
+    const candidatePool = explicitPath?.trim() ? [
+        explicitPath.trim()
+    ] : getChromeCandidates();
+    for (const candidate of candidatePool)if (candidate) {
+        if ((0, external_node_path_namespaceObject.isAbsolute)(candidate) && (0, external_node_fs_namespaceObject.existsSync)(candidate)) return candidate;
+        if (!(0, external_node_path_namespaceObject.isAbsolute)(candidate)) {
+            const fromPath = resolveBinaryFromPath(candidate);
+            if (fromPath) return fromPath;
+        }
+    }
+    if (explicitPath?.trim()) throw new Error(`Chrome executable not found at "${explicitPath}". Provide a valid executable path.`);
+    throw new Error("No Chrome/Chromium executable found. Install Chrome/Chromium or set WINGMAN_CHROME_EXECUTABLE.");
+}
+function writeLine(outputManager, message) {
+    if ("interactive" === outputManager.getMode()) console.log(message);
+    else outputManager.emitLog("info", message);
+}
+exports.executeBrowserCommand = __webpack_exports__.executeBrowserCommand;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "executeBrowserCommand"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cli/commands/browser.d.ts

@@ -0,0 +1,13 @@
+import { type SpawnOptions } from "node:child_process";
+import type { BrowserCommandArgs } from "../types/browser.js";
+type BrowserSpawn = (command: string, args: readonly string[], options: SpawnOptions) => {
+    unref: () => void;
+};
+export interface BrowserCommandOptions {
+    workspace?: string;
+    configDir?: string;
+    spawnProcess?: BrowserSpawn;
+    resolveExecutablePath?: (explicitPath?: string) => string;
+}
+export declare function executeBrowserCommand(args: BrowserCommandArgs, options?: BrowserCommandOptions): Promise<void>;
+export {};