fraim-hub 2.0.227 → 2.0.229

package/dist/src/ai-hub/conversation-store.js

@@ -19,7 +19,18 @@ exports.COMPANY_SCOPE_KEY = '@company';
 // (id, title, jobId, jobTitle, agentName, personaKey, status, runId, createdAt, lastUpdatedAt,
 // scope, reviewHandoff, ...) is kept. Client-only runtime flags are omitted too so stale index
 // cache state cannot make the frontend skip lazy body hydration.
-const HEADER_OMITTED_FIELDS = ['messages', 'events', 'artifacts', 'run', 'delegation', '_bodyLoaded', '_stopping'];
+const HEADER_OMITTED_FIELDS = [
+    'messages',
+    'events',
+    'artifacts',
+    'run',
+    'delegation',
+    '_bodyLoaded',
+    '_stopping',
+    '_priorEvents',
+    '_priorMessages',
+];
+const HEADER_OMITTED_FIELD_SET = new Set(HEADER_OMITTED_FIELDS);
 /**
  * Issue #708: resolve the conversation store bucket key for a given scope.
  * - 'manager'/'company' → a stable sentinel key (project-independent home).
@@ -292,8 +303,36 @@ function toHeader(conv) {
     const header = { ...conv };
     for (const field of HEADER_OMITTED_FIELDS)
         delete header[field];
+    for (const field of Object.keys(header)) {
+        if (field.startsWith('_'))
+            delete header[field];
+    }
     return header;
 }
+function headerNeedsSanitization(header) {
+    const value = header;
+    return Object.keys(value).some((field) => HEADER_OMITTED_FIELD_SET.has(field) || field.startsWith('_'));
+}
+function sanitizeBucketIndex(index) {
+    let changed = false;
+    const headers = index.headers.map((header) => {
+        if (headerNeedsSanitization(header))
+            changed = true;
+        return toHeader(header);
+    }).sort(newestFirst);
+    const activeId = index.activeId && headers.some((header) => header.id === index.activeId) ? index.activeId : null;
+    if (activeId !== index.activeId)
+        changed = true;
+    if (!changed) {
+        for (let indexPosition = 0; indexPosition < headers.length; indexPosition += 1) {
+            if (headers[indexPosition].id !== index.headers[indexPosition]?.id) {
+                changed = true;
+                break;
+            }
+        }
+    }
+    return { index: { activeId, headers }, changed };
+}
 function renameWithRetry(from, to) {
     // Windows can throw EPERM/EBUSY when a reader briefly holds the destination open. Retry a few
     // times; the per-bucket lock already prevents concurrent writers from colliding here.
@@ -322,6 +361,7 @@ class AiHubConversationStore {
     constructor(stateFilePath = path_1.default.join((0, project_fraim_paths_1.getUserFraimDirPath)(), 'ai-hub-conversations.json')) {
         this.stateFilePath = stateFilePath;
         this.migrated = false;
+        this.projectPathCache = null;
         const dir = path_1.default.dirname(this.stateFilePath);
         const base = path_1.default.basename(this.stateFilePath).replace(/\.json$/i, '');
         // Sibling directory of the legacy file, e.g. ~/.fraim/ai-hub-conversations/
@@ -345,6 +385,9 @@ class AiHubConversationStore {
     lockPath(bucketDir) {
         return path_1.default.join(bucketDir, '.lock');
     }
+    invalidateProjectPathCache() {
+        this.projectPathCache = null;
+    }
     // ---- migration (split of the legacy monolith) ----
     importLegacyMonolithIfPresent() {
         let stat;
@@ -431,8 +474,23 @@ class AiHubConversationStore {
     // source of truth) and persist it best-effort.
     loadIndex(bucketDir, bucketKey) {
         const existing = this.readIndex(bucketDir);
-        if (existing)
-            return existing;
+        if (existing) {
+            const sanitized = sanitizeBucketIndex(existing);
+            if (sanitized.changed) {
+                try {
+                    writeJsonAtomic(this.indexPath(bucketDir), {
+                        version: 2,
+                        bucketKey,
+                        activeId: sanitized.index.activeId,
+                        headers: sanitized.index.headers,
+                    });
+                }
+                catch {
+                    /* best-effort cache self-heal */
+                }
+            }
+            return sanitized.index;
+        }
         const headers = this.readAllConversations(bucketDir, bucketKey).map(toHeader).sort(newestFirst);
         const rebuilt = { activeId: null, headers };
         if (headers.length > 0) {
@@ -457,6 +515,7 @@ class AiHubConversationStore {
     // Author a whole bucket to exactly `conversations` (used by migration and replaceProject).
     writeBucket(bucketKey, state) {
         const bucketDir = this.bucketDir(bucketKey);
+        const bucketAlreadyExisted = fs_1.default.existsSync(bucketDir);
         fs_1.default.mkdirSync(bucketDir, { recursive: true });
         (0, conversation_store_lock_1.withBucketLock)(this.lockPath(bucketDir), () => {
             const desired = new Set(state.conversations.map((c) => c.id));
@@ -480,10 +539,24 @@ class AiHubConversationStore {
                 this.writeConvFile(bucketDir, bucketKey, conv);
             this.writeIndex(bucketDir, bucketKey, state.activeId, state.conversations);
         });
+        if (!bucketAlreadyExisted)
+            this.invalidateProjectPathCache();
     }
     // ---- public API ----
     listProjectPaths() {
         this.ensureMigrated();
+        let rootStat;
+        try {
+            rootStat = fs_1.default.statSync(this.shardRoot);
+        }
+        catch {
+            return [];
+        }
+        if (!rootStat.isDirectory())
+            return [];
+        if (this.projectPathCache && this.projectPathCache.shardRootMtimeMs === rootStat.mtimeMs) {
+            return this.projectPathCache.keys.slice();
+        }
         let dirs;
         try {
             dirs = fs_1.default.readdirSync(this.shardRoot);
@@ -497,7 +570,15 @@ class AiHubConversationStore {
             if (bucketKey)
                 keys.push(normalizeProjectPath(bucketKey));
         }
-        return keys;
+        let finalRootMtimeMs = rootStat.mtimeMs;
+        try {
+            finalRootMtimeMs = fs_1.default.statSync(this.shardRoot).mtimeMs;
+        }
+        catch {
+            /* keep the pre-scan mtime */
+        }
+        this.projectPathCache = { shardRootMtimeMs: finalRootMtimeMs, keys };
+        return keys.slice();
     }
     bucketKeyOf(bucketDir) {
         try {
@@ -575,6 +656,7 @@ class AiHubConversationStore {
                 fs_1.default.rmSync(path_1.default.join(bucketDir, file), { recursive: true, force: true });
             }
         });
+        this.invalidateProjectPathCache();
         return true;
     }
     replaceProject(projectPath, next) {
@@ -591,8 +673,9 @@ class AiHubConversationStore {
         if (!incoming)
             return this.loadProject(key);
         const bucketDir = this.bucketDir(key);
+        const bucketAlreadyExisted = fs_1.default.existsSync(bucketDir);
         fs_1.default.mkdirSync(bucketDir, { recursive: true });
-        return (0, conversation_store_lock_1.withBucketLock)(this.lockPath(bucketDir), () => {
+        const state = (0, conversation_store_lock_1.withBucketLock)(this.lockPath(bucketDir), () => {
             // Merge with an existing copy of the same id, keeping the richer copy (a header-only shell
             // must never overwrite real run history), tie-broken by newer lastUpdatedAt.
             const convPath = this.convFilePath(bucketDir, incoming.id);
@@ -610,6 +693,9 @@ class AiHubConversationStore {
             this.writeConvFile(bucketDir, key, winner);
             return this.reindexAfterUpsert(bucketDir, key, winner, activeId);
         });
+        if (!bucketAlreadyExisted)
+            this.invalidateProjectPathCache();
+        return state;
     }
     // Set the active conversation without rewriting any conversation body. (Mutation methods return
     // header-shaped state, so callers must never round-trip that through replaceProject to set
@@ -618,20 +704,25 @@ class AiHubConversationStore {
         this.ensureMigrated();
         const key = normalizeConversationKey(projectPath);
         const bucketDir = this.bucketDir(key);
+        const bucketAlreadyExisted = fs_1.default.existsSync(bucketDir);
         fs_1.default.mkdirSync(bucketDir, { recursive: true });
-        return (0, conversation_store_lock_1.withBucketLock)(this.lockPath(bucketDir), () => {
+        const state = (0, conversation_store_lock_1.withBucketLock)(this.lockPath(bucketDir), () => {
             const idx = this.loadIndex(bucketDir, key);
             const valid = activeId && idx.headers.some((h) => h.id === activeId) ? activeId : null;
             writeJsonAtomic(this.indexPath(bucketDir), { version: 2, bucketKey: key, activeId: valid, headers: idx.headers });
             return normalizeProjectState(key, { activeId: valid, conversations: idx.headers });
         });
+        if (!bucketAlreadyExisted)
+            this.invalidateProjectPathCache();
+        return state;
     }
     patchConversation(projectPath, conversationId, patch) {
         this.ensureMigrated();
         const key = normalizeConversationKey(projectPath);
         const bucketDir = this.bucketDir(key);
+        const bucketAlreadyExisted = fs_1.default.existsSync(bucketDir);
         fs_1.default.mkdirSync(bucketDir, { recursive: true });
-        return (0, conversation_store_lock_1.withBucketLock)(this.lockPath(bucketDir), () => {
+        const state = (0, conversation_store_lock_1.withBucketLock)(this.lockPath(bucketDir), () => {
             const convPath = this.convFilePath(bucketDir, conversationId);
             let existing = null;
             try {
@@ -660,10 +751,13 @@ class AiHubConversationStore {
             this.writeConvFile(bucketDir, key, merged);
             return this.reindexAfterUpsert(bucketDir, key, merged, undefined);
         });
+        if (!bucketAlreadyExisted)
+            this.invalidateProjectPathCache();
+        return state;
     }
     // Update the index header for one conversation and return the (header-shaped) project state.
     reindexAfterUpsert(bucketDir, bucketKey, conv, activeId) {
-        const idx = this.readIndex(bucketDir) ?? { activeId: null, headers: [] };
+        const idx = this.loadIndex(bucketDir, bucketKey);
         const headers = idx.headers.filter((h) => h.id !== conv.id);
         headers.push(toHeader(conv));
         headers.sort(newestFirst);

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

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.launchDesktopShell = launchDesktopShell;
 const electron_1 = require("electron");
+const electron_updater_1 = require("electron-updater");
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
 const server_1 = require("./server");
@@ -82,6 +83,14 @@ function ensureLoginItem() {
     fs_1.default.mkdirSync(path_1.default.dirname(flagPath), { recursive: true });
     fs_1.default.writeFileSync(flagPath, '1');
 }
+function configureAutoUpdater() {
+    if (!electron_1.app.isPackaged)
+        return;
+    electron_updater_1.autoUpdater.autoDownload = true;
+    electron_updater_1.autoUpdater.checkForUpdatesAndNotify().catch((err) => {
+        console.warn('[fraim] auto-update check failed:', err);
+    });
+}
 // ---------------------------------------------------------------------------
 // Word manifest sideload (runs once on first launch)
 // ---------------------------------------------------------------------------
@@ -366,6 +375,7 @@ async function bootstrap() {
     electron_1.app.setName('FRAIM Hub');
     // First-launch housekeeping (idempotent, fast on subsequent runs)
     ensureLoginItem();
+    configureAutoUpdater();
     electron_1.app.on('activate', () => {
         // macOS: clicking dock icon re-shows the window
         if (mainWindow) {

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

@@ -12,6 +12,7 @@ exports.detectEmployees = detectEmployees;
 exports.prepareCodexBrowserHome = prepareCodexBrowserHome;
 exports.sharedBrowserHostConfig = sharedBrowserHostConfig;
 exports.buildStartPlan = buildStartPlan;
+exports.buildInteractiveResumeCommand = buildInteractiveResumeCommand;
 exports.buildContinuePlan = buildContinuePlan;
 exports.supportsDirectPath = supportsDirectPath;
 exports.buildDirectStartPlan = buildDirectStartPlan;
@@ -996,6 +997,15 @@ function buildStartPlan(hostId, message, sessionId) {
         env: browser.env,
     };
 }
+function buildInteractiveResumeCommand(hostId, sessionId) {
+    if (hostId === 'codex')
+        return `codex resume ${sessionId}`;
+    if (hostId === 'gemini')
+        return `gemini --resume ${sessionId}`;
+    if (hostId === 'copilot')
+        return `copilot --resume ${sessionId}`;
+    return `claude -r ${sessionId}`;
+}
 function buildContinuePlan(hostId, sessionId, message) {
     if (hostId === 'codex') {
         const browser = sharedBrowserHostConfig('codex');

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

@@ -21,6 +21,7 @@ const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
 const child_process_1 = require("child_process");
 const project_fraim_paths_1 = require("../core/utils/project-fraim-paths");
+const hub_release_download_1 = require("./hub-release-download");
 // Stable install directory under ~/.fraim/bin/fraim-hub-electron/
 function resolveHubInstallDir() {
     return path_1.default.join((0, project_fraim_paths_1.getUserFraimDirPath)(), 'bin', 'fraim-hub-electron');
@@ -125,10 +126,9 @@ async function runHubInstall() {
     const target = resolveShortcutTarget();
     const home = os_1.default.homedir();
     const shortcuts = getOsShortcutPaths(home);
-    // Ensure the install directory exists (the actual Electron binary download
-    // is a separate step — this wires the OS launcher to the expected path so
-    // the shortcut is ready as soon as the binary is downloaded).
     fs_1.default.mkdirSync(installDir, { recursive: true });
+    const downloaded = await (0, hub_release_download_1.downloadLatestHubBinary)(installDir, target);
+    console.log(`  Downloaded release asset: ${downloaded.assetName}`);
     if (process.platform === 'win32' && shortcuts.startMenu) {
         fs_1.default.mkdirSync(path_1.default.dirname(shortcuts.startMenu), { recursive: true });
         writeWindowsShortcutScript(shortcuts.startMenu, target);
@@ -155,9 +155,6 @@ async function runHubInstall() {
     console.log('');
     console.log('FRAIM Hub is registered as an OS application.');
     console.log('Launch it from your Start Menu / Launchpad / application launcher.');
-    console.log('');
-    console.log('Note: the Hub binary will be downloaded on first launch via:');
-    console.log('  fraim hub  (or npx fraim-hub@latest)');
 }
 exports.hubInstallCommand = new commander_1.Command('install')
     .description('Register FRAIM Hub as an OS application (Start Menu / Launchpad entry)')

package/dist/src/ai-hub/hub-release-download.js

@@ -0,0 +1,123 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectHubReleaseAsset = selectHubReleaseAsset;
+exports.downloadLatestHubBinary = downloadLatestHubBinary;
+const fs_1 = __importDefault(require("fs"));
+const https_1 = __importDefault(require("https"));
+const path_1 = __importDefault(require("path"));
+const promises_1 = require("stream/promises");
+const adm_zip_1 = __importDefault(require("adm-zip"));
+const LATEST_RELEASE_API_URL = 'https://api.github.com/repos/mathursrus/FRAIM/releases/latest';
+function archNeedles(arch) {
+    if (arch === 'x64')
+        return ['x64', 'x86_64', 'amd64'];
+    if (arch === 'arm64')
+        return ['arm64', 'aarch64'];
+    return [arch.toLowerCase()];
+}
+function nameIncludesArch(name, arch) {
+    const lower = name.toLowerCase();
+    const needles = archNeedles(arch);
+    return needles.some((needle) => lower.includes(needle)) || !/(x64|x86_64|amd64|arm64|aarch64)/i.test(name);
+}
+function selectHubReleaseAsset(assets, platform = process.platform, arch = process.arch) {
+    const candidates = assets.filter((asset) => /fraim[-_ ]?hub/i.test(asset.name) && nameIncludesArch(asset.name, arch));
+    const preferredPatterns = platform === 'win32'
+        ? [/portable.*\.exe$/i, /\.exe$/i, /\.msi$/i]
+        : platform === 'darwin'
+            ? [/mac.*\.zip$/i, /\.zip$/i, /\.dmg$/i]
+            : [/\.AppImage$/i, /\.deb$/i];
+    for (const pattern of preferredPatterns) {
+        const match = candidates.find((asset) => pattern.test(asset.name));
+        if (match)
+            return match;
+    }
+    return null;
+}
+function assertHttpsUrl(rawUrl) {
+    const url = new URL(rawUrl);
+    if (url.protocol !== 'https:') {
+        throw new Error(`Refusing non-HTTPS Hub release URL: ${rawUrl}`);
+    }
+    return url;
+}
+function getJson(rawUrl) {
+    const url = assertHttpsUrl(rawUrl);
+    return new Promise((resolve, reject) => {
+        const req = https_1.default.get(url, { headers: { 'User-Agent': 'fraim-hub-install' }, timeout: 15000 }, (res) => {
+            if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+                res.resume();
+                getJson(res.headers.location).then(resolve, reject);
+                return;
+            }
+            if (res.statusCode !== 200) {
+                res.resume();
+                reject(new Error(`GitHub release lookup failed with HTTP ${res.statusCode}`));
+                return;
+            }
+            let body = '';
+            res.setEncoding('utf8');
+            res.on('data', (chunk) => { body += chunk; });
+            res.on('end', () => {
+                try {
+                    resolve(JSON.parse(body));
+                }
+                catch (err) {
+                    reject(err);
+                }
+            });
+        });
+        req.on('error', reject);
+        req.on('timeout', () => {
+            req.destroy(new Error('Timed out while looking up the latest FRAIM Hub release'));
+        });
+    });
+}
+async function downloadFile(rawUrl, destination, redirectsRemaining = 5) {
+    const url = assertHttpsUrl(rawUrl);
+    await new Promise((resolve, reject) => {
+        const req = https_1.default.get(url, { headers: { 'User-Agent': 'fraim-hub-install' }, timeout: 60000 }, (res) => {
+            if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location && redirectsRemaining > 0) {
+                res.resume();
+                downloadFile(res.headers.location, destination, redirectsRemaining - 1).then(resolve, reject);
+                return;
+            }
+            if (res.statusCode !== 200) {
+                res.resume();
+                reject(new Error(`Hub release download failed with HTTP ${res.statusCode}`));
+                return;
+            }
+            fs_1.default.mkdirSync(path_1.default.dirname(destination), { recursive: true });
+            void (0, promises_1.pipeline)(res, fs_1.default.createWriteStream(destination)).then(resolve, reject);
+        });
+        req.on('error', reject);
+        req.on('timeout', () => {
+            req.destroy(new Error('Timed out while downloading the FRAIM Hub release asset'));
+        });
+    });
+}
+function installDownloadedAsset(downloadPath, assetName, installDir, target) {
+    if (process.platform === 'darwin' && /\.zip$/i.test(assetName)) {
+        fs_1.default.rmSync(path_1.default.join(installDir, 'FRAIM Hub.app'), { recursive: true, force: true });
+        new adm_zip_1.default(downloadPath).extractAllTo(installDir, true);
+        return;
+    }
+    fs_1.default.copyFileSync(downloadPath, target);
+    if (process.platform !== 'win32') {
+        fs_1.default.chmodSync(target, 0o755);
+    }
+}
+async function downloadLatestHubBinary(installDir, target) {
+    const release = await getJson(process.env.FRAIM_HUB_RELEASE_API_URL || LATEST_RELEASE_API_URL);
+    const asset = selectHubReleaseAsset(release.assets || []);
+    if (!asset) {
+        throw new Error('No runnable FRAIM Hub release asset was found for this platform.');
+    }
+    const downloadPath = path_1.default.join(installDir, asset.name);
+    await downloadFile(asset.browser_download_url, downloadPath);
+    installDownloadedAsset(downloadPath, asset.name, installDir, target);
+    return { assetName: asset.name, target };
+}

package/dist/src/ai-hub/remote-hub-gateway.js

@@ -24,23 +24,30 @@ class HttpHubRemoteGateway {
             timeout: 10000,
         });
     }
-    async getPersonaState(apiKey) {
+    async getPersonaStateResult(apiKey) {
+        // No key: a definitive "unauthenticated" answer — the authority is not the problem.
         if (!apiKey)
-            return null;
+            return { state: null, reachable: true };
         try {
             const res = await this.client(apiKey).get('/api/personas/me');
-            return res.data;
+            return { state: res.data, reachable: true };
         }
         catch (err) {
-            // 401 (no/expired key) or 404 (feature disabled) => treat as "no state" so the Hub
-            // renders a clean locked/not-signed-in view instead of crashing.
+            // 401 (no/expired key) or 404 (feature disabled) are definitive answers from a
+            // reachable authority => treat as "no state" so the Hub renders a clean
+            // locked/not-signed-in view instead of crashing.
             const status = err?.response?.status;
             if (status === 401 || status === 404)
-                return null;
+                return { state: null, reachable: true };
+            // Anything else (timeout, connection refused, 5xx) means we could not reach the
+            // authority. Issue #925: the caller must not treat this like a signed-out user.
             console.warn('[ai-hub] getPersonaState failed:', err?.message || err);
-            return null;
+            return { state: null, reachable: false };
         }
     }
+    async getPersonaState(apiKey) {
+        return (await this.getPersonaStateResult(apiKey)).state;
+    }
     async listManagerTeam(apiKey) {
         if (!apiKey)
             return [];