fraim-hub 2.0.289 → 2.0.291

package/dist/src/ai-hub/cli.js

@@ -46,15 +46,10 @@ const git_utils_1 = require("../core/utils/git-utils");
 const path_1 = __importDefault(require("path"));
 const child_process_1 = require("child_process");
 const fs_1 = __importDefault(require("fs"));
-const net_1 = __importDefault(require("net"));
-const http_1 = __importDefault(require("http"));
-const tree_kill_1 = __importDefault(require("tree-kill"));
-const hub_launch_decision_1 = require("./hub-launch-decision");
 const hub_runtime_file_1 = require("./hub-runtime-file");
 const project_fraim_paths_1 = require("../core/utils/project-fraim-paths");
-const version_utils_1 = require("../cli/utils/version-utils");
 const electron_dist_1 = require("./electron-dist");
-const process_liveness_1 = require("./process-liveness");
+const hub_instance_reconciliation_1 = require("./hub-instance-reconciliation");
 function resolveDesktopEntry() {
     const candidates = [
         path_1.default.resolve(__dirname, 'desktop-main.js'),
@@ -113,96 +108,6 @@ function openBrowser(url) {
     const child = (0, child_process_1.spawn)('xdg-open', [url], { detached: true, stdio: 'ignore' });
     child.unref();
 }
-function killPid(pid) {
-    try {
-        if (process.platform === 'win32') {
-            // /T kills the entire process tree; /F forces termination without prompting.
-            (0, child_process_1.execFileSync)('taskkill', ['/PID', String(pid), '/T', '/F'], { stdio: 'ignore' });
-        }
-        else {
-            // tree-kill sends SIGTERM to the process group so child Electron helper processes
-            // are also terminated, not just the root node process (#921).
-            (0, tree_kill_1.default)(pid, 'SIGTERM');
-        }
-    }
-    catch {
-        /* already gone */
-    }
-}
-// #921: after killing the registered pid, probe ports 43091-43200 for any Hub HTTP
-// response. Any Hub found on those ports that is NOT the already-killed pid is an
-// orphan (e.g. an older version started via bare `npx` that never wrote hub-runtime.json).
-// GET /api/ai-hub/pid identifies the pid; we then kill it and wait for its port to free.
-async function fetchHubPid(port) {
-    return new Promise((resolve) => {
-        const req = http_1.default.get({ host: '127.0.0.1', port, path: '/api/ai-hub/pid', timeout: 1000 }, (res) => {
-            if (res.statusCode !== 200) {
-                res.resume();
-                return resolve(null);
-            }
-            let body = '';
-            res.on('data', (c) => { body += c; });
-            res.on('end', () => { try {
-                resolve(JSON.parse(body).pid ?? null);
-            }
-            catch {
-                resolve(null);
-            } });
-        });
-        req.on('error', () => resolve(null));
-        req.on('timeout', () => { req.destroy(); resolve(null); });
-    });
-}
-async function scanAndKillOrphanHubs(excludePid) {
-    const HUB_PORT_SCAN_START = 43091;
-    const HUB_PORT_SCAN_END = 43200;
-    for (let port = HUB_PORT_SCAN_START; port <= HUB_PORT_SCAN_END; port++) {
-        const version = await fetchRunningHubVersion(port);
-        if (!version)
-            continue; // port not a Hub
-        const pid = await fetchHubPid(port);
-        if (pid === null || pid === excludePid)
-            continue; // same process we already killed
-        console.log(`Killing orphan Hub (pid ${pid}) on port ${port}`);
-        killPid(pid);
-        await waitForPortFree(port);
-    }
-}
-function isPortFree(port, timeoutMs = 500) {
-    return new Promise((resolve) => {
-        const sock = net_1.default.connect({ host: '127.0.0.1', port }, () => { sock.destroy(); resolve(false); });
-        sock.on('error', () => resolve(true));
-        sock.setTimeout(timeoutMs, () => { sock.destroy(); resolve(true); });
-    });
-}
-async function waitForPortFree(port, totalMs = 5000) {
-    const start = Date.now();
-    while (Date.now() - start < totalMs) {
-        if (await isPortFree(port))
-            return;
-        await new Promise((r) => setTimeout(r, 200));
-    }
-}
-function fetchRunningHubVersion(port) {
-    return new Promise((resolve) => {
-        const req = http_1.default.get({ host: '127.0.0.1', port, path: '/api/ai-hub/version', timeout: 1000 }, (res) => {
-            if (res.statusCode !== 200) {
-                res.resume();
-                return resolve(null);
-            }
-            let body = '';
-            res.on('data', (c) => { body += c; });
-            res.on('end', () => { try {
-                resolve(JSON.parse(body).version ?? null);
-            }
-            catch {
-                resolve(null);
-            } });
-        });
-        req.on('error', () => resolve(null));
-        req.on('timeout', () => { req.destroy(); resolve(null); });
-    });
-}
 // #1110: the desktop shell's cold-start cost is work this launcher can neither see nor bound.
 // Before the Hub can answer /api/ai-hub/version it pays for Electron process boot, top-level
 // evaluation of the src/ai-hub/server.ts module graph, cert load plus a blocking certutil
@@ -278,7 +183,7 @@ async function waitForDesktopHubReady(child, preferredPort, options = {}) {
     while (Date.now() - start < timeoutMs) {
         failIfChildDied();
         for (const port of readinessProbePorts(fraimDir, runtimeId, preferredPort)) {
-            const version = await fetchRunningHubVersion(port);
+            const version = await (0, hub_instance_reconciliation_1.fetchRunningHubVersion)(port);
             if (version) {
                 return { port, version };
             }
@@ -298,32 +203,6 @@ async function waitForDesktopHubReady(child, preferredPort, options = {}) {
         + `${stillRunning}`
         + ` Set ${exports.DESKTOP_HUB_READY_TIMEOUT_ENV} to a larger value if this machine needs longer.`);
 }
-async function reconcileRunningHub(flags, runtimeId = 'hub') {
-    const running = (0, hub_runtime_file_1.readHubRuntimeFile)((0, project_fraim_paths_1.getUserFraimDirPath)(), runtimeId);
-    const confirmedVersion = running ? await fetchRunningHubVersion(running.port) : null;
-    const live = !!(running && confirmedVersion && (0, process_liveness_1.isPidAlive)(running.pid));
-    const effective = live && running ? { ...running, version: confirmedVersion } : null;
-    const decision = (0, hub_launch_decision_1.decideHubLaunch)({
-        running: effective,
-        pidAlive: live,
-        cliVersion: (0, version_utils_1.getFraimVersion)(),
-        restart: flags.restart,
-        noRestart: flags.keepRunning,
-    });
-    if (decision.action === 'replace' && effective) {
-        console.log(`Replacing running Hub (v${effective.version}, pid ${effective.pid}) - ${decision.reason}`);
-        killPid(effective.pid);
-        await waitForPortFree(effective.port);
-        // #921: after killing the registered pid, scan for orphan Hub processes that were
-        // never registered in hub-runtime.json (e.g. older versions started via bare npx).
-        if (runtimeId === 'hub') {
-            await scanAndKillOrphanHubs(effective.pid);
-        }
-    }
-    else if (decision.action === 'focus-existing' && effective) {
-        console.log(`A Hub (v${effective.version}) is already running - focusing it. Use --restart to replace it.`);
-    }
-}
 async function runHub(options) {
     const { AiHubServer, findAvailablePort } = await Promise.resolve().then(() => __importStar(require('./server')));
     const preferredPort = options.port || (0, git_utils_1.getPort)() + 100;
@@ -332,7 +211,7 @@ async function runHub(options) {
     if (options.open) {
         const wantDesktop = !options.browser;
         if (wantDesktop) {
-            await reconcileRunningHub({ restart: !!options.restart, keepRunning: !!options.keepRunning }, runtimeId);
+            await (0, hub_instance_reconciliation_1.reconcileRunningHub)({ restart: !!options.restart, keepRunning: !!options.keepRunning }, runtimeId);
         }
         const desktopChild = wantDesktop ? await openDesktopWindow(projectPath, preferredPort, runtimeId) : null;
         if (!desktopChild) {

package/dist/src/ai-hub/desktop-launcher.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const electron_1 = require("electron");
+const path_1 = __importDefault(require("path"));
+const hub_app_materializer_1 = require("./hub-app-materializer");
+// Issue #1415: this is the packaged Electron `main` entry (see packages/fraim-hub/package.json
+// `"main"`). It is deliberately thin and changes rarely: its only job is to resolve which version
+// of the actual Hub application (the code in desktop-main.ts) to run — the latest published to
+// npm, materializing it once per machine if not already cached — and hand off to it. The native
+// installer only ever needs to ship a new build of this file and the Electron shell itself;
+// every ordinary `fraim-hub` release reaches an already-installed user the moment this
+// resolution runs on their next launch, with no new installer download.
+const BUNDLED_ENTRY_PATH = path_1.default.join(__dirname, 'desktop-main.js');
+async function bootstrapFrom(entryPath) {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const entry = require(entryPath);
+    await entry.bootstrap();
+}
+async function launch() {
+    // Issue #1415: deterministic escape hatch for integration testing — skips the real npm
+    // resolution (and its dependence on whatever happens to be published at test time) so a test can
+    // prove the Electron main-process boot chain itself (resolveHubAppEntry -> require -> bootstrap
+    // -> healthy server) without a network round-trip. Not used in any real launch path; mirrors the
+    // existing `FRAIM_INSTALLER_LIFECYCLE_TEST` kill-switch pattern already used for testability.
+    const resolved = process.env.FRAIM_HUB_SKIP_MATERIALIZE === '1'
+        ? { entryPath: BUNDLED_ENTRY_PATH, source: 'bundled', version: electron_1.app.getVersion() }
+        : await (0, hub_app_materializer_1.resolveHubAppEntry)({
+            bundledVersion: electron_1.app.getVersion(),
+            bundledEntryPath: BUNDLED_ENTRY_PATH,
+            onProgress: (message) => console.log(`[fraim-hub-launcher] ${message}`),
+        }).catch((error) => {
+            // resolveHubAppEntry is designed to never throw (every failure mode falls back internally),
+            // but a launch must survive even a bug in that resolution rather than fail here.
+            console.error('[fraim-hub-launcher] resolution failed unexpectedly; using the bundled build:', error);
+            return { entryPath: BUNDLED_ENTRY_PATH, source: 'bundled', version: electron_1.app.getVersion() };
+        });
+    console.log(`[fraim-hub-launcher] running FRAIM Hub ${resolved.version} (${resolved.source})`);
+    try {
+        await bootstrapFrom(resolved.entryPath);
+    }
+    catch (error) {
+        if (resolved.entryPath === BUNDLED_ENTRY_PATH)
+            throw error;
+        // A materialized copy that fails to load (corrupt cache, an ABI mismatch some future
+        // dependency introduces) must not strand the user on a broken launch — fall back to the
+        // build that shipped with this installer, which is always known-good for this Electron binary.
+        console.error(`[fraim-hub-launcher] materialized FRAIM Hub ${resolved.version} failed to load; falling back to the bundled build:`, error);
+        await bootstrapFrom(BUNDLED_ENTRY_PATH);
+    }
+}
+if (process.versions.electron && process.type !== 'renderer') {
+    launch().catch((error) => {
+        console.error(error instanceof Error ? error.message : error);
+        try {
+            electron_1.dialog.showErrorBox('FRAIM Hub failed to start', error instanceof Error ? error.message : String(error));
+        }
+        catch {
+            // dialog can be unavailable this early in rare startup failures; the console error above
+            // is the fallback record.
+        }
+        electron_1.app.exit(1);
+    });
+}

package/dist/src/ai-hub/desktop-main.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.launchDesktopShell = launchDesktopShell;
+exports.bootstrap = bootstrap;
 const electron_1 = require("electron");
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
@@ -20,6 +21,8 @@ const server_2 = require("../first-run/server");
 const session_service_1 = require("../first-run/session-service");
 const fraim_mcp_latest_launcher_1 = require("../cli/mcp/fraim-mcp-latest-launcher");
 const desktop_auto_updater_1 = require("./desktop-auto-updater");
+const hub_app_materializer_1 = require("./hub-app-materializer");
+const hub_instance_reconciliation_1 = require("./hub-instance-reconciliation");
 // Keep installed, running, and user-pinned Windows shortcuts grouped under the
 // stable identity declared in packages/fraim-hub/package.json.
 electron_1.app.setAppUserModelId('ai.fraim.hub');
@@ -73,7 +76,7 @@ function configurePackagedFraimRuntime() {
     if (!electron_1.app.isPackaged && process.env.FRAIM_DESKTOP_FIRST_RUN !== '1')
         return;
     process.env.FRAIM_PACKAGED_CLI_EXECUTABLE = process.execPath;
-    process.env.FRAIM_PACKAGED_CLI_SCRIPT = path_1.default.join(electron_1.app.getAppPath(), 'node_modules', 'fraim', 'bin', 'fraim.js');
+    process.env.FRAIM_PACKAGED_CLI_SCRIPT = (0, hub_app_materializer_1.resolvePackagedCliScriptPath)(__dirname);
     (0, fraim_mcp_latest_launcher_1.ensureFraimMcpLatestLauncher)();
 }
 function shouldShowEmbeddedFirstRun() {
@@ -133,11 +136,65 @@ async function configureAutoUpdater() {
     });
     return result.action === 'installing';
 }
-function checkForUpdateAfterSecondInstance() {
+// Issue #1415: shared by every path that needs to know "is a newer FRAIM Hub published than the
+// one currently running" — the automatic second-instance/activate recheck below, and the
+// manually-triggered restart from the web UI's update badge (see restartToLatestNow). Compares
+// `getFraimVersion()` (not `app.getVersion()`), because it resolves from wherever the
+// currently-running code actually lives — the bundled app.asar or a previously materialized copy
+// — while `app.getVersion()` always names the former.
+async function resolveLatestHubAppVersion() {
+    const runningVersion = (0, version_utils_1.getFraimVersion)();
+    const resolved = await (0, hub_app_materializer_1.resolveHubAppEntry)({
+        bundledVersion: runningVersion,
+        bundledEntryPath: __filename,
+    });
+    return { upgradable: resolved.version !== runningVersion, latest: resolved.version };
+}
+// Issue #1415: a second-instance activation (the user re-clicking the icon while the Hub is
+// already running) is the common case once login-item autostart + hide-to-tray keep the Hub
+// resident for days, and it is the one launch-shaped event where the desktop-launcher.ts
+// materializer never gets a chance to run — bootstrap() has already won the single-instance lock
+// by the time it fires. Without this check, an already-running Hub could only ever pick up a new
+// `fraim-hub` release through the slower electron-updater feed below, which is the exact lagging
+// signal #1415 was filed about.
+async function checkForHubAppUpdateOnSecondInstance() {
+    const { upgradable, latest } = await resolveLatestHubAppVersion();
+    if (!upgradable)
+        return false;
+    console.log(`[fraim] newer FRAIM Hub ${latest} available (was running ${(0, version_utils_1.getFraimVersion)()}); restarting to apply it`);
+    electron_1.app.relaunch();
+    electron_1.app.quit();
+    return true;
+}
+// Issue #1415: the web UI's persistent update badge (#1379) used to just tell the user to quit
+// and relaunch by hand. This is the same "resolve latest, relaunch" as the automatic checks above,
+// just triggered by an explicit click instead of a relaunch-shaped Electron event — wired into
+// AiHubServer as the `restartToLatest` option (see launchDesktopShell) so POST
+// /api/ai-hub/restart-to-latest can call it. The relaunch/quit is deferred a beat so the HTTP
+// response reaches the browser (which uses it to start polling for the new instance) before this
+// process starts tearing down.
+async function restartToLatestNow() {
+    const { upgradable, latest } = await resolveLatestHubAppVersion();
+    if (!upgradable)
+        return { restarting: false, latest };
+    console.log(`[fraim] manual restart requested; relaunching to FRAIM Hub ${latest}`);
+    setTimeout(() => {
+        electron_1.app.relaunch();
+        electron_1.app.quit();
+    }, 300);
+    return { restarting: true, latest };
+}
+// Issue #1415: shared by both re-launch-shaped events on an already-running Hub — Windows/Linux's
+// `second-instance` (a new process lost the single-instance lock) and macOS's `activate` (the
+// Dock icon click that never spawns a new process at all, so `second-instance` never fires there).
+// Before this, neither path re-checked npm-latest, only the older, slower electron-updater feed.
+function checkForRelaunchAttemptUpdate() {
     if (!electron_1.app.isPackaged || process.env.FRAIM_INSTALLER_LIFECYCLE_TEST === '1')
         return;
-    void configureAutoUpdater().catch((err) => {
-        console.warn('[fraim] second-instance update check failed:', err);
+    void checkForHubAppUpdateOnSecondInstance()
+        .then((restarting) => (restarting ? undefined : configureAutoUpdater().then(() => undefined)))
+        .catch((err) => {
+        console.warn('[fraim] relaunch-attempt update check failed:', err);
     });
 }
 // ---------------------------------------------------------------------------
@@ -404,6 +461,7 @@ async function launchDesktopShell(options) {
             });
             return result.canceled || result.filePaths.length === 0 ? null : result.filePaths[0];
         },
+        restartToLatest: restartToLatestNow,
     });
     await server.start(httpPort);
     const resolvedProjectPath = server.getProjectPath();
@@ -469,6 +527,9 @@ async function launchDesktopShell(options) {
 // ---------------------------------------------------------------------------
 // Bootstrap
 // ---------------------------------------------------------------------------
+// Issue #1415: exported so `desktop-launcher.ts` can `require()` this module (whether the copy
+// bundled in this installer or a materialized npm-latest copy) and invoke bootstrap explicitly,
+// instead of relying on the module's own top-level self-execution below.
 async function bootstrap() {
     const options = parseArgs(process.argv.slice(2));
     applyUserDataOverride();
@@ -483,7 +544,7 @@ async function bootstrap() {
         return;
     }
     electron_1.app.on('second-instance', () => {
-        void electron_1.app.whenReady().then(checkForUpdateAfterSecondInstance);
+        void electron_1.app.whenReady().then(checkForRelaunchAttemptUpdate);
         if (mainWindow) {
             mainWindow.show();
             mainWindow.focus();
@@ -492,6 +553,25 @@ async function bootstrap() {
     await electron_1.app.whenReady();
     electron_1.app.setName(displayName(options.runtimeId));
     configurePackagedFraimRuntime();
+    // Issue #1415 (follow-up): app.requestSingleInstanceLock() above only sees another instance of
+    // *this same identity* — it cannot see a Hub already running via a different launch path (e.g.
+    // `npx fraim-hub`'s raw electron.exe, confirmed live to end up under a different userData scope
+    // than this packaged app). hub-runtime.json is the identity-agnostic record both launch paths
+    // already write (#755); reconcile against it — and sweep for unregistered orphans (#921) —
+    // before binding our own port, so a direct double-click launch takes over whatever Hub is
+    // already running instead of silently opening a second, independent one on a fallback port.
+    // `restart: true` because a materialized/bundled launch is by construction already resolved to
+    // the current latest — there is nothing to compare, only to replace. Runs after whenReady, like
+    // every other network-touching step in this function (checkForRelaunchAttemptUpdate,
+    // configureAutoUpdater) — reconcileRunningHub makes real HTTP probes and process kills, and this
+    // keeps it on the same footing as those instead of racing Electron's own startup.
+    // Gated on the same FRAIM_AI_HUB_FAKE_HOST flag as the single-instance lock above, not on
+    // FRAIM_INSTALLER_LIFECYCLE_TEST: the orphan sweep probes real system ports 43091-43200
+    // regardless of FRAIM_USER_DIR isolation, so a test double (FAKE_HOST=1) skips it for the same
+    // reason it skips the lock — it must never disturb a real Hub already running on this machine.
+    if (!skipSingleInstance) {
+        await (0, hub_instance_reconciliation_1.reconcileRunningHub)({ restart: true, keepRunning: false }, options.runtimeId);
+    }
     // macOS reads the dock icon from the app bundle once packaged, but an
     // unpackaged `npm run hub:desktop` / `npx fraim-hub` run shows Electron's
     // own icon there unless we set it explicitly (#1329).
@@ -508,7 +588,10 @@ async function bootstrap() {
             return;
     }
     electron_1.app.on('activate', () => {
-        // macOS: clicking dock icon re-shows the window
+        // macOS: clicking dock icon re-shows the window. Unlike Windows/Linux, this never spawns a
+        // second process (so 'second-instance' never fires here) — it is macOS's equivalent
+        // relaunch-attempt event, so it gets the same npm-latest re-check (#1415).
+        checkForRelaunchAttemptUpdate();
         if (mainWindow) {
             mainWindow.show();
             mainWindow.focus();
@@ -533,7 +616,12 @@ async function bootstrap() {
     });
     await launchDesktopShell(options);
 }
-if (process.versions.electron && process.type !== 'renderer') {
+// Issue #1415: self-execution is now gated on `require.main === module` in addition to the
+// existing Electron-main-process check, so `desktop-launcher.ts` requiring this file (bundled or
+// materialized) does not double-run bootstrap — the launcher calls the exported `bootstrap`
+// explicitly instead. Direct invocation (`npm run hub:desktop`, Electron-launching test suites)
+// is unaffected: this file is still `require.main` in that case.
+if (require.main === module && process.versions.electron && process.type !== 'renderer') {
     bootstrap().catch(async (error) => {
         console.error(error instanceof Error ? error.message : error);
         await stopServerOnce();