@agenthippo-ai/agenthippo 0.1.0

package/out/test/gateway-lifecycle.test.js

@@ -0,0 +1,608 @@
+"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 });
+require("mocha");
+const assert = __importStar(require("assert"));
+const crypto_1 = require("crypto");
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const Module = require("module");
+const originalRequire = Module.prototype.require;
+function createDeferred() {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+    });
+    return { promise, resolve, reject };
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+const infoMessages = [];
+const warningMessages = [];
+const errorMessages = [];
+const configUpdates = [];
+const outputLines = [];
+const terminals = [];
+const terminalCloseListeners = [];
+const statusBarItems = [];
+const configValues = new Map();
+let informationHandler;
+let warningHandler;
+let progressHandler;
+function resetHarnessState() {
+    infoMessages.length = 0;
+    warningMessages.length = 0;
+    errorMessages.length = 0;
+    configUpdates.length = 0;
+    outputLines.length = 0;
+    terminals.length = 0;
+    terminalCloseListeners.length = 0;
+    statusBarItems.length = 0;
+    configValues.clear();
+    configValues.set("hidden", false);
+    configValues.set("enabled", false);
+    configValues.set("installSource", "github:agenthippoai/hippoclaw");
+    configValues.set("port", 18789);
+    configValues.set("autoStart", false);
+    informationHandler = undefined;
+    warningHandler = undefined;
+    progressHandler = undefined;
+}
+const disposable = { dispose() { } };
+class FakeEventEmitter {
+    listeners = [];
+    event = (listener) => {
+        this.listeners.push(listener);
+        return disposable;
+    };
+    fire(value) {
+        for (const listener of this.listeners) {
+            listener(value);
+        }
+    }
+    dispose() {
+        this.listeners = [];
+    }
+}
+class FakeThemeColor {
+    id;
+    constructor(id) {
+        this.id = id;
+    }
+}
+const fakeVscode = {
+    window: {
+        terminals,
+        createStatusBarItem: () => {
+            const item = {
+                text: "",
+                tooltip: "",
+                color: undefined,
+                backgroundColor: undefined,
+                command: undefined,
+                name: "",
+                show() { },
+                hide() { },
+                dispose() { },
+            };
+            statusBarItems.push(item);
+            return item;
+        },
+        createTerminal: (options) => {
+            const terminal = {
+                name: options.name,
+                show() { },
+                dispose() {
+                    const index = terminals.indexOf(terminal);
+                    if (index >= 0) {
+                        terminals.splice(index, 1);
+                    }
+                    for (const listener of terminalCloseListeners) {
+                        listener(terminal);
+                    }
+                },
+            };
+            terminals.push(terminal);
+            return terminal;
+        },
+        onDidCloseTerminal: (listener) => {
+            terminalCloseListeners.push(listener);
+            return disposable;
+        },
+        showInformationMessage: (message, ...items) => {
+            infoMessages.push(message);
+            return Promise.resolve(informationHandler ? informationHandler(message, items) : undefined);
+        },
+        showWarningMessage: (message, ...items) => {
+            warningMessages.push(message);
+            return Promise.resolve(warningHandler ? warningHandler(message, items) : undefined);
+        },
+        showErrorMessage: (message) => {
+            errorMessages.push(message);
+            return Promise.resolve(undefined);
+        },
+        withProgress: (options, task) => {
+            if (progressHandler) {
+                return progressHandler(options, task);
+            }
+            return task({ report: () => undefined });
+        },
+    },
+    workspace: {
+        getConfiguration: () => ({
+            get: (key, defaultValue) => (configValues.has(key) ? configValues.get(key) : defaultValue),
+            update: async (key, value, target) => {
+                configValues.set(key, value);
+                configUpdates.push({ key, value, target });
+            },
+            inspect: () => undefined,
+        }),
+        onDidChangeConfiguration: () => disposable,
+    },
+    commands: {
+        executeCommand: async () => undefined,
+        registerCommand: () => disposable,
+    },
+    EventEmitter: FakeEventEmitter,
+    ThemeColor: FakeThemeColor,
+    StatusBarAlignment: { Right: 2 },
+    ProgressLocation: { Window: 10, Notification: 15 },
+    ConfigurationTarget: { Global: 1 },
+};
+let GatewayLifecycleManager;
+let AGENT_ANYWHERE_LABEL;
+function createManager() {
+    const outputChannel = {
+        appendLine: (message) => outputLines.push(message),
+        show: () => undefined,
+    };
+    return new GatewayLifecycleManager(outputChannel, {});
+}
+suite("Gateway Lifecycle Manager", () => {
+    suiteSetup(() => {
+        Module.prototype.require = function (request) {
+            if (request === "vscode") {
+                return fakeVscode;
+            }
+            return originalRequire.apply(this, arguments);
+        };
+        const lifecycleModule = require("../gateway/lifecycle");
+        GatewayLifecycleManager = lifecycleModule.GatewayLifecycleManager;
+        AGENT_ANYWHERE_LABEL = lifecycleModule.AGENT_ANYWHERE_LABEL;
+        Module.prototype.require = originalRequire;
+    });
+    setup(() => {
+        resetHarnessState();
+    });
+    test("install success clears in-progress state before completion prompt resolves", async () => {
+        const completionPrompt = createDeferred();
+        informationHandler = (message) => {
+            if (message.startsWith(`${AGENT_ANYWHERE_LABEL}: Installed.`)) {
+                return completionPrompt.promise;
+            }
+            return undefined;
+        };
+        const manager = createManager();
+        let detectCall = 0;
+        manager.detectGatewayState = async () => {
+            detectCall += 1;
+            if (detectCall === 1) {
+                return { installed: false, running: false, port: 18789 };
+            }
+            return {
+                installed: true,
+                running: false,
+                port: 18789,
+                binaryPath: "C:\\fake\\hippoclaw.cmd",
+            };
+        };
+        manager.readInstallStatusSnapshot = () => ({
+            phase: "complete",
+            message: "Installing Gateway CLI...",
+            steps: { finalCheckPassed: true },
+        });
+        manager.getInstallProgressSummary = () => ({
+            message: "Installing Gateway CLI...",
+            percent: 95,
+        });
+        manager.ensureManagedGatewayWrapperState = async () => undefined;
+        manager.ensureWebUIBuilt = async () => undefined;
+        manager.writeStarterConfig = () => undefined;
+        const installResult = await Promise.race([
+            manager.install().then(() => "resolved"),
+            delay(100).then(() => "timedout"),
+        ]);
+        assert.strictEqual(installResult, "resolved");
+        assert.strictEqual(manager._gatewayInstallInProgress, false);
+        assert.strictEqual(manager._installProgressMessage, undefined);
+        assert.strictEqual(manager.status, "installed");
+        assert.ok(outputLines.some((line) => line.includes("Install flag -> true")));
+        assert.ok(outputLines.some((line) => line.includes("Install flag -> false (success)")));
+        assert.ok(configUpdates.some((entry) => entry.key === "enabled" && entry.value === true));
+        const messagesBeforeToggle = infoMessages.length;
+        let detectRuns = 0;
+        manager.detect = async () => {
+            detectRuns += 1;
+            return { installed: true, running: false, port: 18789 };
+        };
+        await manager.toggle();
+        const newMessages = infoMessages.slice(messagesBeforeToggle);
+        assert.ok(newMessages.some((message) => message === `${AGENT_ANYWHERE_LABEL}: Disconnected.`));
+        assert.ok(!newMessages.some((message) => message.includes("Install in progress")));
+        await delay(150);
+        assert.strictEqual(detectRuns, 1);
+        detectRuns = 0;
+        manager.queueBackgroundDetect("test after success");
+        await delay(150);
+        assert.strictEqual(detectRuns, 1);
+        completionPrompt.resolve(undefined);
+        await completionPrompt.promise;
+    });
+    test("start restores not-installed when user dismisses Install Now", async () => {
+        const manager = createManager();
+        warningHandler = () => undefined;
+        manager.detectGatewayFastState = async () => null;
+        manager.detect = async () => ({
+            installed: false,
+            running: false,
+            port: 18789,
+        });
+        manager.probeGatewayPort = async () => false;
+        await manager.start();
+        assert.strictEqual(manager.status, "not-installed");
+        assert.ok(warningMessages.some((m) => m.includes("not installed")));
+    });
+    test("start sets error when gateway binary path is missing", async () => {
+        const manager = createManager();
+        manager.detectGatewayFastState = async () => null;
+        manager.detect = async () => ({
+            installed: true,
+            running: false,
+            port: 18789,
+            binaryPath: undefined,
+        });
+        manager.probeGatewayPort = async () => false;
+        await manager.start();
+        assert.strictEqual(manager.status, "error");
+        assert.ok(errorMessages.some((m) => m.includes("binary not found")));
+    });
+    test("removeStaleGatewayLockBeforeStart removes only locks older than min age on Windows", async function () {
+        if (process.platform !== "win32") {
+            this.skip();
+        }
+        const manager = createManager();
+        const configPath = path.join(os.homedir(), ".openclaw", "openclaw.json");
+        const configHash = (0, crypto_1.createHash)("sha256").update(configPath).digest("hex").slice(0, 8);
+        const lockDir = path.join(os.tmpdir(), "openclaw");
+        const lockPath = path.join(lockDir, `gateway.${configHash}.lock`);
+        fs.mkdirSync(lockDir, { recursive: true });
+        try {
+            fs.writeFileSync(lockPath, "test-lock", { encoding: "utf8" });
+            const old = new Date(Date.now() - 60_000);
+            fs.utimesSync(lockPath, old, old);
+            manager.probeGatewayPort = async () => false;
+            await manager.removeStaleGatewayLockBeforeStart(18789);
+            assert.strictEqual(fs.existsSync(lockPath), false);
+            assert.ok(outputLines.some((line) => line.includes("Removed stale gateway lock")));
+        }
+        finally {
+            try {
+                fs.rmSync(lockPath, { force: true });
+            }
+            catch {
+                // ignore
+            }
+        }
+    });
+    test("removeStaleGatewayLockBeforeStart skips recent lock files on Windows", async function () {
+        if (process.platform !== "win32") {
+            this.skip();
+        }
+        const manager = createManager();
+        const configPath = path.join(os.homedir(), ".openclaw", "openclaw.json");
+        const configHash = (0, crypto_1.createHash)("sha256").update(configPath).digest("hex").slice(0, 8);
+        const lockDir = path.join(os.tmpdir(), "openclaw");
+        const lockPath = path.join(lockDir, `gateway.${configHash}.lock`);
+        fs.mkdirSync(lockDir, { recursive: true });
+        try {
+            fs.writeFileSync(lockPath, "fresh-lock", { encoding: "utf8" });
+            manager.probeGatewayPort = async () => false;
+            await manager.removeStaleGatewayLockBeforeStart(18789);
+            assert.strictEqual(fs.existsSync(lockPath), true);
+            assert.ok(outputLines.some((line) => line.includes("possible concurrent start")));
+        }
+        finally {
+            fs.rmSync(lockPath, { force: true });
+        }
+    });
+    test("start sets spinner immediately before slow startup checks finish", async () => {
+        const manager = createManager();
+        const fastDetect = createDeferred();
+        manager.detectGatewayFastState = () => fastDetect.promise;
+        const startPromise = manager.start();
+        await delay(0);
+        assert.strictEqual(manager.status, "starting");
+        fastDetect.resolve({
+            installed: true,
+            running: true,
+            port: 18789,
+            binaryPath: "C:\\fake\\hippoclaw.cmd",
+        });
+        await startPromise;
+        assert.strictEqual(manager.status, "running");
+    });
+    test("start waits for port readiness after Windows launch succeeds", async () => {
+        const manager = createManager();
+        let probeCalls = 0;
+        manager.isWindowsLaunch = () => true;
+        manager.detectGatewayFastState = async () => null;
+        manager.detect = async () => ({
+            installed: true,
+            running: false,
+            port: 18789,
+            binaryPath: "C:\\fake\\hippoclaw.cmd",
+        });
+        manager.probeGatewayPort = async () => {
+            probeCalls += 1;
+            return probeCalls >= 6;
+        };
+        manager.stopExistingGatewayBeforeStart = async () => undefined;
+        manager.removeStaleGatewayLockBeforeStart = async () => undefined;
+        manager.resolveWindowsManagedGatewayLaunchRuntime = async () => ({
+            nodePath: "C:\\Users\\trung\\AppData\\Roaming\\nodejs\\node.exe",
+            entryScriptPath: "C:\\Users\\trung\\AppData\\Roaming\\nodejs\\node_modules\\openclaw\\openclaw.mjs",
+        });
+        manager.startGatewayViaHiddenWindowsProcess = async () => 123;
+        manager.isStartedGatewayProcessAlive = () => true;
+        manager.writeGatewayPidRecord = async () => undefined;
+        manager.startHealthChecks = () => undefined;
+        manager.getStartupTimeoutMs = () => 0;
+        manager.getStartupCheckIntervalMs = () => 1;
+        manager.getStartupLaunchGraceMs = () => 1000;
+        manager.sleep = async () => undefined;
+        await manager.start();
+        assert.strictEqual(manager.status, "running");
+        assert.strictEqual(errorMessages.length, 0);
+        assert.ok(probeCalls >= 5);
+    });
+    test("Windows start keeps waiting when launch process exits before port is ready", async () => {
+        const manager = createManager();
+        let probeCalls = 0;
+        let aliveChecks = 0;
+        manager.isWindowsLaunch = () => true;
+        manager.detectGatewayFastState = async () => null;
+        manager.detect = async () => ({
+            installed: true,
+            running: false,
+            port: 18789,
+            binaryPath: "C:\\fake\\hippoclaw.cmd",
+        });
+        // Port becomes ready only after the launched process has been observed to die (aliveChecks>=2),
+        // so the readiness loop must traverse the "process exited, keep waiting" branch first. Tying to
+        // aliveChecks (not a raw probe counter) keeps this immune to pre-loop port probes.
+        manager.probeGatewayPort = async () => {
+            probeCalls += 1;
+            return aliveChecks >= 2;
+        };
+        manager.stopExistingGatewayBeforeStart = async () => undefined;
+        manager.removeStaleGatewayLockBeforeStart = async () => undefined;
+        manager.resolveWindowsManagedGatewayLaunchRuntime = async () => ({
+            nodePath: "C:\\Users\\trung\\AppData\\Roaming\\nodejs\\node.exe",
+            entryScriptPath: "C:\\Users\\trung\\AppData\\Roaming\\nodejs\\node_modules\\openclaw\\openclaw.mjs",
+        });
+        manager.startGatewayViaHiddenWindowsProcess = async () => 74932;
+        manager.isStartedGatewayProcessAlive = () => {
+            aliveChecks += 1;
+            return aliveChecks === 1;
+        };
+        manager.writeGatewayPidRecord = async () => undefined;
+        manager.startHealthChecks = () => undefined;
+        manager.getStartupTimeoutMs = () => 1000;
+        manager.getStartupCheckIntervalMs = () => 1;
+        manager.sleep = async () => undefined;
+        await manager.start();
+        assert.strictEqual(manager.status, "running");
+        assert.strictEqual(errorMessages.length, 0);
+        assert.ok(outputLines.some((line) => line.includes("continuing to wait for port readiness")));
+    });
+    test("Windows start clears stale gateway lock before launch", async () => {
+        const manager = createManager();
+        let cleanupCalled = false;
+        let launchStartedAfterCleanup = false;
+        let probeCalls = 0;
+        manager.isWindowsLaunch = () => true;
+        manager.detectGatewayFastState = async () => null;
+        manager.detect = async () => ({
+            installed: true,
+            running: false,
+            port: 18789,
+            binaryPath: "C:\\fake\\hippoclaw.cmd",
+        });
+        manager.probeGatewayPort = async () => {
+            probeCalls += 1;
+            return probeCalls >= 2;
+        };
+        manager.stopExistingGatewayBeforeStart = async () => undefined;
+        manager.removeStaleGatewayLockBeforeStart = async () => {
+            cleanupCalled = true;
+        };
+        manager.resolveWindowsManagedGatewayLaunchRuntime = async () => ({
+            nodePath: "C:\\Users\\trung\\AppData\\Roaming\\nodejs\\node.exe",
+            entryScriptPath: "C:\\Users\\trung\\AppData\\Roaming\\nodejs\\node_modules\\openclaw\\openclaw.mjs",
+        });
+        manager.startGatewayViaHiddenWindowsProcess = async () => {
+            launchStartedAfterCleanup = cleanupCalled;
+            return 74932;
+        };
+        manager.writeGatewayPidRecord = async () => undefined;
+        manager.startHealthChecks = () => undefined;
+        await manager.start();
+        assert.strictEqual(cleanupCalled, true);
+        assert.strictEqual(launchStartedAfterCleanup, true);
+        assert.strictEqual(manager.status, "running");
+    });
+    test("start progress uses window progress instead of notification", async () => {
+        const manager = createManager();
+        let progressOptions;
+        let probeCalls = 0;
+        progressHandler = async (options, task) => {
+            progressOptions = options;
+            return task({ report: () => undefined });
+        };
+        manager.isWindowsLaunch = () => true;
+        manager.detectGatewayFastState = async () => null;
+        manager.detect = async () => ({
+            installed: true,
+            running: false,
+            port: 18789,
+            binaryPath: "C:\\fake\\hippoclaw.cmd",
+        });
+        manager.probeGatewayPort = async () => {
+            probeCalls += 1;
+            return probeCalls >= 2;
+        };
+        manager.stopExistingGatewayBeforeStart = async () => undefined;
+        manager.removeStaleGatewayLockBeforeStart = async () => undefined;
+        manager.resolveWindowsManagedGatewayLaunchRuntime = async () => ({
+            nodePath: "C:\\Users\\trung\\AppData\\Roaming\\nodejs\\node.exe",
+            entryScriptPath: "C:\\Users\\trung\\AppData\\Roaming\\nodejs\\node_modules\\openclaw\\openclaw.mjs",
+        });
+        manager.startGatewayViaHiddenWindowsProcess = async () => 74932;
+        manager.writeGatewayPidRecord = async () => undefined;
+        manager.startHealthChecks = () => undefined;
+        await manager.start();
+        assert.strictEqual(progressOptions?.["location"], fakeVscode.ProgressLocation.Window);
+        assert.strictEqual(progressOptions?.["title"], `${AGENT_ANYWHERE_LABEL}: Starting gateway...`);
+        assert.strictEqual("cancellable" in (progressOptions ?? {}), false);
+        assert.strictEqual(manager.status, "running");
+    });
+    test("install wait loop exits promptly when setup terminal reconciliation clears progress flag", async () => {
+        const manager = createManager();
+        let detectCalls = 0;
+        manager.detectGatewayState = async () => {
+            detectCalls += 1;
+            if (detectCalls === 2) {
+                manager.setInstallProgressFlag(false, "terminal reconciliation");
+            }
+            return { installed: false, running: false, port: 18789 };
+        };
+        const started = Date.now();
+        const installSucceeded = await Promise.race([
+            manager.install(),
+            delay(8_000).then(() => "hung"),
+        ]);
+        const elapsed = Date.now() - started;
+        assert.strictEqual(installSucceeded, false);
+        assert.notStrictEqual(installSucceeded, "hung");
+        assert.ok(elapsed < 8_000, `expected prompt abort, took ${elapsed}ms`);
+        assert.ok(outputLines.some((line) => line.includes("Gateway install wait aborted — setup terminal closed")));
+    });
+    test("reconcileInstallProgressState is recovery-only and logs terminal reconciliation", async () => {
+        const manager = createManager();
+        manager.setInstallProgressFlag(true, "test setup");
+        manager._installSetupTerminal = null;
+        manager.detectGatewayState = async () => ({
+            installed: true,
+            running: false,
+            port: 18789,
+        });
+        const result = await manager.reconcileInstallProgressState();
+        assert.strictEqual(result?.installed, true);
+        assert.strictEqual(manager._gatewayInstallInProgress, false);
+        assert.strictEqual(manager.status, "installed");
+        assert.ok(outputLines.some((line) => line.includes("Install flag -> false (terminal reconciliation)")));
+    });
+    test("install failure clears in-progress state and logs failure", async () => {
+        const manager = createManager();
+        manager.detectGatewayState = async () => ({
+            installed: false,
+            running: false,
+            port: 18789,
+        });
+        manager.readInstallStatusSnapshot = () => ({
+            phase: "failed",
+            message: "Install failed.",
+            lastError: "boom",
+        });
+        manager.getInstallProgressSummary = () => ({
+            message: "Install failed.",
+            percent: 100,
+        });
+        const installSucceeded = await manager.install();
+        assert.strictEqual(installSucceeded, false);
+        assert.strictEqual(manager._gatewayInstallInProgress, false);
+        assert.strictEqual(manager._installProgressMessage, undefined);
+        assert.strictEqual(manager.status, "error");
+        assert.ok(outputLines.some((line) => line.includes("Install flag -> false (failure)")));
+    });
+    test("uninstall completes when managed package is gone even if external openclaw remains on PATH", async () => {
+        const manager = createManager();
+        manager.stop = async () => undefined;
+        manager.detectGatewayState = async () => ({
+            installed: true,
+            running: false,
+            port: 18789,
+            binaryPath: "C:\\external\\openclaw.cmd",
+        });
+        manager.hasGlobalNpmOpenclawTree = async () => false;
+        manager.getUninstallInitialDelayMs = () => 0;
+        manager.sleep = async () => undefined;
+        await manager.uninstall();
+        assert.strictEqual(manager.status, "not-installed");
+        assert.strictEqual(manager._gatewayUninstallInProgress, false);
+        assert.strictEqual(warningMessages.length, 0);
+        assert.ok(outputLines.some((line) => line.includes("another OpenClaw binary remains on PATH")));
+        assert.strictEqual(terminals.length, 1);
+    });
+    test("lifecycle.ts stale lock removal uses minimum age gate", () => {
+        const lifecycleTs = path.join(__dirname, "..", "..", "src", "gateway", "lifecycle.ts");
+        const src = fs.readFileSync(lifecycleTs, "utf8");
+        assert.match(src, /STALE_GATEWAY_LOCK_MIN_AGE_MS/);
+        assert.match(src, /lockAgeMs < STALE_GATEWAY_LOCK_MIN_AGE_MS/);
+    });
+    test("lifecycle.ts Unix spawn exit defers setStatus while start is in flight", () => {
+        const lifecycleTs = path.join(__dirname, "..", "..", "src", "gateway", "lifecycle.ts");
+        const src = fs.readFileSync(lifecycleTs, "utf8");
+        assert.match(src, /process\.on\("exit"/);
+        assert.match(src, /if \(this\._startInFlight\)/);
+    });
+});