fraim-hub 2.0.247 → 2.0.249

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

@@ -36,6 +36,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForDesktopHubReady = waitForDesktopHubReady;
 exports.runHub = runHub;
 // Hub-owned launcher used by the fraim-hub package. Keep this outside
 // src/cli/commands so the core fraim package has no Hub command implementation.
@@ -79,7 +80,7 @@ function openDesktopWindow(projectPath, preferredPort, runtimeId) {
     const electronBinary = resolveElectronBinary();
     const desktopEntry = resolveDesktopEntry();
     if (!electronBinary || !desktopEntry) {
-        return false;
+        return null;
     }
     const args = projectPath
         ? [desktopEntry, '--project-path', projectPath, '--port', String(preferredPort)]
@@ -91,8 +92,7 @@ function openDesktopWindow(projectPath, preferredPort, runtimeId) {
         detached: true,
         stdio: 'ignore',
     });
-    child.unref();
-    return true;
+    return child;
 }
 function openBrowser(url) {
     if (process.platform === 'win32') {
@@ -207,6 +207,41 @@ function fetchRunningHubVersion(port) {
         req.on('timeout', () => { req.destroy(); resolve(null); });
     });
 }
+async function waitForDesktopHubReady(child, preferredPort, options = {}) {
+    const timeoutMs = options.timeoutMs ?? 15000;
+    const pollMs = options.pollMs ?? 250;
+    const runtimeId = options.runtimeId || 'hub';
+    const fraimDir = options.fraimDir || (0, project_fraim_paths_1.getUserFraimDirPath)();
+    const start = Date.now();
+    const childState = {};
+    child.once('exit', (code, signal) => {
+        childState.exit = { code, signal };
+    });
+    child.once('error', (error) => {
+        childState.error = error;
+    });
+    while (Date.now() - start < timeoutMs) {
+        if (childState.error) {
+            throw new Error(`FRAIM Hub desktop shell failed to launch: ${childState.error.message}`);
+        }
+        if (childState.exit) {
+            const detail = childState.exit.signal ? `signal ${childState.exit.signal}` : `exit code ${childState.exit.code ?? 'unknown'}`;
+            throw new Error(`FRAIM Hub desktop shell exited before the Hub became ready (${detail}).`);
+        }
+        const runtime = (0, hub_runtime_file_1.readHubRuntimeFile)(fraimDir, runtimeId);
+        const ports = runtime?.port && runtime.port !== preferredPort
+            ? [runtime.port, preferredPort]
+            : [preferredPort];
+        for (const port of ports) {
+            const version = await fetchRunningHubVersion(port);
+            if (version) {
+                return { port, version };
+            }
+        }
+        await new Promise((r) => setTimeout(r, pollMs));
+    }
+    throw new Error(`Timed out waiting for FRAIM Hub desktop shell to become ready on port ${preferredPort}.`);
+}
 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;
@@ -243,8 +278,8 @@ async function runHub(options) {
         if (wantDesktop) {
             await reconcileRunningHub({ restart: !!options.restart, keepRunning: !!options.keepRunning }, runtimeId);
         }
-        const openedDesktop = wantDesktop && openDesktopWindow(projectPath, preferredPort, runtimeId);
-        if (!openedDesktop) {
+        const desktopChild = wantDesktop ? openDesktopWindow(projectPath, preferredPort, runtimeId) : null;
+        if (!desktopChild) {
             const port = await findAvailablePort(preferredPort);
             const server = new AiHubServer(projectPath ? { projectPath } : {});
             await server.start(port);
@@ -254,7 +289,9 @@ async function runHub(options) {
             openBrowser(url);
             return;
         }
-        console.log('AI Hub desktop shell launched.');
+        const ready = await waitForDesktopHubReady(desktopChild, preferredPort, { runtimeId });
+        desktopChild.unref();
+        console.log(`AI Hub desktop shell launched at http://127.0.0.1:${ready.port}/ai-hub/ (v${ready.version}).`);
         if (projectPath)
             console.log(`Project path: ${projectPath}`);
         else

package/dist/src/ai-hub/custom-employees.js

@@ -17,21 +17,22 @@ exports.buildCustomEmployeePersona = buildCustomEmployeePersona;
 // evaluatePersonaAccess) must never call resolveEmployee.
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
-const project_fraim_paths_1 = require("../core/utils/project-fraim-paths");
+const pack_home_1 = require("../cli/utils/pack-home");
 const persona_hiring_1 = require("../config/persona-hiring");
 const EMPLOYEES_DIR_REL = path_1.default.join('fraim', 'personalized-employee', 'employees');
 function employeesDir(projectDir) {
     return path_1.default.join(projectDir, EMPLOYEES_DIR_REL);
 }
-// Issue #1002: the manager level is the default home for a custom employee, so
-// an employee the manager created is available in every project on the machine.
-// Two roots, matching capability precedence: the writable home wins over the
-// synced cache, so a just-created employee appears before any publish or sync.
-function managerEmployeesDirs() {
-    return {
-        local: path_1.default.join((0, project_fraim_paths_1.getUserFraimDirPath)(), 'personalized-employee', 'employees'),
-        cache: path_1.default.join((0, project_fraim_paths_1.getUserFraimDirPath)(), 'manager', 'employees'),
-    };
+// Issue #1043 (review round 2): every layer has exactly one home, named by
+// config, and that home holds the whole layer. There are no caches, so an
+// employee has exactly one authoritative location per level.
+const EMPLOYEES_SUBDIR = 'employees';
+function layerEmployeeReadDirs(layer) {
+    return (0, pack_home_1.packReadRoots)(layer).map((root) => path_1.default.join(root, EMPLOYEES_SUBDIR));
+}
+/** The single writable employees directory for a layer. */
+function layerEmployeeWriteDir(layer) {
+    return path_1.default.join((0, pack_home_1.resolvePackHome)(layer).root, EMPLOYEES_SUBDIR);
 }
 function readEmployeesFromDir(dir, scope) {
     if (!fs_1.default.existsSync(dir))
@@ -82,15 +83,23 @@ function safeSlug(key) {
  * cache. Reading the manager level here is what makes the manager-level default
  * usable: without it an employee created at the manager level would exist on
  * disk and appear in no roster.
+ *
+ * Issue #1043 adds the org level at the bottom of that order, so an employee
+ * shared company-wide is visible to everyone, and a manager or project copy of
+ * the same key still takes precedence over it.
  */
 function readCustomEmployees(projectDir) {
-    const dirs = managerEmployeesDirs();
     const byKey = new Map();
     // Lowest precedence first, so a later write overwrites on key collision.
-    for (const emp of readEmployeesFromDir(dirs.cache, 'manager'))
-        byKey.set(emp.key, emp);
-    for (const emp of readEmployeesFromDir(dirs.local, 'manager'))
-        byKey.set(emp.key, emp);
+    // packReadRoots is highest-precedence-first, so it is walked in reverse.
+    for (const dir of [...layerEmployeeReadDirs('org')].reverse()) {
+        for (const emp of readEmployeesFromDir(dir, 'org'))
+            byKey.set(emp.key, emp);
+    }
+    for (const dir of [...layerEmployeeReadDirs('manager')].reverse()) {
+        for (const emp of readEmployeesFromDir(dir, 'manager'))
+            byKey.set(emp.key, emp);
+    }
     for (const emp of readEmployeesFromDir(employeesDir(projectDir), 'project'))
         byKey.set(emp.key, emp);
     return [...byKey.values()];
@@ -108,7 +117,9 @@ function writeCustomEmployee(projectDir, employee) {
     const slug = safeSlug(record.key);
     if (!slug)
         throw new Error(`Invalid employee key: ${record.key}`);
-    const dir = scope === 'project' ? employeesDir(projectDir) : managerEmployeesDirs().local;
+    // Issue #1043 (review round 1): the org level now has a real writable home,
+    // resolved from config, so an org-scope write no longer has to be refused.
+    const dir = scope === 'project' ? employeesDir(projectDir) : layerEmployeeWriteDir(scope);
     fs_1.default.mkdirSync(dir, { recursive: true });
     fs_1.default.writeFileSync(path_1.default.join(dir, `${slug}.json`), JSON.stringify(record, null, 2), 'utf8');
 }
@@ -121,11 +132,12 @@ function deleteCustomEmployee(projectDir, key) {
     const slug = safeSlug(key);
     if (!slug)
         return false;
-    const dirs = managerEmployeesDirs();
+    // Every place a copy could live, at every level. A delete that misses one
+    // reports success while the record is still listed from that level.
     const candidates = [
         path_1.default.join(employeesDir(projectDir), `${slug}.json`),
-        path_1.default.join(dirs.local, `${slug}.json`),
-        path_1.default.join(dirs.cache, `${slug}.json`),
+        ...layerEmployeeReadDirs('manager').map((d) => path_1.default.join(d, `${slug}.json`)),
+        ...layerEmployeeReadDirs('org').map((d) => path_1.default.join(d, `${slug}.json`)),
     ];
     let removed = false;
     for (const fp of candidates) {

package/dist/src/ai-hub/host-session-state.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hostSessionState = exports.HostSessionState = void 0;
+class HostSessionState {
+    keyFor(owner) {
+        const configuredAgentId = typeof owner.configuredAgentId === 'string' ? owner.configuredAgentId.trim() : '';
+        return configuredAgentId || `${owner.baseHostId}-default`;
+    }
+    applySession(target, owner, sessionId, options = {}) {
+        const normalizedSessionId = sessionId.trim();
+        if (!normalizedSessionId)
+            return;
+        const at = options.at || new Date().toISOString();
+        const key = this.keyFor(owner);
+        target.hostSessions = {
+            ...(target.hostSessions || {}),
+            [key]: {
+                configuredAgentId: owner.configuredAgentId || null,
+                baseHostId: owner.baseHostId,
+                sessionId: normalizedSessionId,
+                status: options.status || 'valid',
+                sourceRunId: options.sourceRunId ?? target.id ?? null,
+                updatedAt: at,
+            },
+        };
+        target.sessionId = normalizedSessionId;
+    }
+    mergeFromRun(record, run) {
+        const owner = {
+            configuredAgentId: run.configuredAgentId || record.configuredAgentId || null,
+            baseHostId: (run.baseHostId || run.hostId || record.baseHostId || record.agentName),
+        };
+        record.hostSessions = { ...(record.hostSessions || {}) };
+        for (const [key, session] of Object.entries(run.hostSessions || {})) {
+            record.hostSessions[key] = { ...session };
+        }
+        if (run.sessionId) {
+            const projectedRun = {
+                id: run.id,
+                sessionId: record.sessionId || undefined,
+                hostSessions: record.hostSessions,
+            };
+            this.applySession(projectedRun, owner, run.sessionId, { sourceRunId: run.id });
+            record.hostSessions = projectedRun.hostSessions;
+        }
+        const active = this.resolve(record, owner);
+        record.sessionId = active?.sessionId || run.sessionId || record.sessionId || null;
+    }
+    resolve(conversation, owner) {
+        if (!conversation)
+            return null;
+        const sessions = conversation.hostSessions || {};
+        const key = this.keyFor(owner);
+        const exact = sessions[key];
+        if (this.isResumableForOwner(exact, owner))
+            return exact;
+        const fallback = Object.values(sessions).find((session) => this.isResumableForOwner(session, owner));
+        if (fallback)
+            return fallback;
+        const legacySessionId = typeof conversation.sessionId === 'string' ? conversation.sessionId.trim() : '';
+        if (!legacySessionId)
+            return null;
+        return {
+            configuredAgentId: owner.configuredAgentId || null,
+            baseHostId: owner.baseHostId,
+            sessionId: legacySessionId,
+            status: 'suspect',
+            sourceRunId: typeof conversation.runId === 'string' ? conversation.runId : null,
+            updatedAt: typeof conversation.lastUpdatedAt === 'string' ? conversation.lastUpdatedAt : new Date().toISOString(),
+        };
+    }
+    markInvalid(conversation, owner, sessionId, reason, at = new Date().toISOString()) {
+        const normalizedSessionId = sessionId.trim();
+        if (!normalizedSessionId)
+            return;
+        const key = this.keyFor(owner);
+        const existing = conversation.hostSessions?.[key];
+        conversation.hostSessions = { ...(conversation.hostSessions || {}) };
+        conversation.hostSessions[key] = {
+            configuredAgentId: owner.configuredAgentId || existing?.configuredAgentId || null,
+            baseHostId: owner.baseHostId,
+            sessionId: normalizedSessionId,
+            status: 'invalid',
+            sourceRunId: existing?.sourceRunId || (typeof conversation.runId === 'string' ? conversation.runId : null),
+            updatedAt: existing?.updatedAt || at,
+            invalidatedAt: at,
+            invalidationReason: reason,
+        };
+        if (conversation.sessionId === normalizedSessionId) {
+            const replacement = this.resolve({ ...conversation, sessionId: null }, owner);
+            conversation.sessionId = replacement?.sessionId || null;
+        }
+    }
+    markInvalidRun(run, owner, sessionId, reason, at = new Date().toISOString()) {
+        const normalizedSessionId = sessionId.trim();
+        if (!normalizedSessionId)
+            return;
+        const key = this.keyFor(owner);
+        const existing = run.hostSessions?.[key];
+        run.hostSessions = { ...(run.hostSessions || {}) };
+        run.hostSessions[key] = {
+            configuredAgentId: owner.configuredAgentId || existing?.configuredAgentId || null,
+            baseHostId: owner.baseHostId,
+            sessionId: normalizedSessionId,
+            status: 'invalid',
+            sourceRunId: existing?.sourceRunId || run.id || null,
+            updatedAt: existing?.updatedAt || at,
+            invalidatedAt: at,
+            invalidationReason: reason,
+        };
+        if (run.sessionId === normalizedSessionId) {
+            run.sessionId = undefined;
+        }
+    }
+    hasInvalidSession(conversation, owner, sessionId) {
+        const normalizedSessionId = sessionId.trim();
+        if (!conversation || !normalizedSessionId)
+            return false;
+        const key = this.keyFor(owner);
+        const exact = conversation.hostSessions?.[key];
+        if (exact?.status === 'invalid' && exact.sessionId === normalizedSessionId)
+            return true;
+        return Object.values(conversation.hostSessions || {}).some((session) => (session.status === 'invalid'
+            && session.sessionId === normalizedSessionId
+            && session.baseHostId === owner.baseHostId));
+    }
+    isResumableForOwner(session, owner) {
+        if (!session || !session.sessionId || session.status === 'invalid')
+            return false;
+        if (session.baseHostId !== owner.baseHostId)
+            return false;
+        const requestedConfiguredAgentId = typeof owner.configuredAgentId === 'string' ? owner.configuredAgentId.trim() : '';
+        const sessionConfiguredAgentId = typeof session.configuredAgentId === 'string' ? session.configuredAgentId.trim() : '';
+        return !requestedConfiguredAgentId || !sessionConfiguredAgentId || requestedConfiguredAgentId === sessionConfiguredAgentId;
+    }
+}
+exports.HostSessionState = HostSessionState;
+exports.hostSessionState = new HostSessionState();

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

@@ -1578,7 +1578,10 @@ function parseHostLine(hostId, line) {
         if (parsed.type === 'result') {
             // Don't emit message — the 'assistant' event already captured the turn text.
             // result carries usage data (parsed by parseUsageSignal above via withSignal).
-            return withSignal({ sessionId: parsed.session_id, raw: trimmed });
+            // Claude result events can echo the requested resume id even when resume failed
+            // with "No conversation found with session ID". Treat system events as the
+            // authoritative session source instead of reinforcing a stale pointer.
+            return withSignal({ raw: trimmed });
         }
         return withSignal({ raw: trimmed });
     }

package/dist/src/ai-hub/office-sideload.js

@@ -3,9 +3,9 @@
  * Sideloads Office add-in manifests (Word + PowerPoint) so they appear under
  * Insert > My Add-ins > Developer Add-ins without admin rights or AppSource.
  *
- * Windows: writes HKCU\SOFTWARE\Microsoft\Office\16.0\WEF\Developer\<guid> =
- *          ABSOLUTE FILE PATH to manifest.xml. This is exactly what Microsoft's
- *          `office-addin-dev-settings register` writes. A URL value is for
+ * Windows: writes HKCU\SOFTWARE\Microsoft\Office\16.0\WEF\Developer\{<guid>}
+ *          (Default) = ABSOLUTE FILE PATH to manifest.xml. This is the registry
+ *          shape Word resolves for Developer Add-ins. A URL value is for
  *          SharePoint/network-share catalogs and yields "catalog access denied"
  *          for a developer sideload — do NOT use a URL here.
  * macOS:   copies the manifest into each app's
@@ -23,6 +23,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.manifestXmlForPort = manifestXmlForPort;
+exports.winDeveloperManifestSubkey = winDeveloperManifestSubkey;
 exports.isSideloaded = isSideloaded;
 exports.sideloadManifest = sideloadManifest;
 exports.removeSideload = removeSideload;
@@ -61,7 +62,7 @@ function generatedManifestPath(entry, userDataDir) {
     return path_1.default.join(userDataDir, 'office-manifests', entry.guid, 'manifest.xml');
 }
 function manifestXmlForPort(xml, httpPort) {
-    return xml.replace(/(https?:\/\/(?:localhost|127\.0\.0\.1)):43091/g, `$1:${httpPort}`);
+    return xml.replace(/https?:\/\/(?:localhost|127\.0\.0\.1):43091/g, `http://127.0.0.1:${httpPort}`);
 }
 function prepareManifestForSideload(entry, sourcePath, options) {
     if (!options.httpPort)
@@ -76,16 +77,46 @@ function prepareManifestForSideload(entry, sourcePath, options) {
 // ---------------------------------------------------------------------------
 // Windows registry helpers
 // ---------------------------------------------------------------------------
-function winRegisteredValue(guid) {
+function winDeveloperManifestSubkey(guid) {
+    return `${WEF_DEVELOPER_KEY}\\{${guid}}`;
+}
+function parseRegSzValue(stdout) {
+    const line = stdout.split(/\r?\n/).find(l => l.includes('REG_SZ'));
+    if (!line)
+        return null;
+    const idx = line.indexOf('REG_SZ');
+    return line.slice(idx + 'REG_SZ'.length).trim() || null;
+}
+function winRegisteredRootValue(guid) {
     const r = (0, child_process_1.spawnSync)('reg', ['query', WEF_DEVELOPER_KEY, '/v', guid], { encoding: 'utf8' });
     if (r.status !== 0 || !r.stdout.includes('REG_SZ'))
         return null;
     // Output line looks like: "    <guid>    REG_SZ    C:\path\to\manifest.xml"
-    const line = r.stdout.split(/\r?\n/).find(l => l.includes('REG_SZ'));
-    if (!line)
+    return parseRegSzValue(r.stdout);
+}
+function winRegisteredDefaultValue(guid) {
+    const r = (0, child_process_1.spawnSync)('reg', ['query', winDeveloperManifestSubkey(guid), '/ve'], { encoding: 'utf8' });
+    if (r.status !== 0 || !r.stdout.includes('REG_SZ'))
         return null;
-    const idx = line.indexOf('REG_SZ');
-    return line.slice(idx + 'REG_SZ'.length).trim() || null;
+    // Output line looks like: "    (Default)    REG_SZ    C:\path\to\manifest.xml"
+    return parseRegSzValue(r.stdout);
+}
+function winRegisteredValue(guid) {
+    // Word resolves the braced GUID subkey. Prefer it even when a legacy root
+    // value exists, so a stale effective registration cannot be hidden.
+    return winRegisteredDefaultValue(guid) ?? winRegisteredRootValue(guid);
+}
+function winWriteRegisteredValue(guid, manifestPath) {
+    const r = (0, child_process_1.spawnSync)('reg', [
+        'add', winDeveloperManifestSubkey(guid),
+        '/ve', '/t', 'REG_SZ', '/d', manifestPath, '/f',
+    ], { encoding: 'utf8' });
+    if (r.status !== 0)
+        return { ok: false, reason: r.stderr || `reg add failed for ${guid}` };
+    // Remove the older root-value registration if present. Office does not need
+    // it, and keeping two registration shapes makes stale-state diagnosis harder.
+    (0, child_process_1.spawnSync)('reg', ['delete', WEF_DEVELOPER_KEY, '/v', guid, '/f'], { encoding: 'utf8' });
+    return { ok: true };
 }
 // ---------------------------------------------------------------------------
 // Public API
@@ -117,13 +148,10 @@ function sideloadManifest(projectPath, options = {}) {
         }
         const sideloadPath = prepareManifestForSideload(entry, manifestPath, options);
         if (process.platform === 'win32') {
-            // Developer-key value = absolute file path to manifest.xml (NOT a URL).
-            const r = (0, child_process_1.spawnSync)('reg', [
-                'add', WEF_DEVELOPER_KEY,
-                '/v', entry.guid, '/t', 'REG_SZ', '/d', sideloadPath, '/f',
-            ], { encoding: 'utf8' });
-            if (r.status !== 0)
-                return { ok: false, reason: r.stderr || `reg add failed for ${entry.guid}` };
+            // Developer add-in subkey default value = absolute file path to manifest.xml (NOT a URL).
+            const r = winWriteRegisteredValue(entry.guid, sideloadPath);
+            if (!r.ok)
+                return r;
             continue;
         }
         if (process.platform === 'darwin') {
@@ -146,6 +174,7 @@ function removeSideload() {
     for (const entry of MANIFESTS) {
         if (process.platform === 'win32') {
             (0, child_process_1.spawnSync)('reg', ['delete', WEF_DEVELOPER_KEY, '/v', entry.guid, '/f'], { encoding: 'utf8' });
+            (0, child_process_1.spawnSync)('reg', ['delete', winDeveloperManifestSubkey(entry.guid), '/f'], { encoding: 'utf8' });
         }
         else if (process.platform === 'darwin') {
             const target = macWefPath(entry.macContainer, entry.guid);

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

@@ -112,16 +112,15 @@ function normalizeAiHubProjectList(projects, currentProjectPath, options = {}) {
     const byPath = new Map();
     const currentCanonical = currentProjectPath ? canonicalProjectPath(currentProjectPath) : null;
     const removedKeys = new Set(normalizeRemovedProjectPaths(options.removedProjectPaths));
-    const add = (entry, isCurrent = false) => {
+    const add = (entry) => {
         if (!entry)
             return;
         const displayPath = normalizeProjectPath(entry.folderPath);
         const dedupKey = canonicalProjectPath(displayPath);
-        // Issue #788: the current project is always shown in its own workspace, even when
-        // tombstoned (#719 never-empty Hub). This is a display override ONLY — the tombstone
-        // is neither erased here nor in persistence, so switching away re-hides the project
-        // and no subsequent add can resurrect it.
-        if (!isCurrent && removedKeys.has(dedupKey))
+        // Issue #1044: tombstoned paths are never shown, even when the path is the active
+        // project. The caller must switch to a different project (or clear projectPath) before
+        // deleting — the server now enforces this only when other projects remain (#719 reverted).
+        if (removedKeys.has(dedupKey))
             return;
         if (!options.includeMissing && dedupKey !== currentCanonical && !projectPathExists(displayPath))
             return;
@@ -129,7 +128,7 @@ function normalizeAiHubProjectList(projects, currentProjectPath, options = {}) {
         byPath.set(dedupKey, existing ? { ...existing, ...entry, folderPath: existing.folderPath } : { ...entry, folderPath: displayPath });
     };
     if (currentProjectPath)
-        add(normalizeProjectEntry({ folderPath: currentProjectPath }, currentProjectPath), true);
+        add(normalizeProjectEntry({ folderPath: currentProjectPath }, currentProjectPath));
     for (const project of projects)
         add(normalizeProjectEntry(project));
     return withUniqueProjectIds(Array.from(byPath.values()));