@agenthippo-ai/agenthippo 0.1.0

package/out/gateway/lifecycle.js

@@ -0,0 +1,3056 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GatewayLifecycleManager = exports.AGENT_ANYWHERE_LABEL = void 0;
+exports.detectGateway = detectGateway;
+/* eslint-disable local/code-no-unexternalized-strings */
+/**
+ * Agent Anywhere -- Gateway Lifecycle Manager
+ *
+ * Detects, installs, starts, stops, and monitors the OpenClaw Gateway process.
+ * All actions are opt-in -- nothing auto-installs or auto-starts without explicit user action.
+ *
+ * Branding: the user-facing feature is called "Agent Anywhere".
+ * Internals still use "gateway" for code references.
+ */
+const vscode = __importStar(require("vscode"));
+const child_process_1 = require("child_process");
+const crypto_1 = require("crypto");
+const util_1 = require("util");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const index_1 = require("../utils/index");
+const agentEnvFile_js_1 = require("../utils/agentEnvFile.js");
+const windowsCommandLine_js_1 = require("../utils/windowsCommandLine.js");
+const gateway_scope_errors_js_1 = require("./gateway-scope-errors.js");
+const openclaw_channel_routing_js_1 = require("./openclaw-channel-routing.js");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
+const IS_WINDOWS = process.platform === "win32";
+const IS_MACOS = process.platform === "darwin";
+function addPathEntries(acc, value) {
+    if (!value) {
+        return;
+    }
+    for (const entry of value.split(path.delimiter)) {
+        const trimmed = entry.trim();
+        if (trimmed.length > 0) {
+            acc.add(trimmed);
+        }
+    }
+}
+/**
+ * Build a resilient PATH for setup terminals launched from signed macOS apps (Finder launch),
+ * where process.env.PATH can be minimal and miss Homebrew/nvm/pnpm locations.
+ */
+function buildAnywhereSetupPath() {
+    const entries = new Set();
+    const home = os.homedir();
+    // Always keep core system paths first.
+    addPathEntries(entries, "/usr/bin:/bin:/usr/sbin:/sbin");
+    addPathEntries(entries, process.env.PATH);
+    const commonDirs = [
+        path.join(home, ".local", "bin"),
+        path.join(home, "Library", "pnpm"),
+        path.join(home, ".local", "share", "pnpm"),
+        path.join(home, ".npm-global", "bin"),
+        path.join(home, ".volta", "bin"),
+        path.join(home, ".fnm"),
+        path.join(home, ".asdf", "shims"),
+        "/opt/homebrew/bin",
+        "/usr/local/bin",
+    ];
+    for (const dir of commonDirs) {
+        if (fs.existsSync(dir)) {
+            entries.add(dir);
+        }
+    }
+    // Include available nvm Node bin dirs (newest first) if present.
+    const nvmDir = process.env.NVM_DIR || path.join(home, ".nvm");
+    const nvmVersionsDir = path.join(nvmDir, "versions", "node");
+    if (fs.existsSync(nvmVersionsDir)) {
+        try {
+            const versions = fs
+                .readdirSync(nvmVersionsDir, { withFileTypes: true })
+                .filter((d) => d.isDirectory())
+                .map((d) => d.name)
+                .sort()
+                .reverse()
+                .slice(0, 8);
+            for (const version of versions) {
+                const binDir = path.join(nvmVersionsDir, version, "bin");
+                if (fs.existsSync(binDir)) {
+                    entries.add(binDir);
+                }
+            }
+        }
+        catch {
+            // Ignore nvm directory read errors; fallback PATH still works.
+        }
+    }
+    return Array.from(entries).join(path.delimiter);
+}
+function getAnywhereSetupShellPath() {
+    if (IS_MACOS && fs.existsSync("/bin/zsh")) {
+        return "/bin/zsh";
+    }
+    return "/bin/bash";
+}
+function getAnywhereSetupShellArgs(command) {
+    // macOS: use login+interactive zsh so ~/.zprofile and ~/.zshrc can expose node/npm/pnpm.
+    if (IS_MACOS) {
+        return ["-lic", command];
+    }
+    // Linux: login bash is enough for common system/profile PATH setups.
+    return ["-lc", command];
+}
+/**
+ * Env for gateway setup terminals: npm's lifecycle runner spawns bare `sh` unless script-shell
+ * is set; @npmcli/run-script can rebuild PATH without /bin when the parent PATH is empty (IDE hosts).
+ */
+function anywhereSetupTerminalEnv() {
+    if (IS_WINDOWS) {
+        return undefined;
+    }
+    return {
+        ...process.env,
+        PATH: buildAnywhereSetupPath(),
+        npm_config_script_shell: "/bin/sh",
+    };
+}
+// ============================================================================
+// Constants
+// ============================================================================
+/** User-facing feature name */
+exports.AGENT_ANYWHERE_LABEL = "Agent Anywhere";
+const AGENT_ANYWHERE_SETUP_TERMINAL = `${exports.AGENT_ANYWHERE_LABEL} Setup`;
+const AGENT_ANYWHERE_UNINSTALL_TERMINAL = `${exports.AGENT_ANYWHERE_LABEL} Uninstall`;
+/** Default gateway port */
+const DEFAULT_PORT = 18789;
+/** Persistent gateway stdout/stderr log (see doStart). */
+const DEFAULT_GATEWAY_LOG_PATH = path.join(os.homedir(), ".openclaw", "gateway.log");
+const OPEN_GATEWAY_LOG_ACTION = "Open Gateway Log";
+function stripAnsi(text) {
+    return text.replace(/\x1b\[[0-9;]*m/g, "");
+}
+/** Last actionable error line from gateway.log for startup failure toasts. */
+function readLastGatewayLogHint(logPath) {
+    try {
+        if (!fs.existsSync(logPath)) {
+            return undefined;
+        }
+        const content = fs.readFileSync(logPath, "utf8");
+        const lines = content.split(/\r?\n/).filter((line) => line.trim());
+        for (let i = lines.length - 1; i >= Math.max(0, lines.length - 50); i--) {
+            const plain = stripAnsi(lines[i]).trim();
+            if (!plain || /Doctor warnings|force: no listeners/i.test(plain)) {
+                continue;
+            }
+            const gatewayFailed = plain.match(/Gateway failed to start:\s*(.+)/i);
+            if (gatewayFailed?.[1]) {
+                return gatewayFailed[1].trim().slice(0, 160);
+            }
+            if (/SecretRefResolutionError|is missing or empty|required secrets are unavailable/i.test(plain)) {
+                return plain.replace(/^\d{4}-\d{2}-\d{2}T[\d:.+-]+\s*/, "").slice(0, 160);
+            }
+            if (/errorCode=|errorMessage=/i.test(plain)) {
+                return plain.slice(0, 160);
+            }
+        }
+    }
+    catch {
+        // ignore read errors
+    }
+    return undefined;
+}
+async function showGatewayStartFailedToast(logPath) {
+    const hint = readLastGatewayLogHint(logPath);
+    const message = hint
+        ? `${exports.AGENT_ANYWHERE_LABEL}: Gateway failed to start. ${hint}`
+        : `${exports.AGENT_ANYWHERE_LABEL}: Gateway failed to start.`;
+    const choice = await vscode.window.showErrorMessage(message, OPEN_GATEWAY_LOG_ACTION);
+    if (choice === OPEN_GATEWAY_LOG_ACTION) {
+        try {
+            const doc = await vscode.workspace.openTextDocument(vscode.Uri.file(logPath));
+            await vscode.window.showTextDocument(doc, { preview: false });
+        }
+        catch (err) {
+            const detail = err instanceof Error ? err.message : String(err);
+            void vscode.window.showErrorMessage(`${exports.AGENT_ANYWHERE_LABEL}: Could not open gateway log (${detail}). Path: ${logPath}`);
+        }
+    }
+}
+/** Health check interval in ms */
+const HEALTH_CHECK_INTERVAL_MS = 30_000;
+/** Gateway startup timeout in ms (Windows cold starts can take longer). */
+const STARTUP_TIMEOUT_MS = IS_WINDOWS ? 75_000 : 20_000;
+/**
+ * Only remove a gateway lock file when it is at least this old. Avoids a TOCTOU race where
+ * concurrent starts see "lock exists, port not listening yet" and delete another instance's fresh lock.
+ */
+const STALE_GATEWAY_LOCK_MIN_AGE_MS = 30_000;
+/** PID file for fast status checks (~1-2ms vs 100ms+ for shell commands) */
+const GATEWAY_PID_FILE = index_1.PID_FILES.gateway();
+const FORK_CLI_NAME = "hippoclaw";
+const MANAGED_GATEWAY_STATE_DIR = path.join(os.homedir(), ".agenthippo", "gateway");
+const MANAGED_GATEWAY_MANIFEST_PATH = path.join(MANAGED_GATEWAY_STATE_DIR, "install.json");
+const GATEWAY_INSTALL_STATUS_FILE = path.join(MANAGED_GATEWAY_STATE_DIR, "install-status.json");
+const MANAGED_GATEWAY_WRAPPER_DIR = IS_WINDOWS
+    ? path.join(process.env.LOCALAPPDATA || path.join(os.homedir(), "AppData", "Local"), "AgentHippo", "bin")
+    : path.join(os.homedir(), ".local", "bin");
+const MANAGED_GATEWAY_WRAPPER_PATH = path.join(MANAGED_GATEWAY_WRAPPER_DIR, IS_WINDOWS ? "hippoclaw.cmd" : "hippoclaw");
+const MANAGED_OPENCLAW_WRAPPER_PATH = path.join(MANAGED_GATEWAY_WRAPPER_DIR, IS_WINDOWS ? "openclaw.cmd" : "openclaw");
+const MANAGED_GATEWAY_WRAPPER_MARKER = IS_WINDOWS
+    ? "REM Managed by Agent Anywhere"
+    : "# Managed by Agent Anywhere";
+function installSourceNeedsBuild(source) {
+    if (!source) {
+        return false;
+    }
+    return (source.startsWith("\\") ||
+        source.startsWith("/") ||
+        source.startsWith(".") ||
+        /^[A-Za-z]:/.test(source) ||
+        source.startsWith("github:") ||
+        source.startsWith("git+http:") ||
+        source.startsWith("git+https:") ||
+        /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+(?:#.+)?$/.test(source));
+}
+const GATEWAY_INSTALL_PROGRESS_STEPS = [
+    ["npmInstallComplete", "npm install complete"],
+    ["wrapperExists", "wrapper exists"],
+    ["configExists", "config exists"],
+    ["distExists", "dist exists"],
+    ["webUiExists", "web UI exists"],
+    ["finalCheckPassed", "final check passed"],
+];
+// ============================================================================
+// Detection
+// ============================================================================
+/**
+ * Detect whether OpenClaw is installed and whether the gateway is running.
+ * This is a fast, non-destructive check.
+ *
+ * Detection logic:
+ * - If the managed fork CLI (`hippoclaw`) resolves and is usable, it's installed.
+ * - If the port is open, listener ownership is verified before it is treated as running.
+ * - We also check common install locations in case PATH is incomplete
+ *   (VS Code's shell PATH often differs from the user's terminal).
+ */
+function normalizePathForCompare(value) {
+    return value.replace(/\\/g, "/").replace(/\/+$/, "").toLowerCase();
+}
+function pathStartsWithPath(child, parent) {
+    const childNorm = normalizePathForCompare(child);
+    const parentNorm = normalizePathForCompare(parent);
+    return childNorm === parentNorm || childNorm.startsWith(`${parentNorm}/`);
+}
+function readManagedGatewayInstallRecord() {
+    try {
+        if (!fs.existsSync(MANAGED_GATEWAY_MANIFEST_PATH)) {
+            return undefined;
+        }
+        // Strip UTF-8 BOM — PowerShell writes JSON with BOM by default
+        const raw = fs.readFileSync(MANAGED_GATEWAY_MANIFEST_PATH, "utf8").replace(/^/, "");
+        return JSON.parse(raw);
+    }
+    catch {
+        return undefined;
+    }
+}
+function writeManagedGatewayInstallRecord(record) {
+    fs.mkdirSync(MANAGED_GATEWAY_STATE_DIR, { recursive: true });
+    fs.writeFileSync(MANAGED_GATEWAY_MANIFEST_PATH, JSON.stringify(record, null, 2), "utf8");
+}
+function getManagedGatewayPackageRoot(record) {
+    const candidate = record?.packageRoot;
+    if (!candidate || !fs.existsSync(candidate)) {
+        return undefined;
+    }
+    try {
+        return fs.realpathSync(candidate);
+    }
+    catch {
+        return candidate;
+    }
+}
+function resolveManagedGatewayCliTarget(binaryPath) {
+    if (!binaryPath) {
+        return undefined;
+    }
+    const record = readManagedGatewayInstallRecord();
+    if (!record?.entryScriptPath && !record?.cliPath) {
+        return binaryPath;
+    }
+    if ((record.wrapperPath || record.openclawWrapperPath) &&
+        [
+            record.wrapperPath,
+            record.openclawWrapperPath,
+        ].some((wrapperPath) => wrapperPath &&
+            normalizePathForCompare(binaryPath) === normalizePathForCompare(wrapperPath)) &&
+        ((record.entryScriptPath && fs.existsSync(record.entryScriptPath)) ||
+            (record.cliPath && fs.existsSync(record.cliPath)))) {
+        return record.entryScriptPath && fs.existsSync(record.entryScriptPath)
+            ? record.entryScriptPath
+            : record.cliPath;
+    }
+    return binaryPath;
+}
+function resolveManagedGatewayLauncherPath(binaryPath) {
+    if (!binaryPath) {
+        return undefined;
+    }
+    const record = readManagedGatewayInstallRecord();
+    if (!record?.cliPath) {
+        return binaryPath;
+    }
+    if ([
+        record.wrapperPath,
+        record.openclawWrapperPath,
+        record.entryScriptPath,
+    ].some((candidate) => candidate &&
+        normalizePathForCompare(binaryPath) === normalizePathForCompare(candidate)) &&
+        fs.existsSync(record.cliPath)) {
+        return record.cliPath;
+    }
+    return binaryPath;
+}
+function getManagedGatewayBinary(record) {
+    for (const candidate of [record?.wrapperPath, record?.openclawWrapperPath, record?.cliPath]) {
+        if (candidate && fs.existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    return undefined;
+}
+function getManagedGatewayNodePath(record) {
+    const candidate = record?.nodePath;
+    if (!candidate || !fs.existsSync(candidate)) {
+        return undefined;
+    }
+    return candidate;
+}
+function getManagedGatewayEntryScriptPath(record) {
+    const candidate = record?.entryScriptPath;
+    if (!candidate || !fs.existsSync(candidate)) {
+        return undefined;
+    }
+    return candidate;
+}
+async function resolveManagedGatewayRuntimeSpec(binaryPath, record) {
+    const installRecord = record ?? readManagedGatewayInstallRecord();
+    const cachedBinary = binaryPath ?? getManagedGatewayBinary(installRecord) ?? (await getCachedBinaryPath());
+    const launcherPath = resolveManagedGatewayLauncherPath(cachedBinary) ?? cachedBinary;
+    if (!launcherPath || !fs.existsSync(launcherPath)) {
+        return undefined;
+    }
+    const packageRoot = getManagedGatewayPackageRoot(installRecord) ?? resolvePackageRootFromBinary(launcherPath);
+    if (!packageRoot) {
+        return undefined;
+    }
+    const nodePath = getManagedGatewayNodePath(installRecord) ?? resolveManagedGatewayNodePath(launcherPath);
+    const entryScriptPath = getManagedGatewayEntryScriptPath(installRecord) ??
+        resolveManagedGatewayEntryScriptFromPackageRoot(packageRoot);
+    if (!nodePath || !entryScriptPath) {
+        return undefined;
+    }
+    return {
+        launcherPath,
+        packageRoot,
+        nodePath,
+        entryScriptPath,
+    };
+}
+function isAgentAnywhereManagedWrapper(wrapperPath) {
+    try {
+        if (!fs.existsSync(wrapperPath)) {
+            return false;
+        }
+        const content = fs.readFileSync(wrapperPath, "utf8");
+        return content.includes(MANAGED_GATEWAY_WRAPPER_MARKER);
+    }
+    catch {
+        return false;
+    }
+}
+function writeManagedGatewayWrapper(nodePath, entryScriptPath, wrapperPath) {
+    fs.mkdirSync(path.dirname(wrapperPath), { recursive: true });
+    const content = IS_WINDOWS
+        ? `@echo off\r\n${MANAGED_GATEWAY_WRAPPER_MARKER}\r\n"${nodePath}" "${entryScriptPath}" %*\r\n`
+        : `#!/bin/sh\n${MANAGED_GATEWAY_WRAPPER_MARKER}\nexec "${nodePath}" "${entryScriptPath}" "$@"\n`;
+    fs.writeFileSync(wrapperPath, content, IS_WINDOWS ? "ascii" : "utf8");
+    if (!IS_WINDOWS) {
+        fs.chmodSync(wrapperPath, 0o755);
+    }
+    return wrapperPath;
+}
+function resolveManagedGatewayEntryScriptFromPackageRoot(packageRoot) {
+    if (!packageRoot) {
+        return undefined;
+    }
+    try {
+        const pkgJsonPath = path.join(packageRoot, "package.json");
+        if (!fs.existsSync(pkgJsonPath)) {
+            return undefined;
+        }
+        const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, "utf8"));
+        let bins = pkg.bin;
+        if (typeof bins === "string") {
+            bins = { [pkg.name || "openclaw"]: bins };
+        }
+        const orderedNames = [...new Set(["hippoclaw", "openclaw", ...Object.keys(bins || {})])];
+        for (const name of orderedNames) {
+            const relativeEntry = bins && typeof bins[name] === "string" ? bins[name] : undefined;
+            if (!relativeEntry) {
+                continue;
+            }
+            const candidate = path.resolve(packageRoot, relativeEntry);
+            if (fs.existsSync(candidate)) {
+                return candidate;
+            }
+        }
+    }
+    catch {
+        // ignore
+    }
+    return undefined;
+}
+function resolveManagedGatewayNodePath(binaryPath) {
+    const launcherPath = resolveManagedGatewayLauncherPath(binaryPath) ?? binaryPath;
+    if (launcherPath) {
+        const candidate = path.join(path.dirname(launcherPath), IS_WINDOWS ? "node.exe" : "node");
+        if (fs.existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    for (const candidate of (0, index_1.getCommonBinaryPaths)("node")) {
+        if (fs.existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    return undefined;
+}
+function removeManagedGatewayWrapperState() {
+    for (const wrapperPath of [MANAGED_GATEWAY_WRAPPER_PATH, MANAGED_OPENCLAW_WRAPPER_PATH]) {
+        if (isAgentAnywhereManagedWrapper(wrapperPath)) {
+            try {
+                fs.rmSync(wrapperPath, { force: true });
+            }
+            catch {
+                // ignore cleanup errors
+            }
+        }
+    }
+    try {
+        fs.rmSync(MANAGED_GATEWAY_MANIFEST_PATH, { force: true });
+    }
+    catch {
+        // ignore cleanup errors
+    }
+}
+function addManagedOpenclawRoot(roots, candidate) {
+    if (!fs.existsSync(candidate)) {
+        return;
+    }
+    try {
+        roots.add(fs.realpathSync(candidate));
+    }
+    catch {
+        roots.add(candidate);
+    }
+}
+/** Scan nvm version dirs when `npm root -g` is unavailable in the extension host PATH. */
+function collectNvmOpenclawPackageRoots() {
+    const home = os.homedir();
+    const nvmDir = process.env.NVM_DIR || path.join(home, ".nvm");
+    const versionsDir = path.join(nvmDir, "versions", "node");
+    if (!fs.existsSync(versionsDir)) {
+        return [];
+    }
+    const candidates = [];
+    try {
+        for (const entry of fs.readdirSync(versionsDir, { withFileTypes: true })) {
+            if (!entry.isDirectory()) {
+                continue;
+            }
+            candidates.push(path.join(versionsDir, entry.name, "lib", "node_modules", "openclaw"));
+        }
+    }
+    catch {
+        // ignore nvm directory read errors
+    }
+    return candidates;
+}
+async function getManagedOpenclawRoots() {
+    const roots = new Set();
+    const manifestRecord = readManagedGatewayInstallRecord();
+    const manifestRoot = getManagedGatewayPackageRoot(manifestRecord);
+    if (manifestRoot && fs.existsSync(manifestRoot)) {
+        roots.add(manifestRoot);
+    }
+    const bootstrapNodeRoot = path.join(os.homedir(), ".agenthippo", "tools", "node");
+    if (fs.existsSync(bootstrapNodeRoot)) {
+        try {
+            const versions = fs.readdirSync(bootstrapNodeRoot, { withFileTypes: true });
+            for (const entry of versions) {
+                if (!entry.isDirectory()) {
+                    continue;
+                }
+                // Windows npm uses node_modules/ directly (no lib/ prefix); Unix uses lib/node_modules/
+                const candidate = path.join(bootstrapNodeRoot, entry.name, ...(IS_WINDOWS ? ["node_modules"] : ["lib", "node_modules"]), "openclaw");
+                if (!fs.existsSync(candidate)) {
+                    continue;
+                }
+                try {
+                    roots.add(fs.realpathSync(candidate));
+                }
+                catch {
+                    roots.add(candidate);
+                }
+            }
+        }
+        catch {
+            // ignore bootstrap node scan failures
+        }
+    }
+    // Windows npm uses node_modules/ directly (no lib/ prefix); Unix uses lib/node_modules/
+    const legacyManaged = path.join(os.homedir(), ".npm-global", ...(IS_WINDOWS ? ["node_modules"] : ["lib", "node_modules"]), "openclaw");
+    addManagedOpenclawRoot(roots, legacyManaged);
+    for (const nvmManaged of collectNvmOpenclawPackageRoots()) {
+        addManagedOpenclawRoot(roots, nvmManaged);
+    }
+    try {
+        const { stdout } = await execAsync("npm root -g", { timeout: 3_000 });
+        const npmRoot = stdout.trim();
+        if (npmRoot) {
+            addManagedOpenclawRoot(roots, path.join(npmRoot, "openclaw"));
+        }
+    }
+    catch {
+        // ignore npm root failures
+    }
+    return Array.from(roots);
+}
+function resolvePackageRootFromBinary(binaryPath) {
+    try {
+        const targetBinary = resolveManagedGatewayCliTarget(binaryPath) ?? binaryPath;
+        const realBinary = fs.realpathSync(targetBinary);
+        let pkgRoot = path.dirname(realBinary);
+        for (let i = 0; i < 8; i++) {
+            if (fs.existsSync(path.join(pkgRoot, "package.json"))) {
+                return pkgRoot;
+            }
+            const parent = path.dirname(pkgRoot);
+            if (parent === pkgRoot) {
+                break;
+            }
+            pkgRoot = parent;
+        }
+    }
+    catch {
+        // ignore
+    }
+    return undefined;
+}
+async function isManagedForkBinaryPath(binaryPath, managedRoots) {
+    const roots = managedRoots ?? (await getManagedOpenclawRoots());
+    if (roots.length === 0) {
+        return false;
+    }
+    const pkgRoot = resolvePackageRootFromBinary(binaryPath);
+    if (!pkgRoot) {
+        return false;
+    }
+    return roots.some((root) => pathStartsWithPath(pkgRoot, root));
+}
+async function getListeningCommandLinesForPort(port) {
+    if (!Number.isFinite(port) || port < 1 || port > 65535) {
+        return [];
+    }
+    if (IS_WINDOWS) {
+        try {
+            const command = `$listenerPids=Get-NetTCPConnection -LocalPort ${port} -State Listen -ErrorAction SilentlyContinue | ` +
+                `Select-Object -ExpandProperty OwningProcess -Unique; ` +
+                `foreach($listenerProcId in $listenerPids){$proc=Get-CimInstance Win32_Process -Filter \\\"ProcessId=$listenerProcId\\\" -ErrorAction SilentlyContinue; if($proc -and $proc.CommandLine){$proc.CommandLine}}`;
+            const { stdout } = await execAsync(`powershell.exe -NoProfile -Command "${command}"`, {
+                timeout: 10_000,
+            });
+            return stdout
+                .split(/\r?\n/)
+                .map((line) => line.trim())
+                .filter((line) => line.length > 0);
+        }
+        catch {
+            return [];
+        }
+    }
+    try {
+        const { stdout } = await execAsync(`lsof -nP -iTCP:${port} -sTCP:LISTEN -t 2>/dev/null || true`, { timeout: 5_000 });
+        const pids = [
+            ...new Set(stdout
+                .trim()
+                .split(/\n/)
+                .map((s) => s.trim())
+                .filter((s) => /^\d+$/.test(s))),
+        ];
+        const commands = [];
+        for (const pid of pids) {
+            try {
+                const { stdout: cmdOut } = await execAsync(`ps -p ${pid} -o command=`, {
+                    timeout: 3_000,
+                });
+                const cmd = cmdOut.trim();
+                if (cmd) {
+                    commands.push(cmd);
+                }
+            }
+            catch {
+                // ignore per-pid failures
+            }
+        }
+        return commands;
+    }
+    catch {
+        return [];
+    }
+}
+async function isTrustedGatewayListener(port, binaryPath) {
+    const managedRoots = await getManagedOpenclawRoots();
+    if (managedRoots.length === 0) {
+        return false;
+    }
+    let binaryIsManaged = false;
+    let binaryReal = "";
+    if (binaryPath) {
+        binaryIsManaged = await isManagedForkBinaryPath(binaryPath, managedRoots);
+        if (binaryIsManaged) {
+            try {
+                binaryReal = fs.realpathSync(binaryPath);
+            }
+            catch {
+                binaryReal = binaryPath;
+            }
+        }
+    }
+    const commandLines = await getListeningCommandLinesForPort(port);
+    if (commandLines.length === 0) {
+        return false;
+    }
+    // The gateway sets process.title to "openclaw-gateway", so ps output won't
+    // contain file paths. Add the managed node binary path to both the command
+    // list (via lsof) and a matching needle, so we can trust processes started
+    // from our bootstrapped node tree even when the process title is opaque.
+    const manifestRecord = readManagedGatewayInstallRecord();
+    const manifestNodePath = getManagedGatewayNodePath(manifestRecord);
+    const augmentedCommands = [...commandLines];
+    if (manifestNodePath) {
+        augmentedCommands.push(manifestNodePath);
+    }
+    const rootNeedles = managedRoots.map((root) => normalizePathForCompare(root));
+    // Add the managed node binary dir as a needle so it can match against the
+    // augmented command list entry for the node executable.
+    if (manifestNodePath) {
+        rootNeedles.push(normalizePathForCompare(path.dirname(manifestNodePath)));
+    }
+    const binaryNeedle = binaryReal ? normalizePathForCompare(binaryReal) : "";
+    for (const cmd of augmentedCommands) {
+        const normalized = normalizePathForCompare(cmd);
+        if (normalized.includes(FORK_CLI_NAME)) {
+            if (binaryIsManaged) {
+                return true;
+            }
+        }
+        if (binaryNeedle && normalized.includes(binaryNeedle)) {
+            return true;
+        }
+        if (rootNeedles.some((needle) => normalized.includes(needle))) {
+            return true;
+        }
+    }
+    return false;
+}
+async function detectGateway(port = DEFAULT_PORT) {
+    // Parallelize port probe and binary lookup for ~50% faster detection
+    const [portOpen, managedRoots] = await Promise.all([
+        (0, index_1.probePort)(port),
+        getManagedOpenclawRoots(),
+    ]);
+    const binaryPath = await getCachedBinaryPath(managedRoots);
+    let version;
+    if (binaryPath) {
+        try {
+            const { stdout } = await execAsync(`"${binaryPath}" --version`, {
+                timeout: 3_000, // Reduced from 5s - local command should be fast
+            });
+            version = stdout.trim().split("\n")[0];
+        }
+        catch {
+            // Binary exists but --version failed
+        }
+    }
+    // Treat installed as "managed fork CLI is available and usable".
+    const installed = !!binaryPath && !!version;
+    const running = portOpen
+        ? await isTrustedGatewayListener(port, binaryPath)
+        : false;
+    return {
+        installed,
+        binaryPath,
+        version,
+        running,
+        port,
+    };
+}
+/**
+ * Ask the OpenClaw CLI to stop a supervised or local gateway (launchd/systemd aware).
+ */
+async function tryOpenclawGatewayStopCli(binaryPath, log) {
+    try {
+        if (IS_WINDOWS) {
+            const runtimeSpec = await resolveManagedGatewayRuntimeSpec(binaryPath);
+            if (runtimeSpec) {
+                log("Running gateway stop via managed node runtime...");
+                await execFileAsync(runtimeSpec.nodePath, [runtimeSpec.entryScriptPath, "gateway", "stop"], { timeout: 20_000, windowsHide: true });
+                return;
+            }
+        }
+        log(`Running ${path.basename(binaryPath)} gateway stop (CLI)...`);
+        await execAsync(`"${binaryPath}" gateway stop`, { timeout: 20_000, windowsHide: true });
+    }
+    catch {
+        // Non-fatal — fall back to process signals / port-based kill
+    }
+}
+function readGatewayInstallStatusSnapshot() {
+    try {
+        if (!fs.existsSync(GATEWAY_INSTALL_STATUS_FILE)) {
+            return undefined;
+        }
+        const raw = fs.readFileSync(GATEWAY_INSTALL_STATUS_FILE, "utf8").replace(/^\uFEFF/, "");
+        return JSON.parse(raw);
+    }
+    catch {
+        return undefined;
+    }
+}
+function isGatewayInstallComplete(status) {
+    return status?.phase === "complete" && status.steps?.finalCheckPassed === true;
+}
+function getGatewayInstallProgressSummary(status) {
+    if (!status) {
+        return {
+            message: "Waiting for setup status...",
+            percent: 0,
+        };
+    }
+    if (status.phase === "failed") {
+        return {
+            message: status.lastError?.trim() || status.message?.trim() || "Install failed.",
+            percent: 100,
+        };
+    }
+    const completedLabels = GATEWAY_INSTALL_PROGRESS_STEPS
+        .filter(([key]) => status.steps?.[key])
+        .map(([, label]) => label);
+    const completedCount = completedLabels.length;
+    const phaseMessage = status.message?.trim() || "Installing Agent Anywhere...";
+    const progressMessage = completedLabels.length > 0
+        ? `${phaseMessage} (done: ${completedLabels.join(", ")})`
+        : phaseMessage;
+    return {
+        message: progressMessage,
+        percent: Math.min(95, Math.floor((completedCount / GATEWAY_INSTALL_PROGRESS_STEPS.length) * 100)),
+    };
+}
+function escapePowerShellSingleQuotedString(value) {
+    return value.replace(/'/g, "''");
+}
+async function getListeningProcessIdsForPort(port) {
+    if (!Number.isFinite(port) || port < 1 || port > 65535) {
+        return [];
+    }
+    if (IS_WINDOWS) {
+        try {
+            const { stdout } = await execAsync(`powershell.exe -NoProfile -Command "Get-NetTCPConnection -LocalPort ${port} -State Listen -ErrorAction SilentlyContinue | ForEach-Object { $_.OwningProcess } | Sort-Object -Unique"`, { timeout: 10_000, windowsHide: true });
+            return [
+                ...new Set(stdout
+                    .trim()
+                    .split(/\r?\n/)
+                    .map((s) => parseInt(s.trim(), 10))
+                    .filter((pid) => Number.isInteger(pid) && pid > 0)),
+            ];
+        }
+        catch {
+            return [];
+        }
+    }
+    try {
+        const { stdout } = await execAsync(`lsof -nP -iTCP:${port} -sTCP:LISTEN -t 2>/dev/null || true`, { timeout: 5_000 });
+        return [
+            ...new Set(stdout
+                .trim()
+                .split(/\n/)
+                .map((s) => parseInt(s.trim(), 10))
+                .filter((pid) => Number.isInteger(pid) && pid > 0)),
+        ];
+    }
+    catch {
+        return [];
+    }
+}
+async function waitForGatewayShutdown(port, observedPids, timeoutMs = 8_000) {
+    const trackedPids = [...new Set(observedPids.filter((pid) => Number.isInteger(pid) && pid > 0))];
+    const deadline = Date.now() + timeoutMs;
+    let stableClosedSince = 0;
+    while (Date.now() < deadline) {
+        const portOpen = await (0, index_1.probePort)(port);
+        const stillRunning = trackedPids.filter((pid) => (0, index_1.isProcessRunning)(pid));
+        if (!portOpen && stillRunning.length === 0) {
+            if (stableClosedSince === 0) {
+                stableClosedSince = Date.now();
+            }
+            if (Date.now() - stableClosedSince >= 750) {
+                return true;
+            }
+        }
+        else {
+            stableClosedSince = 0;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 250));
+    }
+    return !(await (0, index_1.probePort)(port)) && trackedPids.every((pid) => !(0, index_1.isProcessRunning)(pid));
+}
+/**
+ * Signal the gateway process group. We spawn the gateway launcher detached, so it is a process
+ * group leader and its listening child shares the group; signalling the group avoids orphaning the
+ * child that actually holds the port. Falls back to signalling just the launcher when the group
+ * signal is unavailable. Unix only -- Windows uses `taskkill /T` for tree termination.
+ */
+function killGatewayProcessGroupOrSelf(child, pid, signal) {
+    if (pid && pid > 0) {
+        try {
+            process.kill(-pid, signal);
+            return;
+        }
+        catch {
+            // Group signal unavailable (not a group leader / already gone) -- fall back below.
+        }
+    }
+    try {
+        child.kill(signal);
+    }
+    catch {
+        // Process already exited.
+    }
+}
+/**
+ * Stop whatever is listening on the gateway TCP port (covers node …/cli.mjs
+ * when argv does not contain the substring "openclaw").
+ */
+async function killTcpListenersOnPort(port) {
+    if (!Number.isFinite(port) || port < 1 || port > 65535) {
+        return;
+    }
+    if (IS_WINDOWS) {
+        try {
+            const { stdout } = await execAsync(`powershell.exe -NoProfile -Command "Get-NetTCPConnection -LocalPort ${port} -State Listen -ErrorAction SilentlyContinue | ForEach-Object { $_.OwningProcess } | Sort-Object -Unique"`, { timeout: 10_000 });
+            const pids = stdout
+                .trim()
+                .split(/\r?\n/)
+                .map((s) => s.trim())
+                .filter((s) => /^\d+$/.test(s));
+            for (const pid of pids) {
+                await execAsync(`taskkill /F /T /PID ${pid}`, { timeout: 5_000 }).catch(() => { });
+            }
+        }
+        catch {
+            // ignore
+        }
+        return;
+    }
+    try {
+        const { stdout } = await execAsync(`lsof -nP -iTCP:${port} -sTCP:LISTEN -t 2>/dev/null || true`, { timeout: 5_000 });
+        const pids = [
+            ...new Set(stdout
+                .trim()
+                .split(/\n/)
+                .map((s) => s.trim())
+                .filter((s) => /^\d+$/.test(s))),
+        ];
+        for (const pid of pids) {
+            await execAsync(`kill ${pid}`, { timeout: 3_000 }).catch(() => { });
+        }
+        await new Promise((r) => setTimeout(r, 800));
+        const { stdout: stdout2 } = await execAsync(`lsof -nP -iTCP:${port} -sTCP:LISTEN -t 2>/dev/null || true`, { timeout: 5_000 });
+        const pids2 = [
+            ...new Set(stdout2
+                .trim()
+                .split(/\n/)
+                .map((s) => s.trim())
+                .filter((s) => /^\d+$/.test(s))),
+        ];
+        for (const pid of pids2) {
+            await execAsync(`kill -9 ${pid}`, { timeout: 3_000 }).catch(() => { });
+        }
+    }
+    catch {
+        // lsof missing or failed — ignore
+    }
+}
+/**
+ * Stop a gateway we did not spawn in-process (detached child, terminal, setup script, etc.).
+ * @returns true if the gateway port is no longer accepting connections
+ */
+async function stopExternalGatewayListener(port, binaryPath, log) {
+    const observedPids = await getListeningProcessIdsForPort(port);
+    if (binaryPath) {
+        await tryOpenclawGatewayStopCli(binaryPath, log);
+        if (await waitForGatewayShutdown(port, observedPids)) {
+            return true;
+        }
+    }
+    log(`Stopping listener(s) on port ${port}...`);
+    await killTcpListenersOnPort(port);
+    const allObservedPids = [...observedPids];
+    if (port !== DEFAULT_PORT && (await (0, index_1.probePort)(DEFAULT_PORT))) {
+        allObservedPids.push(...(await getListeningProcessIdsForPort(DEFAULT_PORT)));
+        log(`Stopping listener(s) on port ${DEFAULT_PORT} (default gateway port)...`);
+        await killTcpListenersOnPort(DEFAULT_PORT);
+    }
+    return waitForGatewayShutdown(port, allObservedPids);
+}
+// Note: findBinary() and probePort() are now imported from ../utils
+// ============================================================================
+// Fast Detection (PID file based, ~1-2ms)
+// Uses shared utilities from ../utils/pid.ts
+// ============================================================================
+/** Wrapper for gateway-specific PID file writes */
+async function writeGatewayPidFile(pid, port, binaryPath) {
+    await (0, index_1.writePidFile)(GATEWAY_PID_FILE, pid, port, binaryPath);
+}
+/** Wrapper for gateway-specific PID file removal */
+async function removeGatewayPidFile() {
+    await (0, index_1.removePidFile)(GATEWAY_PID_FILE);
+}
+/**
+ * Fast gateway detection using PID file.
+ * Cost: ~1-2ms when PID file exists and process is running.
+ * Falls back to full detection if PID file is missing/stale.
+ */
+async function detectGatewayFast(port) {
+    const pidData = await (0, index_1.checkPidFileWithCleanup)(GATEWAY_PID_FILE);
+    if (!pidData) {
+        return null; // No PID file or stale
+    }
+    // Parse gateway-specific metadata: [port, binaryPath]
+    const portFromFile = pidData.metadata?.[0] ? parseInt(pidData.metadata[0], 10) : undefined;
+    const binaryPath = pidData.metadata?.[1] || undefined;
+    const effectivePort = portFromFile ?? port;
+    // PID can be reused by another process; require the gateway port to be listening.
+    if (!(await (0, index_1.probePort)(effectivePort))) {
+        return null;
+    }
+    // PID can be stale/reused. Trust fast-path only when listener still looks like our fork.
+    if (!(await isTrustedGatewayListener(effectivePort, binaryPath))) {
+        return null;
+    }
+    return {
+        installed: true,
+        binaryPath,
+        running: true,
+        port: effectivePort,
+    };
+}
+/**
+ * Get cached binary path, or find it fresh if cache expired.
+ * Uses shared binary finder utility with caching.
+ */
+async function getCachedBinaryPath(managedRoots) {
+    const roots = managedRoots ?? (await getManagedOpenclawRoots());
+    return getCachedBinaryPathFromRoots(roots);
+}
+async function getCachedBinaryPathFromRoots(managedRoots) {
+    const manifestRecord = readManagedGatewayInstallRecord();
+    const manifestRoot = getManagedGatewayPackageRoot(manifestRecord);
+    const manifestBinary = getManagedGatewayBinary(manifestRecord);
+    if (manifestRoot && manifestBinary && fs.existsSync(manifestBinary)) {
+        const manifestMatchesManaged = managedRoots.length === 0 ||
+            managedRoots.some((root) => pathStartsWithPath(manifestRoot, root));
+        if (manifestMatchesManaged) {
+            return manifestBinary;
+        }
+    }
+    const forkCli = await (0, index_1.findBinaryCached)(FORK_CLI_NAME, (0, index_1.getCommonBinaryPaths)(FORK_CLI_NAME));
+    if (forkCli && (await isManagedForkBinaryPath(forkCli, managedRoots))) {
+        return forkCli;
+    }
+    const forkCliFile = IS_WINDOWS ? `${FORK_CLI_NAME}.cmd` : FORK_CLI_NAME;
+    for (const managedRoot of managedRoots) {
+        // Unix: {prefix}/lib/node_modules/openclaw → 3 levels up → {prefix}/bin/cmd
+        // Windows: {prefix}/node_modules/openclaw → 2 levels up → {prefix}/cmd.cmd (no bin/)
+        const prefixDir = IS_WINDOWS
+            ? path.dirname(path.dirname(managedRoot))
+            : path.dirname(path.dirname(path.dirname(managedRoot)));
+        const candidate = IS_WINDOWS
+            ? path.join(prefixDir, forkCliFile)
+            : path.join(prefixDir, "bin", forkCliFile);
+        if (!fs.existsSync(candidate)) {
+            continue;
+        }
+        if (await isManagedForkBinaryPath(candidate, managedRoots)) {
+            return candidate;
+        }
+    }
+    return undefined;
+}
+class GatewayLifecycleManager {
+    outputChannel;
+    process = null;
+    healthCheckTimer = null;
+    _status = "not-installed";
+    _bridgeConnected = false;
+    _lastDetection = null;
+    _bridgeRef = null;
+    /** True while `install()` is running setup in a terminal (poll loop). Prevents toggle/detect from resetting UI to "Install" again. */
+    _gatewayInstallInProgress = false;
+    _installProgressMessage;
+    _installSetupTerminal = null;
+    _gatewayUninstallInProgress = false;
+    _uninstallSetupTerminal = null;
+    _startInFlight = null;
+    _lastStartInProgressNoticeAt = 0;
+    /**
+     * Cached answer to "does the gateway have at least one configured messaging channel?" — drives
+     * the connected menu's primary button (Meet at... when channels exist, else Web UI). Undefined
+     * until first probed via {@link refreshHasConfiguredChannels}.
+     */
+    _hasConfiguredChannelsCache;
+    disposables = [];
+    statusBarItem;
+    _onStatusChange = new vscode.EventEmitter();
+    onStatusChange = this._onStatusChange.event;
+    /**
+     * Set the bridge reference (GatewayService) so lifecycle can trigger connect/disconnect.
+     */
+    setBridgeRef(ref) {
+        this._bridgeRef = ref;
+    }
+    constructor(outputChannel, extensionContext) {
+        this.outputChannel = outputChannel;
+        void extensionContext; // Reserved for future use (e.g., storage, secrets)
+        // Status bar at priority 100 (replaces the old GatewayService icon, before Spotlight at 99)
+        this.statusBarItem = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Right, 100);
+        this.statusBarItem.command = "agentide.anywhere.toggle";
+        this.statusBarItem.name = exports.AGENT_ANYWHERE_LABEL;
+        // Initialize context key for connection state (used by mode picker button)
+        void vscode.commands.executeCommand("setContext", "agentide.anywhere.connected", this._bridgeConnected);
+        this.disposables.push(vscode.window.onDidCloseTerminal((terminal) => {
+            if (this._installSetupTerminal === terminal) {
+                this._installSetupTerminal = null;
+                if (this._gatewayInstallInProgress) {
+                    void this.reconcileInstallProgressState();
+                }
+            }
+            if (this._uninstallSetupTerminal === terminal) {
+                this._uninstallSetupTerminal = null;
+                if (this._gatewayUninstallInProgress) {
+                    void this.reconcileUninstallProgressState();
+                }
+            }
+        }));
+        this.registerCommands();
+        this.registerConfigWatcher();
+        // Lazy init: only probe if feature is enabled
+        void this.initializeLazy();
+    }
+    setInstallProgressFlag(inProgress, reason) {
+        if (this._gatewayInstallInProgress === inProgress) {
+            return;
+        }
+        this._gatewayInstallInProgress = inProgress;
+        this.log(`Install flag -> ${inProgress ? "true" : `false (${reason})`}`);
+    }
+    get status() {
+        return this._status;
+    }
+    get lastDetection() {
+        return this._lastDetection;
+    }
+    // ============================================================================
+    // Initialization
+    // ============================================================================
+    async initializeLazy() {
+        const hidden = this.getConfig("hidden", false);
+        if (hidden) {
+            this.statusBarItem.hide();
+            return; // Enterprise kill switch: hide everything
+        }
+        const enabled = this.getConfig("enabled", false);
+        if (!enabled) {
+            // Not enabled -- show a subtle status bar hint, no probing
+            this.updateStatusBar("not-installed");
+            this.statusBarItem.show();
+            return;
+        }
+        // Feature enabled -- detect current state (fast path first)
+        const port = this.getGatewayPort();
+        const fast = await detectGatewayFast(port);
+        if (fast) {
+            this._lastDetection = fast;
+            this.setStatus("running");
+        }
+        else {
+            await this.detect();
+        }
+        // Auto-start if configured and installed
+        const autoStart = this.getConfig("autoStart", false);
+        if (autoStart && this._lastDetection?.installed && !this._lastDetection?.running) {
+            this.log("Auto-starting gateway (agentide.anywhere.autoStart = true)");
+            await this.start();
+        }
+    }
+    // ============================================================================
+    // Commands
+    // ============================================================================
+    registerCommands() {
+        this.disposables.push(vscode.commands.registerCommand("agentide.anywhere.toggle", () => this.toggle()), vscode.commands.registerCommand("agentide.anywhere.install", () => this.install()), vscode.commands.registerCommand("agentide.anywhere.uninstall", () => this.uninstall()), vscode.commands.registerCommand("agentide.anywhere.start", () => this.start()), vscode.commands.registerCommand("agentide.anywhere.stop", () => this.stop()), vscode.commands.registerCommand("agentide.anywhere.status", () => this.showStatus()), vscode.commands.registerCommand("agentide.anywhere.openConfig", () => this.openConfig()), vscode.commands.registerCommand("agentide.anywhere.connect", () => this.connectBridge()), vscode.commands.registerCommand("agentide.anywhere.disconnect", () => this.disconnectBridge()), vscode.commands.registerCommand("agentide.anywhere.openWebUI", () => this.openWebUI()), vscode.commands.registerCommand("agentide.anywhere.detect", () => this.detect()), 
+        // Exposed for mode picker button: "Meet Agent Anywhere"
+        vscode.commands.registerCommand("agentide.anywhere.meetAgent", () => this.showMeetAgentPicker()));
+    }
+    setBridgeConnected(value) {
+        this._bridgeConnected = value;
+        void vscode.commands.executeCommand("setContext", "agentide.anywhere.connected", value);
+    }
+    registerConfigWatcher() {
+        this.disposables.push(vscode.workspace.onDidChangeConfiguration((e) => {
+            if (e.affectsConfiguration("agentide.anywhere")) {
+                void this.initializeLazy();
+            }
+        }));
+    }
+    // ============================================================================
+    // Toggle (status bar click)
+    // ============================================================================
+    async toggle() {
+        const hidden = this.getConfig("hidden", false);
+        if (hidden) {
+            return;
+        }
+        if (this._gatewayInstallInProgress) {
+            await this.showGatewayInstallInProgressPrompt();
+            return;
+        }
+        if (this._gatewayUninstallInProgress) {
+            await this.showGatewayUninstallInProgressPrompt();
+            return;
+        }
+        if (this._startInFlight) {
+            this.setStatus("starting");
+            const now = Date.now();
+            if (now - this._lastStartInProgressNoticeAt > 4000) {
+                this._lastStartInProgressNoticeAt = now;
+                void vscode.window.showInformationMessage(`${exports.AGENT_ANYWHERE_LABEL}: Starting gateway... please wait.`);
+            }
+            return;
+        }
+        // Instant path: route to a menu using cached state only.
+        // Do not block click on detect/start/connect; those happen only after user action.
+        this.setBridgeConnected(this._bridgeRef?.isConnected ?? false);
+        switch (this._status) {
+            case "error": {
+                const likelyInstalled = this._lastDetection?.installed === true;
+                if (likelyInstalled) {
+                    await this.showDisconnectedQuickMenu();
+                }
+                else {
+                    await this.showNotInstalledQuickMenu();
+                }
+                break;
+            }
+            case "starting":
+            case "stopping":
+                void vscode.window.showInformationMessage(`${exports.AGENT_ANYWHERE_LABEL}: Operation in progress...`);
+                break;
+            case "running":
+                if (this._bridgeConnected) {
+                    await this.showConnectedQuickMenu();
+                }
+                else {
+                    await this.showDisconnectedQuickMenu();
+                }
+                break;
+            case "installed":
+                await this.showDisconnectedQuickMenu();
+                break;
+            case "not-installed":
+            default: {
+                // If cache is stale but we previously saw an installed state, prefer the
+                // disconnected menu and let background refresh correct the UI.
+                const likelyInstalled = this._lastDetection?.installed === true;
+                if (likelyInstalled) {
+                    await this.showDisconnectedQuickMenu();
+                    break;
+                }
+                await this.showNotInstalledQuickMenu();
+                break;
+            }
+        }
+    }
+    queueBackgroundDetect(reason) {
+        if (this._gatewayInstallInProgress ||
+            this._gatewayUninstallInProgress ||
+            this._startInFlight ||
+            this._status === "starting" ||
+            this._status === "stopping") {
+            return;
+        }
+        setTimeout(() => {
+            if (this._gatewayInstallInProgress ||
+                this._gatewayUninstallInProgress ||
+                this._startInFlight ||
+                this._status === "starting" ||
+                this._status === "stopping") {
+                return;
+            }
+            void this.detect().catch((err) => {
+                this.log(`Background detect failed after ${reason}: ${err instanceof Error ? err.message : String(err)}`);
+            });
+        }, 100);
+    }
+    /**
+     * Level 1 menu for running + connected state.
+     * Connected: Web UI | Disconnect | More | Ask Agent Hippo
+     */
+    async showConnectedQuickMenu() {
+        // Primary action depends on whether messaging channels are configured: surface "Meet at..."
+        // (bind/reclaim a channel for this IDE agent) when they are, otherwise keep "Web UI" since
+        // there is nothing to meet at yet. Cached probe keeps the menu instant; first open awaits once.
+        const hasChannels = this._hasConfiguredChannelsCache ?? (await this.refreshHasConfiguredChannels());
+        const primaryAction = hasChannels ? "Meet at..." : "Web UI";
+        const choicePromise = vscode.window.showInformationMessage(`${exports.AGENT_ANYWHERE_LABEL} is running (bridge: connected).`, primaryAction, "Disconnect", "Ask Agent Hippo", "More");
+        this.queueBackgroundDetect("opening connected menu");
+        // Keep the cache warm for the next open and the More menu's Web UI entry.
+        void this.refreshHasConfiguredChannels();
+        const choice = await choicePromise;
+        switch (choice) {
+            case "Meet at...":
+                await this.showMeetAgentPicker();
+                break;
+            case "Web UI":
+                await this.openWebUI();
+                break;
+            case "Disconnect":
+                await this.disconnectBridge();
+                break;
+            case "More":
+                await this.showMaintenanceQuickMenu();
+                break;
+            case "Ask Agent Hippo":
+                await this.openAskAgentHippoChat();
+                break;
+        }
+    }
+    /**
+     * Level 1 menu for installed but disconnected (or not running) state.
+     * Disconnected: Connect | Reinstall | More | Ask Agent Hippo
+     */
+    async showDisconnectedQuickMenu() {
+        const choicePromise = vscode.window.showInformationMessage(`${exports.AGENT_ANYWHERE_LABEL}: Disconnected.`, "Connect", "Reinstall", "Ask Agent Hippo", "More");
+        this.queueBackgroundDetect("opening disconnected menu");
+        const choice = await choicePromise;
+        switch (choice) {
+            case "Connect":
+                await this.start();
+                if (this._status === "running") {
+                    await this.connectBridge();
+                    this.setBridgeConnected(this._bridgeRef?.isConnected ?? false);
+                    if (this._bridgeConnected) {
+                        await this.showConnectedQuickMenu();
+                    }
+                }
+                break;
+            case "Reinstall":
+                await this.install();
+                break;
+            case "More":
+                await this.showMaintenanceQuickMenu();
+                break;
+            case "Ask Agent Hippo":
+                await this.openAskAgentHippoChat();
+                break;
+        }
+    }
+    async showGatewayInstallInProgressPrompt() {
+        const choice = await vscode.window.showInformationMessage(`${exports.AGENT_ANYWHERE_LABEL}: Install in progress. Follow the "${exports.AGENT_ANYWHERE_LABEL} Setup" terminal; when it finishes, status updates automatically.`, "Show Setup Terminal", "OK");
+        if (choice === "Show Setup Terminal") {
+            if (!this.revealInstallSetupTerminal()) {
+                await this.showMissingInstallSetupTerminalPrompt();
+            }
+        }
+    }
+    async showMissingInstallSetupTerminalPrompt() {
+        const result = await this.reconcileInstallProgressState();
+        if (result?.installed) {
+            void vscode.window.showInformationMessage(`${exports.AGENT_ANYWHERE_LABEL}: Install completed. Status has been refreshed.`);
+        }
+        else {
+            void vscode.window.showWarningMessage(`${exports.AGENT_ANYWHERE_LABEL}: Setup terminal is no longer available. Install did not complete; run Install again to relaunch setup.`);
+        }
+    }
+    async showGatewayUninstallInProgressPrompt() {
+        const choice = await vscode.window.showInformationMessage(`${exports.AGENT_ANYWHERE_LABEL}: Uninstall in progress. Follow the "${AGENT_ANYWHERE_UNINSTALL_TERMINAL}" terminal; when it finishes, status updates automatically.`, "Show Uninstall Terminal", "OK");
+        if (choice === "Show Uninstall Terminal") {
+            if (!this.revealUninstallSetupTerminal()) {
+                await this.showMissingUninstallSetupTerminalPrompt();
+            }
+        }
+    }
+    async showMissingUninstallSetupTerminalPrompt() {
+        const result = await this.reconcileUninstallProgressState();
+        if (result && !result.installed && !result.running) {
+            void vscode.window.showInformationMessage(`${exports.AGENT_ANYWHERE_LABEL}: Uninstall completed. Status has been refreshed.`);
+        }
+        else {
+            void vscode.window.showWarningMessage(`${exports.AGENT_ANYWHERE_LABEL}: Uninstall terminal is no longer available. Uninstall may still be running or did not complete; run Status to confirm.`);
+        }
+    }
+    revealInstallSetupTerminal() {
+        const terminal = this._installSetupTerminal ??
+            vscode.window.terminals.find((t) => t.name === AGENT_ANYWHERE_SETUP_TERMINAL ||
+                t.name.startsWith(`${AGENT_ANYWHERE_SETUP_TERMINAL} `)) ??
+            null;
+        if (!terminal) {
+            return false;
+        }
+        this._installSetupTerminal = terminal;
+        terminal.show();
+        return true;
+    }
+    revealUninstallSetupTerminal() {
+        const terminal = this._uninstallSetupTerminal ??
+            vscode.window.terminals.find((t) => t.name === AGENT_ANYWHERE_UNINSTALL_TERMINAL ||
+                t.name.startsWith(`${AGENT_ANYWHERE_UNINSTALL_TERMINAL} `)) ??
+            null;
+        if (!terminal) {
+            return false;
+        }
+        this._uninstallSetupTerminal = terminal;
+        terminal.show();
+        return true;
+    }
+    async reconcileInstallProgressState() {
+        if (!this._gatewayInstallInProgress) {
+            return this._lastDetection;
+        }
+        if (this.revealInstallSetupTerminal()) {
+            return this._lastDetection;
+        }
+        // Setup terminal closed — allow npm/manifest to settle before treating as failure.
+        await this.sleep(2_000);
+        if (this.revealInstallSetupTerminal()) {
+            return this._lastDetection;
+        }
+        (0, index_1.clearBinaryCache)(FORK_CLI_NAME);
+        (0, index_1.clearBinaryCache)("openclaw");
+        const result = await this.detectGatewayState(this.getGatewayPort());
+        this._lastDetection = result;
+        if (result.running) {
+            this.finishInstallUiState("running", "terminal reconciliation");
+        }
+        else if (result.installed) {
+            this.finishInstallUiState("installed", "terminal reconciliation");
+        }
+        else {
+            this.log("Setup terminal closed before gateway install was detected");
+            this.setInstallProgressFlag(false, "terminal reconciliation");
+            this._installProgressMessage = undefined;
+            this.setStatus("not-installed");
+        }
+        return result;
+    }
+    finishInstallUiState(status, reason) {
+        this.setInstallProgressFlag(false, reason);
+        this._installProgressMessage = undefined;
+        this.setStatus(status);
+    }
+    readInstallStatusSnapshot() {
+        return readGatewayInstallStatusSnapshot();
+    }
+    getInstallProgressSummary(status) {
+        return getGatewayInstallProgressSummary(status);
+    }
+    async detectGatewayState(port) {
+        return detectGateway(port);
+    }
+    async detectGatewayFastState(port) {
+        return detectGatewayFast(port);
+    }
+    async probeGatewayPort(port) {
+        return (0, index_1.probePort)(port);
+    }
+    isStartedGatewayProcessAlive(pid) {
+        return pid !== undefined && (0, index_1.isProcessRunning)(pid);
+    }
+    getStartupTimeoutMs() {
+        return STARTUP_TIMEOUT_MS;
+    }
+    getStartupCheckIntervalMs() {
+        return 500;
+    }
+    getStartupLaunchGraceMs() {
+        return IS_WINDOWS ? 15_000 : 0;
+    }
+    getUninstallInitialDelayMs() {
+        return IS_WINDOWS ? 2_000 : 3_000;
+    }
+    getUninstallVerificationTimeoutMs() {
+        return IS_WINDOWS ? 15_000 : 90_000;
+    }
+    getUninstallCheckIntervalMs() {
+        return IS_WINDOWS ? 1_000 : 4_000;
+    }
+    async sleep(ms) {
+        await new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    /**
+     * Whether the gateway launch should take the Windows (hidden-process) path. Defaults to the
+     * platform constant; exposed as a method so tests can force the Windows branch off-Windows.
+     */
+    isWindowsLaunch() {
+        return IS_WINDOWS;
+    }
+    async stopExistingGatewayBeforeStart(binaryPath) {
+        await tryOpenclawGatewayStopCli(binaryPath, (message) => this.log(message));
+    }
+    getGatewayLockPathForConfig() {
+        const configHash = (0, crypto_1.createHash)("sha256").update(this.configPath).digest("hex").slice(0, 8);
+        return path.join(os.tmpdir(), "openclaw", `gateway.${configHash}.lock`);
+    }
+    async removeStaleGatewayLockBeforeStart(port) {
+        if (!IS_WINDOWS) {
+            return;
+        }
+        const lockPath = this.getGatewayLockPathForConfig();
+        if (!fs.existsSync(lockPath)) {
+            return;
+        }
+        if (await this.probeGatewayPort(port)) {
+            this.log(`Gateway lock present but port ${port} is open; leaving lock in place.`);
+            return;
+        }
+        let lockAgeMs = Number.POSITIVE_INFINITY;
+        try {
+            const st = await fs.promises.stat(lockPath);
+            lockAgeMs = Date.now() - st.mtimeMs;
+        }
+        catch (error) {
+            this.log(`Could not stat gateway lock before start: ${error instanceof Error ? error.message : String(error)}`);
+            return;
+        }
+        if (lockAgeMs < STALE_GATEWAY_LOCK_MIN_AGE_MS) {
+            this.log(`Gateway lock is only ${Math.round(lockAgeMs / 1000)}s old; not removing (possible concurrent start still binding).`);
+            return;
+        }
+        try {
+            fs.rmSync(lockPath, { force: true });
+            this.log(`Removed stale gateway lock before start (${Math.round(lockAgeMs / 1000)}s old): ${lockPath}`);
+        }
+        catch (error) {
+            this.log(`Could not remove stale gateway lock before start: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    async writeGatewayPidRecord(pid, port, binaryPath) {
+        await writeGatewayPidFile(pid, port, binaryPath);
+    }
+    async reconcileUninstallProgressState() {
+        if (!this._gatewayUninstallInProgress) {
+            return this._lastDetection;
+        }
+        if (this.revealUninstallSetupTerminal()) {
+            return this._lastDetection;
+        }
+        const result = await detectGateway(this.getGatewayPort());
+        this._lastDetection = result;
+        this._gatewayUninstallInProgress = false;
+        if (result.running) {
+            this.setStatus("running");
+        }
+        else if (result.installed) {
+            this.setStatus("installed");
+        }
+        else {
+            this.setStatus("not-installed");
+        }
+        return result;
+    }
+    /**
+     * Level 1 menu for not-installed state.
+     * Not installed: Install | Ask Agent Hippo
+     */
+    async showNotInstalledQuickMenu() {
+        const choicePromise = vscode.window.showInformationMessage(`${exports.AGENT_ANYWHERE_LABEL}: Reach your AgentHippo IDE or CLI agents from WhatsApp, Telegram, Slack, Discord, and more - right from your phone or any messaging app. This will also install OpenClaw fork on your computer.`, "Install", "Ask Agent Hippo");
+        this.queueBackgroundDetect("opening not-installed menu");
+        const choice = await choicePromise;
+        switch (choice) {
+            case "Install":
+                await this.install();
+                break;
+            case "Ask Agent Hippo":
+                await this.openAskAgentHippoChat();
+                break;
+        }
+    }
+    /**
+     * Level 2 maintenance menu.
+     * Config | Reset auth | Restart (only if OpenClaw appears installed) | Uninstall
+     */
+    async showMaintenanceQuickMenu() {
+        // Keep "More" instant: build actions from cached in-memory state and
+        // refresh detection in the background.
+        const likelyInstalled = this._status === "running" ||
+            this._status === "installed" ||
+            this._lastDetection?.installed === true;
+        // Web UI lives here once channels are configured (the connected menu's front button becomes
+        // "Meet at..." in that case); keep it reachable but out of the way.
+        const showWebUi = this._status === "running" && this._hasConfiguredChannelsCache === true;
+        const actions = [
+            ...(showWebUi ? ["Web UI"] : []),
+            "Config",
+            "Reset auth",
+            "Reset mappings",
+            ...(likelyInstalled ? ["Restart"] : []),
+            "Uninstall",
+        ];
+        const choicePromise = vscode.window.showInformationMessage(`${exports.AGENT_ANYWHERE_LABEL}: More options`, ...actions);
+        this.queueBackgroundDetect("opening maintenance menu");
+        const choice = await choicePromise;
+        switch (choice) {
+            case "Web UI":
+                await this.openWebUI();
+                break;
+            case "Config":
+                await this.openConfig();
+                break;
+            case "Reset auth":
+                await this.resetAuth();
+                break;
+            case "Reset mappings":
+                await vscode.commands.executeCommand("agentide.gateway.resetMappings");
+                break;
+            case "Restart":
+                await this.restartGateway();
+                break;
+            case "Uninstall":
+                await this.uninstall();
+                break;
+        }
+    }
+    /**
+     * Best-effort `channels.status` probe used to choose the connected menu's primary button. Caches
+     * and returns whether any messaging channel is configured. On an unreachable gateway it returns
+     * the last-known value (or false), so the menu falls back to "Web UI" rather than hanging.
+     */
+    async refreshHasConfiguredChannels() {
+        const ref = this._bridgeRef;
+        if (!ref?.request) {
+            return this._hasConfiguredChannelsCache ?? false;
+        }
+        try {
+            const { rows } = await (0, openclaw_channel_routing_js_1.fetchMeetAgentChannelContext)(ref.request.bind(ref));
+            this._hasConfiguredChannelsCache = rows.length > 0;
+        }
+        catch (err) {
+            this.log(`channels.status probe failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
+            this._hasConfiguredChannelsCache ??= false;
+        }
+        return this._hasConfiguredChannelsCache;
+    }
+    async openAskAgentHippoChat() {
+        await vscode.commands.executeCommand("workbench.action.chat.newChat", {
+            agentMode: true,
+        });
+        const initialQuery = "use openclaw skill as needed.";
+        await vscode.commands.executeCommand("workbench.action.chat.open", {
+            mode: "agent",
+            query: initialQuery,
+            // Prefill without auto-sending; user can review/edit before sending.
+            isPartialQuery: true,
+        });
+    }
+    // ============================================================================
+    // Meet Agent at... (channel binding picker)
+    // ============================================================================
+    /**
+     * Show a QuickPick to choose which channels this agent should receive messages from.
+     * Queries the gateway for available channels and current bindings, then writes
+     * the selected bindings back via config.patch (route bindings).
+     */
+    async showMeetAgentPicker(agentId) {
+        if (!this._bridgeRef?.request) {
+            vscode.window.showWarningMessage("Not connected to gateway.");
+            return;
+        }
+        const request = this._bridgeRef.request.bind(this._bridgeRef);
+        let didScopeRetry = false;
+        const requestWithScopeRetry = async (method, params) => {
+            try {
+                return await request(method, params);
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                if (!didScopeRetry && (0, gateway_scope_errors_js_1.isGatewayScopeAuthError)(message)) {
+                    didScopeRetry = true;
+                    this.log(`Gateway denied RPC (${message}); reconnecting with fresh handshake...`);
+                    await this.disconnectBridge();
+                    await this.connectBridge();
+                    // Rebind after reconnect just in case the ref changed.
+                    if (!this._bridgeRef?.request) {
+                        throw err;
+                    }
+                    return await this._bridgeRef.request(method, params);
+                }
+                throw err;
+            }
+        };
+        try {
+            // Fetch available channels from the gateway (OpenClaw: channels.status).
+            this.log("Meet Agent: fetching channels.status...");
+            const { rows: channels, statusPayload } = await (0, openclaw_channel_routing_js_1.fetchMeetAgentChannelContext)(requestWithScopeRetry);
+            this.log(`Meet Agent: got ${channels?.length ?? 0} channel(s): ${channels?.map((c) => c.id).join(", ") ?? "none"}`);
+            if (!channels || channels.length === 0) {
+                const choice = await vscode.window.showInformationMessage("No messaging channels (Telegram, WhatsApp, etc.) are configured. You can chat with your agent in the Gateway Web UI, or set up channels in OpenClaw config.", "Open Web UI", "Open Config");
+                if (choice === "Open Web UI") {
+                    await this.openWebUI();
+                }
+                else if (choice === "Open Config") {
+                    await this.openConfig();
+                }
+                return;
+            }
+            // Fetch current bindings for this agent to pre-select.
+            // Use the first registered agent if no specific agentId provided.
+            const resolvedAgentId = agentId ?? await this.getFirstRegisteredAgentId();
+            if (!resolvedAgentId) {
+                vscode.window.showWarningMessage("No agent registered with the gateway.");
+                return;
+            }
+            // Get current bindings from the agents.register response or agents.list.
+            const agentsList = await requestWithScopeRetry("agents.list");
+            const externalAgent = agentsList.external?.find((a) => a.id.toLowerCase() === resolvedAgentId.toLowerCase());
+            const currentlyBound = new Set(externalAgent?.boundChannels?.map((c) => c.toLowerCase()) ?? []);
+            const items = channels.map((ch) => ({
+                channelId: ch.id,
+                label: ch.label,
+                description: ch.connected ? "connected" : "offline",
+                detail: ch.accounts.length > 1 ? `Accounts: ${ch.accounts.join(", ")}` : undefined,
+                picked: currentlyBound.has(ch.id.toLowerCase()),
+            }));
+            const picked = await vscode.window.showQuickPick(items, {
+                canPickMany: true,
+                title: `Meet ${resolvedAgentId} at...`,
+                placeHolder: "Select channels where people can reach this agent",
+            });
+            if (!picked) {
+                return; // User cancelled.
+            }
+            const selectedChannels = picked.map((item) => item.channelId);
+            // Write route bindings via config.patch (replaces removed bindings.set).
+            await (0, openclaw_channel_routing_js_1.applyAgentChannelBindingsViaConfigPatch)(requestWithScopeRetry, {
+                agentId: resolvedAgentId,
+                selectedChannelIds: selectedChannels,
+                statusPayload,
+            });
+            if (selectedChannels.length === 0) {
+                vscode.window.showInformationMessage(`${resolvedAgentId}: all channel bindings removed.`);
+            }
+            else {
+                const names = picked.map((item) => item.label).join(", ");
+                vscode.window.showInformationMessage(`${resolvedAgentId} can now be reached at: ${names}`);
+            }
+        }
+        catch (err) {
+            this.log(`Meet Agent picker failed: ${err}`);
+            vscode.window.showErrorMessage(`Failed to configure channels: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    async getFirstRegisteredAgentId() {
+        if (!this._bridgeRef?.request) {
+            return undefined;
+        }
+        try {
+            const result = await this._bridgeRef.request("agents.list");
+            return result.external?.[0]?.id;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    // ============================================================================
+    // Detect
+    // ============================================================================
+    async detect() {
+        const port = this.getGatewayPort();
+        const baseResult = await detectGateway(port);
+        let result = baseResult;
+        // Do not clobber in-progress lifecycle UI while setup/teardown runs in terminals.
+        if (this._gatewayInstallInProgress || this._gatewayUninstallInProgress) {
+            this._lastDetection = result;
+            return result;
+        }
+        // Do not downgrade "starting" back to "installed" while start() is in-flight.
+        if (this._startInFlight && this._status === "starting") {
+            this._lastDetection = result;
+            return result;
+        }
+        if (!result.running && result.installed) {
+            const managedInstallPresent = await this.hasGlobalNpmOpenclawTree();
+            if (!managedInstallPresent) {
+                result = { ...result, installed: false };
+            }
+        }
+        this._lastDetection = result;
+        if (result.running) {
+            this.setStatus("running");
+        }
+        else if (result.installed) {
+            this.setStatus("installed");
+        }
+        else {
+            this.setStatus("not-installed");
+        }
+        return result;
+    }
+    // ============================================================================
+    // Install
+    // ============================================================================
+    async install() {
+        const installSource = this.getConfig("installSource", "");
+        const port = this.getGatewayPort();
+        if (!installSource) {
+            vscode.window.showErrorMessage(`${exports.AGENT_ANYWHERE_LABEL}: Install source not configured. Set "agentide.anywhere.installSource" in settings.`);
+            return false;
+        }
+        // Security: validate installSource to prevent command injection.
+        // Allowed: npm package names, scoped packages, git repos, local paths, version specifiers.
+        // Reject: semicolons, backticks, pipes, $(), &&, ||, newlines, etc.
+        if (/[;`|$&\n\r]/.test(installSource) || /\$\(/.test(installSource)) {
+            vscode.window.showErrorMessage(`${exports.AGENT_ANYWHERE_LABEL}: Invalid install source - contains disallowed characters. Check "agentide.anywhere.installSource" in settings.`);
+            this.log(`Rejected installSource due to suspicious characters: ${installSource}`);
+            return false;
+        }
+        if (this._gatewayInstallInProgress) {
+            const dupChoice = await vscode.window.showInformationMessage(`${exports.AGENT_ANYWHERE_LABEL}: Install is already in progress. Watch the "${exports.AGENT_ANYWHERE_LABEL} Setup" terminal.`, "Show Setup Terminal", "OK");
+            if (dupChoice === "Show Setup Terminal") {
+                if (!this.revealInstallSetupTerminal()) {
+                    await this.showMissingInstallSetupTerminalPrompt();
+                }
+            }
+            return false;
+        }
+        this.setInstallProgressFlag(true, "install command started");
+        try {
+            this.log(`Installing gateway from: ${installSource}`);
+            (0, index_1.clearBinaryCache)(FORK_CLI_NAME);
+            (0, index_1.clearBinaryCache)("openclaw");
+            // Prevent the status bar from flipping to "running" while install is in
+            // progress. During the install window, the port may transiently open,
+            // and `detect()` would otherwise turn the icon green early.
+            this.setStatus("starting");
+            this.stopHealthChecks();
+            // Stop a running gateway before setup so npm/git can replace the global
+            // CLI without file locks on the binary (especially on Windows).
+            const snapshot = await this.detectGatewayState(port);
+            this._lastDetection = snapshot;
+            if (snapshot.running) {
+                this.log("Stopping gateway before install...");
+                await this.disconnectBridge();
+                await this.stop();
+            }
+            // Find the setup script (platform-specific: .ps1 on Windows, .sh elsewhere)
+            const scriptExt = IS_WINDOWS ? "setup-gateway.ps1" : "setup-gateway.sh";
+            const scriptCandidates = [
+                path.join(__dirname, "..", "..", "scripts", "gateway", scriptExt),
+                path.join(__dirname, "..", "scripts", "gateway", scriptExt),
+            ];
+            const scriptPath = scriptCandidates.find((p) => fs.existsSync(p));
+            // Find the config template
+            const templateCandidates = [
+                path.join(__dirname, "..", "..", "base-prompts", "gateway", "openclaw-starter.json5"),
+                path.join(__dirname, "..", "base-prompts", "gateway", "openclaw-starter.json5"),
+            ];
+            const templatePath = templateCandidates.find((p) => fs.existsSync(p));
+            let terminalOptions;
+            if (scriptPath && IS_WINDOWS) {
+                // Windows: run PowerShell script
+                const args = [`-Source "${installSource}"`];
+                if (templatePath) {
+                    args.push(`-ConfigTemplate "${templatePath}"`);
+                }
+                const psCmd = `& "${scriptPath}" ${args.join(" ")}; Write-Host ""; Write-Host "You can close this window."`;
+                terminalOptions = {
+                    name: AGENT_ANYWHERE_SETUP_TERMINAL,
+                    shellPath: "powershell.exe",
+                    shellArgs: ["-NoProfile", "-NoExit", "-ExecutionPolicy", "Bypass", "-Command", psCmd],
+                };
+            }
+            else if (scriptPath) {
+                // macOS/Linux: run bash script
+                const args = [`--source "${installSource}"`];
+                if (templatePath) {
+                    args.push(`--config-template "${templatePath}"`);
+                }
+                const setupCmd = `bash "${scriptPath}" ${args.join(" ")}`;
+                const holdOpenCmd = `${setupCmd}; echo ""; echo "Press Enter to close..."; read`;
+                terminalOptions = {
+                    name: AGENT_ANYWHERE_SETUP_TERMINAL,
+                    shellPath: getAnywhereSetupShellPath(),
+                    shellArgs: getAnywhereSetupShellArgs(holdOpenCmd),
+                    env: anywhereSetupTerminalEnv(),
+                };
+            }
+            else {
+                // Fallback: raw npm install (script not bundled)
+                this.log("Setup script not found, falling back to npm install");
+                const fallbackCmd = `npm install -g ${installSource}`;
+                const holdOpenCmd = `${fallbackCmd}; echo ""; echo "Press Enter to close..."; read`;
+                terminalOptions = IS_WINDOWS
+                    ? { name: AGENT_ANYWHERE_SETUP_TERMINAL, shellPath: "cmd.exe", shellArgs: ["/c", `${fallbackCmd} && echo. && echo Setup complete. && pause`] }
+                    : {
+                        name: AGENT_ANYWHERE_SETUP_TERMINAL,
+                        shellPath: getAnywhereSetupShellPath(),
+                        shellArgs: getAnywhereSetupShellArgs(holdOpenCmd),
+                        env: anywhereSetupTerminalEnv(),
+                    };
+            }
+            // Run in a visible terminal so user can see progress
+            try {
+                fs.rmSync(GATEWAY_INSTALL_STATUS_FILE, { force: true });
+            }
+            catch {
+                // ignore stale install status cleanup failures
+            }
+            this._installProgressMessage = "Launching setup...";
+            this.updateStatusBar("starting");
+            const terminal = vscode.window.createTerminal(terminalOptions);
+            this._installSetupTerminal = terminal;
+            terminal.show();
+            const installTimeoutMs = installSourceNeedsBuild(installSource)
+                ? 10 * 60_000
+                : 120_000;
+            this.log(`Waiting up to ${Math.round(installTimeoutMs / 60_000)} minute(s) for gateway install completion...`);
+            const useInstallStatusMarker = IS_WINDOWS && !!scriptPath;
+            const installSucceeded = await vscode.window.withProgress({
+                location: vscode.ProgressLocation.Window,
+                title: `${exports.AGENT_ANYWHERE_LABEL}: Installing gateway...`,
+                cancellable: false,
+            }, async (progress) => {
+                const deadline = Date.now() + installTimeoutMs;
+                let lastPercent = 0;
+                while (Date.now() < deadline) {
+                    if (!this._gatewayInstallInProgress) {
+                        this.log("Gateway install wait aborted — setup terminal closed before completion was detected");
+                        return false;
+                    }
+                    const installStatus = this.readInstallStatusSnapshot();
+                    const summary = this.getInstallProgressSummary(installStatus);
+                    this._installProgressMessage = summary.message;
+                    this.updateStatusBar("starting");
+                    const increment = Math.max(0, summary.percent - lastPercent);
+                    progress.report({ message: summary.message, increment });
+                    lastPercent = Math.max(lastPercent, summary.percent);
+                    if (installStatus?.phase === "failed") {
+                        this.log(`Gateway install failed: ${installStatus.lastError || installStatus.message || "unknown error"}`);
+                        return false;
+                    }
+                    (0, index_1.clearBinaryCache)(FORK_CLI_NAME);
+                    (0, index_1.clearBinaryCache)("openclaw");
+                    const result = await this.detectGatewayState(port);
+                    this._lastDetection = result;
+                    const installReady = useInstallStatusMarker
+                        ? isGatewayInstallComplete(installStatus) && result.installed
+                        : result.installed;
+                    if (installReady) {
+                        this.log("Gateway installed successfully");
+                        await this.ensureManagedGatewayWrapperState(result.binaryPath);
+                        // Build the web Control UI if it's missing.
+                        // The setup script should do this, but if it failed or was
+                        // skipped (e.g. missing pnpm), build it now so the UI works
+                        // out of the box for new users.
+                        await this.ensureWebUIBuilt(result.binaryPath);
+                        // Write starter config if none exists
+                        this.writeStarterConfig();
+                        // Auto-enable the feature now that it's installed
+                        const anywhereConfig = vscode.workspace.getConfiguration("agentide.anywhere");
+                        await anywhereConfig.update("enabled", true, vscode.ConfigurationTarget.Global);
+                        if (result.running) {
+                            this.finishInstallUiState("running", "success");
+                            progress.report({
+                                message: `Install complete. Gateway is running on port ${port}.`,
+                                increment: Math.max(0, 100 - lastPercent),
+                            });
+                        }
+                        else {
+                            this.finishInstallUiState("installed", "success");
+                            progress.report({
+                                message: "Install complete. Gateway is installed. Click Agent Anywhere to start.",
+                                increment: Math.max(0, 100 - lastPercent),
+                            });
+                        }
+                        // Install no longer auto-starts the gateway; starting is an explicit user action.
+                        void vscode.window.showInformationMessage(result.running
+                            ? `${exports.AGENT_ANYWHERE_LABEL}: Installed and running. Open the config to add your channels or use the status bar to connect.`
+                            : `${exports.AGENT_ANYWHERE_LABEL}: Installed. Open the config to add your channels, then click Agent Anywhere to start.`, "Open Config").then(async (choice) => {
+                            if (choice === "Open Config") {
+                                await this.openConfig();
+                            }
+                        });
+                        return true;
+                    }
+                    await new Promise((resolve) => setTimeout(resolve, 1_000));
+                }
+                return false;
+            });
+            if (!installSucceeded) {
+                this.log("Gateway install timed out or failed");
+                this.finishInstallUiState("error", "failure");
+                return false;
+            }
+            return true;
+        }
+        catch (e) {
+            this.log(`Install failed: ${e instanceof Error ? e.message : String(e)}`);
+            this.finishInstallUiState("error", "failure");
+            return false;
+        }
+        finally {
+            if (this._gatewayInstallInProgress) {
+                this.setInstallProgressFlag(false, "finally");
+                this._installProgressMessage = undefined;
+            }
+            this.updateStatusBar(this._status);
+        }
+    }
+    /**
+     * Remove the globally installed `openclaw` npm package (runs setup script --uninstall / -Uninstall).
+     * The script runs `openclaw uninstall --service --yes --non-interactive` when the CLI exists,
+     * then `npm uninstall -g openclaw`, then frees loopback listener(s) if still bound (see OpenClaw docs: /cli/uninstall).
+     * Does not delete ~/.openclaw (config, sessions, credentials) unless the user runs OpenClaw with --state.
+     */
+    async uninstall() {
+        if (this._gatewayUninstallInProgress) {
+            await this.showGatewayUninstallInProgressPrompt();
+            return;
+        }
+        await this.stop();
+        const scriptExt = IS_WINDOWS ? "setup-gateway.ps1" : "setup-gateway.sh";
+        const scriptCandidates = [
+            path.join(__dirname, "..", "scripts", "gateway", scriptExt),
+            path.join(__dirname, "..", "..", "scripts", "gateway", scriptExt),
+        ];
+        const scriptPath = scriptCandidates.find((p) => fs.existsSync(p));
+        let terminalOptions;
+        if (scriptPath && IS_WINDOWS) {
+            const psCmd = `& "${scriptPath}" -Uninstall; Write-Host ""; Write-Host "You can close this window."`;
+            terminalOptions = {
+                name: AGENT_ANYWHERE_UNINSTALL_TERMINAL,
+                shellPath: "powershell.exe",
+                shellArgs: ["-NoProfile", "-NoExit", "-ExecutionPolicy", "Bypass", "-Command", psCmd],
+            };
+        }
+        else if (scriptPath) {
+            const setupCmd = `bash "${scriptPath}" --uninstall`;
+            const holdOpenCmd = `${setupCmd}; echo ""; echo "Press Enter to close..."; read`;
+            terminalOptions = {
+                name: AGENT_ANYWHERE_UNINSTALL_TERMINAL,
+                shellPath: getAnywhereSetupShellPath(),
+                shellArgs: getAnywhereSetupShellArgs(holdOpenCmd),
+                env: anywhereSetupTerminalEnv(),
+            };
+        }
+        else {
+            const fallbackCmd = "npm uninstall -g openclaw";
+            const holdOpenCmd = `${fallbackCmd}; echo ""; echo "Press Enter to close..."; read`;
+            terminalOptions = IS_WINDOWS
+                ? {
+                    name: AGENT_ANYWHERE_UNINSTALL_TERMINAL,
+                    shellPath: "cmd.exe",
+                    shellArgs: ["/c", `${fallbackCmd} && echo. && pause`],
+                }
+                : {
+                    name: AGENT_ANYWHERE_UNINSTALL_TERMINAL,
+                    shellPath: getAnywhereSetupShellPath(),
+                    shellArgs: getAnywhereSetupShellArgs(holdOpenCmd),
+                    env: anywhereSetupTerminalEnv(),
+                };
+        }
+        this._gatewayUninstallInProgress = true;
+        this.setStatus("stopping");
+        try {
+            const terminal = vscode.window.createTerminal(terminalOptions);
+            this._uninstallSetupTerminal = terminal;
+            terminal.show();
+            this.log("Gateway uninstall started in terminal");
+            (0, index_1.clearBinaryCache)(FORK_CLI_NAME);
+            (0, index_1.clearBinaryCache)("openclaw");
+            await this.sleep(this.getUninstallInitialDelayMs());
+            const deadline = Date.now() + this.getUninstallVerificationTimeoutMs();
+            let lastResult;
+            let managedInstallPresent = true;
+            while (Date.now() < deadline) {
+                (0, index_1.clearBinaryCache)(FORK_CLI_NAME);
+                (0, index_1.clearBinaryCache)("openclaw");
+                const result = await this.detectGatewayState(this.getGatewayPort());
+                lastResult = result;
+                this._lastDetection = result;
+                managedInstallPresent = await this.hasGlobalNpmOpenclawTree();
+                // If the npm-managed OpenClaw package is gone and no local listener is alive,
+                // consider Agent Anywhere uninstall complete even if another `openclaw`
+                // binary remains on PATH (for example, a self-updated/external install).
+                if (!managedInstallPresent && !result.running) {
+                    removeManagedGatewayWrapperState();
+                    this.setStatus("not-installed");
+                    if (result.installed) {
+                        this.log("Managed OpenClaw npm package removed; another OpenClaw binary remains on PATH (likely external/self-updated).");
+                    }
+                    else {
+                        this.log("Global OpenClaw package removed (or no longer detected).");
+                    }
+                    return;
+                }
+                if (!result.installed) {
+                    removeManagedGatewayWrapperState();
+                    this.setStatus("not-installed");
+                    this.log("Global OpenClaw package removed (or no longer detected).");
+                    return;
+                }
+                await this.sleep(this.getUninstallCheckIntervalMs());
+            }
+            if (!managedInstallPresent && lastResult?.running) {
+                void vscode.window.showWarningMessage(`${exports.AGENT_ANYWHERE_LABEL}: Managed package was removed, but the gateway listener still appears to be running. Finish the terminal command or run Status.`);
+            }
+            else {
+                void vscode.window.showWarningMessage(`${exports.AGENT_ANYWHERE_LABEL}: Uninstall is still verifying managed package removal. Finish the terminal command or run Status.`);
+            }
+        }
+        finally {
+            this._gatewayUninstallInProgress = false;
+            this.updateStatusBar(this._status);
+        }
+    }
+    // ============================================================================
+    // Config
+    // ============================================================================
+    /** Path to the OpenClaw config file */
+    get configPath() {
+        return path.join(os.homedir(), ".openclaw", "openclaw.json");
+    }
+    /**
+     * Write a starter openclaw.json if none exists.
+     * Reads the template from base-prompts/gateway/openclaw-starter.json5
+     * (copied to out/ during compile). JSON5 format -- comments supported by OpenClaw.
+     */
+    writeStarterConfig() {
+        const configDir = path.dirname(this.configPath);
+        if (fs.existsSync(this.configPath)) {
+            this.log("Config already exists, skipping starter config");
+            return;
+        }
+        // Find the starter template (check compiled output first, then source for dev)
+        const templateCandidates = [
+            path.join(__dirname, "..", "base-prompts", "gateway", "openclaw-starter.json5"),
+            path.join(__dirname, "..", "..", "base-prompts", "gateway", "openclaw-starter.json5"),
+        ];
+        const templatePath = templateCandidates.find((p) => fs.existsSync(p));
+        if (!templatePath) {
+            this.log("Starter config template not found, skipping");
+            return;
+        }
+        fs.mkdirSync(configDir, { recursive: true, mode: 0o700 });
+        // Read template and replace placeholder token with a random one
+        let content = fs.readFileSync(templatePath, "utf-8");
+        const randomToken = `ah-${(0, crypto_1.randomBytes)(24).toString("hex")}`;
+        content = content.replace("__GENERATED_TOKEN__", randomToken);
+        fs.writeFileSync(this.configPath, content, { encoding: "utf-8", mode: IS_WINDOWS ? undefined : 0o600 });
+        this.log(`Wrote starter config to ${this.configPath}`);
+    }
+    /**
+     * Open the OpenClaw config file in the editor.
+     */
+    async openConfig() {
+        if (!fs.existsSync(this.configPath)) {
+            this.writeStarterConfig();
+        }
+        const doc = await vscode.workspace.openTextDocument(this.configPath);
+        await vscode.window.showTextDocument(doc);
+    }
+    async startGatewayViaHiddenWindowsProcess(spawnExe, spawnArgs, logPath, errorLogPath, gatewayEnv) {
+        const argumentLine = (0, windowsCommandLine_js_1.buildWindowsArgumentLine)(spawnArgs);
+        const argumentClause = argumentLine.length > 0
+            ? ` -ArgumentList '${escapePowerShellSingleQuotedString(argumentLine)}'`
+            : "";
+        const psCommand = [
+            `$proc = Start-Process -FilePath '${escapePowerShellSingleQuotedString(spawnExe)}' -WindowStyle Hidden${argumentClause} -RedirectStandardOutput '${escapePowerShellSingleQuotedString(logPath)}' -RedirectStandardError '${escapePowerShellSingleQuotedString(errorLogPath)}' -PassThru`,
+            "Write-Output $proc.Id",
+        ].join("; ");
+        return new Promise((resolve) => {
+            let stdout = "";
+            let stderr = "";
+            const launcher = (0, child_process_1.spawn)("powershell.exe", ["-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", psCommand], {
+                windowsHide: true,
+                env: gatewayEnv,
+            });
+            launcher.stdout.on("data", (data) => {
+                stdout += data.toString();
+            });
+            launcher.stderr.on("data", (data) => {
+                stderr += data.toString();
+            });
+            launcher.once("error", (err) => {
+                this.log(`Gateway hidden Windows launcher failed to spawn: ${err}`);
+                resolve(undefined);
+            });
+            launcher.once("exit", (code) => {
+                if (code !== 0) {
+                    const detail = stderr.trim() || stdout.trim();
+                    this.log(`Gateway hidden Windows launcher exited with code ${code}${detail ? `: ${detail}` : ""}`);
+                    resolve(undefined);
+                    return;
+                }
+                const startedPid = parseInt(stdout.trim(), 10);
+                if (!Number.isNaN(startedPid)) {
+                    this.log(`Gateway hidden Windows process started (PID: ${startedPid})`);
+                    resolve(startedPid);
+                    return;
+                }
+                this.log("Gateway hidden Windows launcher did not return a PID");
+                resolve(undefined);
+            });
+        });
+    }
+    // ============================================================================
+    // Start
+    // ============================================================================
+    async start() {
+        if (this._gatewayUninstallInProgress) {
+            await this.showGatewayUninstallInProgressPrompt();
+            return;
+        }
+        if (this._startInFlight) {
+            this.setStatus("starting");
+            await this._startInFlight;
+            return;
+        }
+        this.setStatus("starting");
+        const startPromise = this.doStart();
+        this._startInFlight = startPromise;
+        try {
+            await startPromise;
+        }
+        finally {
+            if (this._startInFlight === startPromise) {
+                this._startInFlight = null;
+            }
+        }
+    }
+    async doStart() {
+        // Fast check first: if PID file says running, skip slow detection
+        const port = this.getGatewayPort();
+        const fast = await this.detectGatewayFastState(port);
+        if (fast?.running) {
+            this.log("Gateway already running (fast check)");
+            this._lastDetection = fast;
+            this.setStatus("running");
+            return;
+        }
+        // Full detection needed (finds binary path, checks install status)
+        const detection = await this.detect();
+        const portOccupied = await this.probeGatewayPort(port);
+        if (!detection.installed) {
+            if (portOccupied) {
+                const approved = await this.promptNonManagedPortTakeover(port, "start");
+                if (!approved || (await this.probeGatewayPort(port))) {
+                    this.setStatus("error");
+                    return;
+                }
+            }
+            const doInstall = await vscode.window.showWarningMessage(`${exports.AGENT_ANYWHERE_LABEL}: Gateway is not installed.`, "Install Now");
+            if (doInstall === "Install Now") {
+                await this.install();
+            }
+            else {
+                // Dismiss leaves start(); we must not keep "starting" (blocks background detect / toggle).
+                this.setStatus("not-installed");
+            }
+            return;
+        }
+        if (detection.running) {
+            this.log("Gateway already running");
+            this.setStatus("running");
+            return;
+        }
+        if (portOccupied) {
+            const approved = await this.promptNonManagedPortTakeover(port, "start");
+            if (!approved || (await this.probeGatewayPort(port))) {
+                this.setStatus("error");
+                return;
+            }
+        }
+        if (!detection.binaryPath) {
+            this.setStatus("error");
+            vscode.window.showErrorMessage(`${exports.AGENT_ANYWHERE_LABEL}: Gateway binary not found. Try reinstalling.`);
+            return;
+        }
+        const binaryPath = detection.binaryPath;
+        // Final attach guard: detection.running was evaluated earlier, but detection and the
+        // stale-lock cleanup below take seconds (CLI `--version`, `gateway stop`), during which a
+        // healthy gateway -- ours from a prior start, or one started via the CLI -- can bind the
+        // port. Re-check now and attach instead of force-respawning, which would kill it.
+        if ((await this.probeGatewayPort(port)) && (await isTrustedGatewayListener(port, binaryPath))) {
+            this.log("Healthy gateway already listening; attaching instead of starting a new one");
+            this._lastDetection = { ...detection, running: true };
+            this.setStatus("running");
+            return;
+        }
+        // Best-effort stale-lock cleanup: OpenClaw can report "gateway already running"
+        // even when no trusted listener is present, for example after a crashed prior
+        // instance. Ask the CLI to stop first so a fresh local start can succeed.
+        await this.stopExistingGatewayBeforeStart(binaryPath);
+        await this.removeStaleGatewayLockBeforeStart(port);
+        // Only force-free the port when something still holds it right before launch (a non-managed
+        // listener, or a straggler from a crashed prior instance). When the port is free -- the
+        // normal case -- omit `--force` so we never kill a gateway that bound during startup.
+        // stop() now reliably reaps our own listener, so `--force` is no longer needed for restarts.
+        const gatewayArgs = ["gateway", "run", "--bind", "loopback", "--port", String(port)];
+        if (await this.probeGatewayPort(port)) {
+            gatewayArgs.push("--force");
+        }
+        let spawnExe = binaryPath;
+        let spawnArgs = gatewayArgs;
+        let spawnShell = false;
+        const isWindowsLaunch = this.isWindowsLaunch();
+        if (isWindowsLaunch) {
+            // Windows lifecycle launch must avoid shell-backed .cmd/.ps1 shims. Those wrappers can
+            // create a visible console window and make detached startup behave like a terminal-owned
+            // session. Repair the managed runtime metadata if needed, then launch node.exe directly.
+            const windowsLaunchRuntime = await this.resolveWindowsManagedGatewayLaunchRuntime(binaryPath);
+            if (!windowsLaunchRuntime) {
+                this.setStatus("installed");
+                const choice = await vscode.window.showWarningMessage(`${exports.AGENT_ANYWHERE_LABEL}: Windows background start requires managed gateway runtime metadata. Reinstall Agent Anywhere to refresh the launch configuration.`, "Reinstall");
+                if (choice === "Reinstall") {
+                    await this.install();
+                }
+                return;
+            }
+            spawnExe = windowsLaunchRuntime.nodePath;
+            spawnArgs = [windowsLaunchRuntime.entryScriptPath, ...gatewayArgs];
+        }
+        // Gateway log file -- survives IDE restarts so users can debug issues
+        const logDir = path.dirname(DEFAULT_GATEWAY_LOG_PATH);
+        fs.mkdirSync(logDir, { recursive: true });
+        const logPath = DEFAULT_GATEWAY_LOG_PATH;
+        const errorLogPath = path.join(logDir, "gateway.error.log");
+        this.log(`Starting gateway: ${spawnExe} ${spawnArgs.join(" ")}`);
+        this.log(`Gateway log: ${logPath}`);
+        // Re-reads ~/.agent-hippo/.env and overlays managed secret keys so token rotations
+        // (e.g. switching Slack apps) take effect here instead of reusing the stale process.env
+        // snapshot captured at extension activation.
+        const gatewayEnv = await (0, agentEnvFile_js_1.readGatewayChildProcessEnv)();
+        // The IDE spawns the gateway directly (detached), with no launchd/systemd supervisor. On a
+        // config-triggered restart the gateway would otherwise take the "supervised" path -- exit(0)
+        // expecting a supervisor to relaunch it -- and never come back. Force the in-process restart
+        // path so SIGUSR1 restarts re-listen in the same process and survive (no supervisor needed).
+        gatewayEnv.OPENCLAW_NO_RESPAWN = "1";
+        for (const key of agentEnvFile_js_1.GATEWAY_SECRET_ENV_KEYS) {
+            if (gatewayEnv[key]?.trim()) {
+                this.log(`Gateway env: ${key} present for child process`);
+            }
+        }
+        let startedPid;
+        if (isWindowsLaunch) {
+            startedPid = await this.startGatewayViaHiddenWindowsProcess(spawnExe, spawnArgs, logPath, errorLogPath, gatewayEnv);
+            this.process = null;
+            if (!startedPid) {
+                this.setStatus("error");
+                await showGatewayStartFailedToast(logPath);
+                return;
+            }
+        }
+        else {
+            const logFd = fs.openSync(logPath, "a");
+            this.process = (0, child_process_1.spawn)(spawnExe, spawnArgs, {
+                stdio: ["ignore", logFd, logFd],
+                detached: true, // Persist across IDE restarts
+                env: gatewayEnv,
+                shell: spawnShell,
+                windowsHide: true, // Prevent cmd.exe window appearing on Windows
+            });
+            // Close the log fd in this process -- the child owns it now
+            fs.closeSync(logFd);
+            // Detach: let the gateway keep running after the IDE exits.
+            // The IDE only manages the process lifecycle via explicit Start/Stop commands.
+            this.process.unref();
+            this.process.on("exit", (code) => {
+                this.log(`Gateway process exited with code ${code}`);
+                this.process = null;
+                // Clean up PID file
+                void removeGatewayPidFile();
+                // While start()/doStart readiness runs, that loop owns terminal status (Unix: clean exit
+                // before the port opens must surface as error, not "installed", vs this handler).
+                if (this._startInFlight) {
+                    return;
+                }
+                this.setStatus(code !== 0 && code !== null ? "error" : "installed");
+            });
+        }
+        // Wait for gateway readiness in the window progress area. VS Code progress
+        // notifications only support a Cancel button, not an X-only close affordance.
+        await vscode.window.withProgress({
+            location: vscode.ProgressLocation.Window,
+            title: `${exports.AGENT_ANYWHERE_LABEL}: Starting gateway...`,
+        }, async (progress) => {
+            try {
+                const startTime = Date.now();
+                const startupTimeoutMs = this.getStartupTimeoutMs();
+                const launchGraceMs = this.getStartupLaunchGraceMs();
+                const checkInterval = this.getStartupCheckIntervalMs();
+                let elapsed = 0;
+                let lastPercent = 0;
+                let sawLaunchedProcessAlive = false;
+                let loggedLaunchedProcessExit = false;
+                const trackingPid = this.process?.pid ?? startedPid;
+                while (true) {
+                    if (await this.probeGatewayPort(port)) {
+                        this.setStatus("running");
+                        this.log(`Gateway started and ready (${elapsed}ms)`);
+                        // Write PID file for fast subsequent status checks
+                        const pidForTracking = this.process?.pid ?? startedPid;
+                        if (pidForTracking) {
+                            await this.writeGatewayPidRecord(pidForTracking, port, binaryPath);
+                            this.log(`PID file written: ${GATEWAY_PID_FILE}`);
+                        }
+                        this.startHealthChecks(port);
+                        progress.report({ message: "Ready!", increment: 100 });
+                        return;
+                    }
+                    const processAlive = this.isStartedGatewayProcessAlive(trackingPid);
+                    if (trackingPid && processAlive) {
+                        sawLaunchedProcessAlive = true;
+                    }
+                    elapsed = Date.now() - startTime;
+                    const withinPrimaryTimeout = elapsed < startupTimeoutMs;
+                    const withinLaunchGrace = trackingPid !== undefined &&
+                        processAlive &&
+                        sawLaunchedProcessAlive &&
+                        elapsed < startupTimeoutMs + launchGraceMs;
+                    if (trackingPid && sawLaunchedProcessAlive && !processAlive && !isWindowsLaunch) {
+                        this.setStatus("error");
+                        this.log(`Gateway process exited before opening port ${port}`);
+                        await showGatewayStartFailedToast(logPath);
+                        return;
+                    }
+                    if (trackingPid && sawLaunchedProcessAlive && !processAlive && isWindowsLaunch && !loggedLaunchedProcessExit) {
+                        loggedLaunchedProcessExit = true;
+                        this.log(`Gateway launch process exited before opening port ${port}; continuing to wait for port readiness`);
+                    }
+                    if (!withinPrimaryTimeout && !withinLaunchGrace) {
+                        break;
+                    }
+                    const denominator = Math.max(startupTimeoutMs + (withinLaunchGrace ? launchGraceMs : 0), 1);
+                    const pct = Math.min(90, Math.floor((elapsed / denominator) * 100));
+                    const increment = Math.max(0, pct - lastPercent);
+                    lastPercent = pct;
+                    const progressMessage = trackingPid !== undefined
+                        ? processAlive
+                            ? `Gateway launched (PID ${trackingPid}), waiting for port ${port}...`
+                            : `Waiting for gateway process to initialize...`
+                        : `Waiting for port ${port}...`;
+                    progress.report({ message: progressMessage, increment });
+                    await this.sleep(checkInterval);
+                }
+                // Timeout
+                this.setStatus("error");
+                this.log(`Gateway failed to start within timeout (pid=${trackingPid ?? "n/a"}, alive=${trackingPid !== undefined ? this.isStartedGatewayProcessAlive(trackingPid) : false})`);
+                await showGatewayStartFailedToast(logPath);
+            }
+            catch {
+                this.setStatus("error");
+                this.log("Gateway failed to start");
+                await showGatewayStartFailedToast(logPath);
+            }
+        });
+    }
+    // ============================================================================
+    // Stop
+    // ============================================================================
+    async stop() {
+        this.stopHealthChecks();
+        // Clear bridge UI state immediately so we don't show green "Connected" while
+        // the gateway is being torn down (or if stop fails but the socket was stale).
+        await this.disconnectBridge();
+        if (this.process) {
+            // We started it -- graceful shutdown
+            this.setStatus("stopping");
+            this.log("Stopping gateway...");
+            const port = this.getGatewayPort();
+            const pid = this.process.pid;
+            // The gateway we spawn is a launcher whose CHILD process holds the listening socket.
+            // Capture the actual listener(s) now so we can confirm/reap them after the launcher exits.
+            const listenerPids = await getListeningProcessIdsForPort(port);
+            const observedPids = [
+                ...new Set([pid, ...listenerPids].filter((p) => typeof p === "number" && p > 0)),
+            ];
+            if (IS_WINDOWS && pid) {
+                // On Windows, SIGTERM maps to TerminateProcess which force-kills.
+                // Use taskkill /T to also kill child processes (node spawns).
+                await execAsync(`taskkill /F /T /PID ${pid}`, { timeout: 5_000 }).catch(() => { });
+            }
+            else {
+                // Signal the whole process group (we spawn detached, so the launcher is the group
+                // leader); its listening child shares the group and would otherwise be orphaned.
+                killGatewayProcessGroupOrSelf(this.process, pid, "SIGTERM");
+            }
+            const exited = await new Promise((resolve) => {
+                const timeout = setTimeout(() => resolve(false), 5_000);
+                this.process?.once("exit", () => {
+                    clearTimeout(timeout);
+                    resolve(true);
+                });
+            });
+            if (!exited && this.process) {
+                this.log("Forcefully killing gateway...");
+                if (IS_WINDOWS && pid) {
+                    await execAsync(`taskkill /F /T /PID ${pid}`, { timeout: 5_000 }).catch(() => { });
+                }
+                else {
+                    killGatewayProcessGroupOrSelf(this.process, pid, "SIGKILL");
+                }
+            }
+            this.process = null;
+            await removeGatewayPidFile();
+            // The launcher exiting does not guarantee its listening child died and released the port.
+            // Confirm the port is actually free; if not, reap the straggler by port (same mechanism as
+            // the external-stop path) so we never report "stopped" while the port is still held.
+            let freed = await waitForGatewayShutdown(port, observedPids);
+            if (!freed) {
+                this.log("Gateway port still held after process exit; reaping listener(s)...");
+                await killTcpListenersOnPort(port);
+                freed = await waitForGatewayShutdown(port, [
+                    ...observedPids,
+                    ...(await getListeningProcessIdsForPort(port)),
+                ]);
+            }
+            if (freed) {
+                this.setStatus("installed");
+                this.log("Gateway stopped");
+            }
+            else {
+                this.setStatus("running");
+                this.log("Could not free gateway port after stop");
+                vscode.window.showWarningMessage(`${exports.AGENT_ANYWHERE_LABEL}: Could not fully stop the gateway. Try stopping it manually.`);
+            }
+            return;
+        }
+        // We didn't start it -- check if something else is running
+        const detection = await this.detect();
+        if (!detection.running) {
+            this.log("Gateway is not running");
+            return;
+        }
+        // Kill external gateway process (CLI stop → pkill/CIM → port-based kill)
+        this.setStatus("stopping");
+        this.log("Stopping externally started gateway...");
+        const stopped = await stopExternalGatewayListener(detection.port, detection.binaryPath, (m) => this.log(m));
+        await removeGatewayPidFile();
+        if (stopped) {
+            this.setStatus("installed");
+            this.log("Gateway stopped");
+        }
+        else {
+            this.setStatus("running");
+            this.log("Could not stop gateway process");
+            vscode.window.showWarningMessage(`${exports.AGENT_ANYWHERE_LABEL}: Could not stop the gateway. Try stopping it manually.`);
+        }
+    }
+    async restartGateway() {
+        const wasConnected = this._bridgeRef?.isConnected ?? false;
+        await this.disconnectBridge();
+        let shouldStop = this._status === "running";
+        if (!shouldStop) {
+            // Lightweight runtime check to avoid full detect() latency.
+            shouldStop = await (0, index_1.probePort)(this.getGatewayPort(), "127.0.0.1", 250);
+        }
+        if (shouldStop) {
+            await this.stop();
+        }
+        else {
+            this.log("Restart requested while gateway is stopped; skipping stop.");
+        }
+        await this.start();
+        if (wasConnected && this._status === "running") {
+            await this.connectBridge();
+        }
+    }
+    // ============================================================================
+    // Status
+    // ============================================================================
+    async showStatus() {
+        this.setBridgeConnected(this._bridgeRef?.isConnected ?? false);
+        const port = this.getGatewayPort();
+        const detection = this._lastDetection ?? await this.detect();
+        // Build status summary
+        // allow-any-unicode-next-line
+        const gwStatus = detection.running ? "🟢 Running" : detection.installed ? "⚫ Stopped" : "⬜ Not installed";
+        // allow-any-unicode-next-line
+        const bridgeStatus = this._bridgeConnected ? "🟢 Connected" : "⚫ Disconnected";
+        const version = detection.version ? ` (${detection.version})` : "";
+        const message = [
+            `Gateway: ${gwStatus}${version}`,
+            `Bridge: ${bridgeStatus}`,
+            `Port: ${port}`,
+        ].join("\n");
+        if (!detection.installed) {
+            const choice = await vscode.window.showInformationMessage(`${exports.AGENT_ANYWHERE_LABEL}\n${message}`, "Set Up");
+            if (choice === "Set Up") {
+                await this.install();
+            }
+            return;
+        }
+        if (!detection.running) {
+            const choice = await vscode.window.showInformationMessage(`${exports.AGENT_ANYWHERE_LABEL}\n${message}`, "Connect", "Config", "Uninstall");
+            switch (choice) {
+                case "Connect":
+                    await this.start();
+                    if (this._status === "running") {
+                        await this.connectBridge();
+                    }
+                    break;
+                case "Config":
+                    await this.openConfig();
+                    break;
+                case "Uninstall":
+                    await this.uninstall();
+                    break;
+            }
+            return;
+        }
+        // Running -- show status details with maintenance actions
+        const choice = await vscode.window.showInformationMessage(`${exports.AGENT_ANYWHERE_LABEL}\n${message}`, "Web UI", "Config", "Restart", "Reset auth", "Uninstall");
+        switch (choice) {
+            case "Web UI":
+                await this.openWebUI();
+                break;
+            case "Config":
+                await this.openConfig();
+                break;
+            case "Restart":
+                await this.restartGateway();
+                break;
+            case "Reset auth":
+                await this.resetAuth();
+                break;
+            case "Uninstall":
+                await this.uninstall();
+                break;
+        }
+    }
+    async resetAuth() {
+        try {
+            if (!fs.existsSync(this.configPath)) {
+                this.writeStarterConfig();
+            }
+            const raw = fs.readFileSync(this.configPath, "utf-8");
+            const stripped = raw.replace(/^\s*\/\/.*$/gm, "").replace(/,\s*([}\]])/g, "$1");
+            const parsed = JSON.parse(stripped);
+            if (!parsed.gateway || typeof parsed.gateway !== "object") {
+                parsed.gateway = {};
+            }
+            if (!parsed.gateway.auth || typeof parsed.gateway.auth !== "object") {
+                parsed.gateway.auth = {};
+            }
+            const newToken = `ah-${(0, crypto_1.randomBytes)(24).toString("hex")}`;
+            parsed.gateway.auth.token = newToken;
+            fs.writeFileSync(this.configPath, `${JSON.stringify(parsed, null, 2)}\n`, {
+                encoding: "utf-8",
+                mode: IS_WINDOWS ? undefined : 0o600,
+            });
+            const gwConfig = vscode.workspace.getConfiguration("agentide.gateway");
+            if (vscode.workspace.workspaceFolders && vscode.workspace.workspaceFolders.length > 0) {
+                try {
+                    await gwConfig.update("token", newToken, vscode.ConfigurationTarget.Workspace);
+                }
+                catch (err) {
+                    this.log(`Workspace token update skipped: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }
+            // Always persist user scope so empty-window mode (no workspace) still works.
+            await gwConfig.update("token", newToken, vscode.ConfigurationTarget.Global);
+            await this.restartGateway();
+            void vscode.window.showInformationMessage(`${exports.AGENT_ANYWHERE_LABEL}: Auth reset; gateway restarted. If you use the Web UI, paste the new token in Control UI settings.`);
+        }
+        catch (err) {
+            this.log(`Failed to reset auth: ${err instanceof Error ? err.message : String(err)}`);
+            vscode.window.showErrorMessage(`${exports.AGENT_ANYWHERE_LABEL}: Failed to reset auth. Open Config to update it manually.`);
+        }
+    }
+    // ============================================================================
+    // Bridge Connect/Disconnect
+    // ============================================================================
+    /**
+     * Connect the bridge to the running gateway.
+     * Ensures the gateway.url setting is set, then delegates to GatewayService.connect().
+     */
+    async connectBridge() {
+        if (!this._bridgeRef) {
+            this.log("Bridge ref not set -- cannot connect");
+            return;
+        }
+        if (this._gatewayUninstallInProgress) {
+            await this.showGatewayUninstallInProgressPrompt();
+            return;
+        }
+        if (this._bridgeRef.isConnected) {
+            this.log("Bridge already connected");
+            return;
+        }
+        // Fast check: if we already know the gateway is running, skip full detection.
+        // Full detect() shells out to `openclaw --version` which adds 1-3s latency.
+        const port = this.getGatewayPort();
+        if (await (0, index_1.probePort)(port)) {
+            const trustedListener = await isTrustedGatewayListener(port, this._lastDetection?.binaryPath);
+            if (!trustedListener) {
+                const approved = await this.promptNonManagedPortTakeover(port, "connect");
+                if (!approved || (await (0, index_1.probePort)(port))) {
+                    if (this._status === "running") {
+                        this.setStatus("installed");
+                    }
+                    return;
+                }
+            }
+        }
+        let isRunning = this._status === "running";
+        if (!isRunning) {
+            // Try fast PID-file check first (~1-2ms)
+            const fast = await detectGatewayFast(port);
+            if (fast?.running) {
+                isRunning = true;
+                this._lastDetection = fast;
+                this.setStatus("running");
+            }
+        }
+        if (!isRunning) {
+            // Slow path: full detection only when necessary
+            const detection = await this.detect();
+            if (!detection.running) {
+                if (!detection.installed) {
+                    const choice = await vscode.window.showInformationMessage(`${exports.AGENT_ANYWHERE_LABEL}: Reach your AgentHippo IDE or CLI agents from WhatsApp, Telegram, Slack, Discord, and more - right from your phone or any messaging app. This will also install OpenClaw fork on your computer.`, "Set Up Agent Anywhere");
+                    if (choice === "Set Up Agent Anywhere") {
+                        await this.install();
+                    }
+                    return;
+                }
+                await this.start();
+                // Re-detect after start
+                const afterStart = await this.detect();
+                if (!afterStart.running) {
+                    this.log("Gateway failed to start, cannot connect");
+                    await showGatewayStartFailedToast(DEFAULT_GATEWAY_LOG_PATH);
+                    return;
+                }
+            }
+        }
+        // Ensure gateway.url is set
+        const gwConfig = vscode.workspace.getConfiguration("agentide.gateway");
+        let wsUrl = gwConfig.get("url", "").trim();
+        if (!wsUrl) {
+            wsUrl = `ws://127.0.0.1:${port}`;
+            await gwConfig.update("url", wsUrl, vscode.ConfigurationTarget.Global);
+        }
+        // For local gateways, apply gateway.auth.token from ~/.openclaw/openclaw.json.
+        // Prefer workspace scope when a workspace exists; otherwise use user scope in empty-window mode.
+        // Remote URLs: do not override — token must come from settings / env for that host.
+        const localGateway = /127\.0\.0\.1|localhost|\[::1\]/i.test(wsUrl);
+        const fileToken = this.readGatewayToken();
+        if (fileToken && localGateway) {
+            if (vscode.workspace.workspaceFolders && vscode.workspace.workspaceFolders.length > 0) {
+                await gwConfig.update("token", fileToken, vscode.ConfigurationTarget.Workspace);
+                this.log("Gateway token applied from openclaw.json (workspace scope)");
+            }
+            else {
+                await gwConfig.update("token", fileToken, vscode.ConfigurationTarget.Global);
+                this.log("Gateway token applied from openclaw.json (global scope; no workspace open)");
+            }
+        }
+        await this._bridgeRef.connect();
+        this.setBridgeConnected(this._bridgeRef.isConnected);
+        // Ensure the visual state matches the actual gateway port state.
+        // This prevents a race where the bridge connects but `_status` is still "installed".
+        const alive = await (0, index_1.probePort)(port);
+        if (alive) {
+            if (this._status !== "running") {
+                this.setStatus("running");
+            }
+        }
+        else {
+            if (this._status !== "installed") {
+                this.setStatus("installed");
+            }
+        }
+        this.updateStatusBar(this._status);
+        this.log("Bridge connected");
+    }
+    /**
+     * Disconnect the bridge from the gateway.
+     */
+    async disconnectBridge() {
+        if (!this._bridgeRef) {
+            return;
+        }
+        await this._bridgeRef.disconnect();
+        this.setBridgeConnected(false);
+        this.updateStatusBar(this._status);
+        this.log("Bridge disconnected");
+    }
+    // ============================================================================
+    // Web UI
+    // ============================================================================
+    /**
+     * Open the OpenClaw Gateway web UI in the default browser.
+     * The web UI is served by the gateway on the same port (default: 18789).
+     * Use it to configure channels, monitor sessions, and manage agents.
+     */
+    async openWebUI() {
+        const port = this.getGatewayPort();
+        // Quick port probe (~10ms) instead of full detect (~1-3s)
+        const running = this._status === "running" || await (0, index_1.probePort)(port);
+        if (!running) {
+            const choice = await vscode.window.showWarningMessage(`${exports.AGENT_ANYWHERE_LABEL}: Gateway is not running. Start it first to use the web UI.`, "Start Now");
+            if (choice === "Start Now") {
+                await this.start();
+            }
+            return;
+        }
+        // Pass token in the URL fragment so the Control UI can import it (applySettingsFromUrl).
+        // Query ?token= is intentionally stripped by OpenClaw without applying (referrer/logs).
+        const tokenFromSettings = (vscode.workspace.getConfiguration("agentide.gateway").get("token") ?? "").trim();
+        const token = this.readGatewayToken() ?? (tokenFromSettings || undefined);
+        const hash = token ? `#token=${encodeURIComponent(token)}` : "";
+        const url = `http://127.0.0.1:${port}/${hash}`;
+        await vscode.env.openExternal(vscode.Uri.parse(url));
+    }
+    // ============================================================================
+    // Health Checks
+    // ============================================================================
+    startHealthChecks(port) {
+        this.stopHealthChecks();
+        this.healthCheckTimer = setInterval(async () => {
+            const alive = await (0, index_1.probePort)(port);
+            if (!alive) {
+                this.log("Health check failed -- gateway is no longer running");
+                this.stopHealthChecks();
+                this.process = null;
+                this.setStatus("installed");
+            }
+        }, HEALTH_CHECK_INTERVAL_MS);
+    }
+    stopHealthChecks() {
+        if (this.healthCheckTimer) {
+            clearInterval(this.healthCheckTimer);
+            this.healthCheckTimer = null;
+        }
+    }
+    // ============================================================================
+    // Helpers
+    // ============================================================================
+    /**
+     * Build the web Control UI if it's missing.
+     * Resolves the gateway package root from the binary path and runs `pnpm ui:build`.
+     * Best-effort: logs failures but doesn't block the install flow.
+     */
+    async ensureWebUIBuilt(binaryPath) {
+        if (!binaryPath) {
+            return;
+        }
+        try {
+            const pkgRoot = resolvePackageRootFromBinary(binaryPath);
+            if (!pkgRoot) {
+                return;
+            }
+            const uiIndex = path.join(pkgRoot, "dist", "control-ui", "index.html");
+            if (fs.existsSync(uiIndex)) {
+                return; // Already built
+            }
+            this.log("Web UI not built - building now...");
+            // On Windows, npm/pnpm install as .cmd wrappers that need a shell to execute.
+            const uiBuildCmd = IS_WINDOWS ? "pnpm.cmd ui:build" : "pnpm ui:build";
+            await execAsync(uiBuildCmd, {
+                cwd: pkgRoot,
+                timeout: 60_000,
+                env: { ...process.env },
+                ...(IS_WINDOWS ? { shell: "cmd.exe" } : {}),
+            });
+            this.log("Web UI built successfully");
+        }
+        catch (err) {
+            this.log(`Web UI build failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    async promptNonManagedPortTakeover(port, intent) {
+        const action = intent === "connect" ? "connect Agent Anywhere" : "start Agent Anywhere";
+        const choice = await vscode.window.showWarningMessage(`${exports.AGENT_ANYWHERE_LABEL}: Port ${port} is in use by a non-managed process. Stop that process and ${action}?`, { modal: true }, "Yes", "No");
+        if (choice !== "Yes") {
+            this.log(`User declined non-managed port takeover on ${port}`);
+            return false;
+        }
+        this.log(`User approved non-managed port takeover on ${port}`);
+        const priorPids = new Set(await getListeningProcessIdsForPort(port));
+        const stopped = await stopExternalGatewayListener(port, undefined, (m) => this.log(m));
+        if (!stopped) {
+            // A supervised daemon (launchd/systemd/scheduled task) restarts itself when killed, so a
+            // fresh PID re-takes the port. Detect that and tell the user the truth — killing the
+            // process can't win against the supervisor's auto-restart; the service must be uninstalled.
+            const currentPids = await getListeningProcessIdsForPort(port);
+            const supervisedRespawn = priorPids.size > 0 && currentPids.some((pid) => !priorPids.has(pid));
+            if (supervisedRespawn) {
+                vscode.window.showWarningMessage(`${exports.AGENT_ANYWHERE_LABEL}: Port ${port} is held by a self-restarting gateway service. Run \`openclaw daemon uninstall\` to remove it, then try again.`);
+            }
+            else {
+                vscode.window.showErrorMessage(`${exports.AGENT_ANYWHERE_LABEL}: Could not free port ${port}. Stop that process manually and try again.`);
+            }
+            return false;
+        }
+        return true;
+    }
+    async ensureManagedGatewayWrapperState(binaryPath, createOpenclawAlias = false) {
+        try {
+            const record = readManagedGatewayInstallRecord();
+            const runtimeSpec = await resolveManagedGatewayRuntimeSpec(binaryPath, record);
+            if (!runtimeSpec) {
+                return undefined;
+            }
+            const { launcherPath, packageRoot, nodePath, entryScriptPath } = runtimeSpec;
+            const wrapperPath = writeManagedGatewayWrapper(nodePath, entryScriptPath, MANAGED_GATEWAY_WRAPPER_PATH);
+            let openclawWrapperPath;
+            if (createOpenclawAlias ||
+                isAgentAnywhereManagedWrapper(MANAGED_OPENCLAW_WRAPPER_PATH)) {
+                openclawWrapperPath = writeManagedGatewayWrapper(nodePath, entryScriptPath, MANAGED_OPENCLAW_WRAPPER_PATH);
+            }
+            writeManagedGatewayInstallRecord({
+                ...record,
+                nodePath,
+                cliPath: launcherPath,
+                entryScriptPath,
+                packageRoot,
+                wrapperPath,
+                wrapperDir: MANAGED_GATEWAY_WRAPPER_DIR,
+                openclawWrapperPath,
+                updatedAt: new Date().toISOString(),
+            });
+            return wrapperPath;
+        }
+        catch (err) {
+            this.log(`Managed gateway wrapper setup failed: ${err instanceof Error ? err.message : String(err)}`);
+            return undefined;
+        }
+    }
+    async resolveWindowsManagedGatewayLaunchRuntime(binaryPath) {
+        if (!IS_WINDOWS) {
+            return undefined;
+        }
+        // Best effort: backfill manifest + wrapper state from an existing managed package install.
+        await this.ensureManagedGatewayWrapperState(binaryPath);
+        const runtimeSpec = await resolveManagedGatewayRuntimeSpec(binaryPath);
+        if (!runtimeSpec) {
+            return undefined;
+        }
+        return {
+            nodePath: runtimeSpec.nodePath,
+            entryScriptPath: runtimeSpec.entryScriptPath,
+        };
+    }
+    /**
+     * Read the gateway auth token from ~/.openclaw/openclaw.json.
+     * Parses JSON5 loosely (strip comments, then JSON.parse) to avoid a dep.
+     */
+    readGatewayToken() {
+        try {
+            if (!fs.existsSync(this.configPath)) {
+                return undefined;
+            }
+            const raw = fs.readFileSync(this.configPath, "utf-8");
+            // Strip single-line comments (// ...) for basic JSON5 compat
+            const stripped = raw.replace(/^\s*\/\/.*$/gm, "").replace(/,\s*([}\]])/g, "$1");
+            const parsed = JSON.parse(stripped);
+            const token = parsed?.gateway?.auth?.token;
+            return typeof token === "string" && token.trim() ? token.trim() : undefined;
+        }
+        catch (err) {
+            this.log(`Could not read gateway token: ${err}`);
+            return undefined;
+        }
+    }
+    setStatus(status) {
+        this._status = status;
+        this.updateStatusBar(status);
+        this._onStatusChange.fire(status);
+    }
+    updateStatusBar(status) {
+        const hidden = this.getConfig("hidden", false);
+        if (hidden) {
+            this.statusBarItem.hide();
+            return;
+        }
+        switch (status) {
+            case "not-installed":
+                this.statusBarItem.text = `$(cloud-download) ${exports.AGENT_ANYWHERE_LABEL}`;
+                this.statusBarItem.tooltip = `${exports.AGENT_ANYWHERE_LABEL}: Reach your agents from WhatsApp, Telegram, Slack (click to set up)`;
+                this.statusBarItem.color = undefined;
+                this.statusBarItem.backgroundColor = undefined;
+                break;
+            case "installed":
+                this.statusBarItem.text = `$(debug-disconnect) ${exports.AGENT_ANYWHERE_LABEL}`;
+                this.statusBarItem.tooltip = `${exports.AGENT_ANYWHERE_LABEL}: Installed, not running (click to start)`;
+                this.statusBarItem.color = undefined;
+                this.statusBarItem.backgroundColor = undefined;
+                break;
+            case "starting":
+                this.statusBarItem.text = `$(sync~spin) ${exports.AGENT_ANYWHERE_LABEL}`;
+                this.statusBarItem.tooltip = this._gatewayInstallInProgress
+                    ? `${exports.AGENT_ANYWHERE_LABEL}: ${this._installProgressMessage ?? "Installing... (see Setup terminal)"}`
+                    : `${exports.AGENT_ANYWHERE_LABEL}: Starting...`;
+                this.statusBarItem.color = undefined;
+                this.statusBarItem.backgroundColor = undefined;
+                break;
+            case "running":
+                if (this._bridgeConnected) {
+                    this.statusBarItem.text = `$(broadcast) ${exports.AGENT_ANYWHERE_LABEL}`;
+                    this.statusBarItem.tooltip = `${exports.AGENT_ANYWHERE_LABEL}: Connected (click for options)`;
+                    this.statusBarItem.color = new vscode.ThemeColor("testing.iconPassed");
+                }
+                else {
+                    this.statusBarItem.text = `$(debug-disconnect) ${exports.AGENT_ANYWHERE_LABEL}`;
+                    this.statusBarItem.tooltip = `${exports.AGENT_ANYWHERE_LABEL}: Disconnected (click to connect)`;
+                    this.statusBarItem.color = undefined;
+                }
+                this.statusBarItem.backgroundColor = undefined;
+                break;
+            case "stopping":
+                this.statusBarItem.text = `$(sync~spin) ${exports.AGENT_ANYWHERE_LABEL}`;
+                this.statusBarItem.tooltip = this._gatewayUninstallInProgress
+                    ? `${exports.AGENT_ANYWHERE_LABEL}: Uninstalling... (see Uninstall terminal)`
+                    : `${exports.AGENT_ANYWHERE_LABEL}: Stopping...`;
+                this.statusBarItem.color = undefined;
+                this.statusBarItem.backgroundColor = undefined;
+                break;
+            case "error":
+                this.statusBarItem.text = `$(warning) ${exports.AGENT_ANYWHERE_LABEL}`;
+                this.statusBarItem.tooltip = `${exports.AGENT_ANYWHERE_LABEL}: Error (click for details)`;
+                this.statusBarItem.color = new vscode.ThemeColor("errorForeground");
+                this.statusBarItem.backgroundColor = undefined;
+                break;
+        }
+        this.statusBarItem.show();
+    }
+    getConfig(key, defaultValue) {
+        return vscode.workspace
+            .getConfiguration("agentide.anywhere")
+            .get(key, defaultValue);
+    }
+    /**
+     * True when the global npm tree still has `openclaw` installed.
+     * This is used by uninstall flow to distinguish managed npm installs
+     * from unrelated/external binaries still present on PATH.
+     */
+    async hasGlobalNpmOpenclawTree() {
+        const managedRoots = await getManagedOpenclawRoots();
+        return managedRoots.length > 0;
+    }
+    readGatewayPortFromOpenclawJson() {
+        try {
+            if (!fs.existsSync(this.configPath)) {
+                return undefined;
+            }
+            const raw = fs.readFileSync(this.configPath, "utf-8");
+            const stripped = raw.replace(/^\s*\/\/.*$/gm, "").replace(/,\s*([}\]])/g, "$1");
+            const parsed = JSON.parse(stripped);
+            const p = parsed?.gateway?.port;
+            if (typeof p === "number" && Number.isFinite(p)) {
+                const n = Math.floor(p);
+                if (n >= 1 && n <= 65535) {
+                    return n;
+                }
+            }
+            if (typeof p === "string" && /^\d+$/.test(p)) {
+                const n = parseInt(p, 10);
+                if (n >= 1 && n <= 65535) {
+                    return n;
+                }
+            }
+            return undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /**
+     * Port used for local gateway probe/start/stop/Web UI. When openclaw.json sets gateway.port,
+     * that wins so the IDE matches the running OpenClaw process (settings default alone can miss).
+     */
+    getGatewayPort() {
+        const fromFile = this.readGatewayPortFromOpenclawJson();
+        if (fromFile !== undefined) {
+            return fromFile;
+        }
+        return this.getConfig("port", DEFAULT_PORT);
+    }
+    log(message) {
+        this.outputChannel.appendLine(`[${exports.AGENT_ANYWHERE_LABEL}] ${message}`);
+    }
+    dispose() {
+        this.stopHealthChecks();
+        // Don't kill the gateway on IDE close -- it's detached and persists.
+        // Users stop it explicitly via the Stop command.
+        this.process = null;
+        this.statusBarItem.dispose();
+        this._onStatusChange.dispose();
+        for (const d of this.disposables) {
+            d.dispose();
+        }
+    }
+}
+exports.GatewayLifecycleManager = GatewayLifecycleManager;