fraim-hub 2.0.324 → 2.0.326

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

@@ -17,22 +17,19 @@ const conversation_search_projection_1 = require("./conversation-search-projecti
 // They are NOT filesystem paths and must never be passed through path.resolve.
 exports.MANAGER_SCOPE_KEY = '@manager';
 exports.COMPANY_SCOPE_KEY = '@company';
-// Fields stripped from a header (the light shape the list UI renders). Everything else
-// (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',
-    'handoffSummary',
-    '_bodyLoaded',
-    '_stopping',
-    '_priorEvents',
-    '_priorMessages',
+// Issue #1765: public list metadata is opt-in. These fields feed the shared Projects,
+// Manager and Company rail identity, ordering, status, trigger and delegation controls
+// (buildAreaRunButton / conversationUiState in public/ai-hub/script.js). New body fields
+// must never silently enlarge every list response or short-circuit lazy hydration.
+const HEADER_FIELDS = [
+    'id', 'projectPath', 'scope', 'invokedArea', 'title', 'jobId', 'jobTitle',
+    'agentName', 'configuredAgentId', 'configuredAgentLabel', 'baseHostId', 'personaKey',
+    'runId', 'status', 'pauseReason', 'createdAt', 'lastUpdatedAt', 'issueNumber',
+    'sourceTrigger', 'blocked', 'stopped', 'reviewApproved', 'compareMode', 'compareRunId',
+    'managedByRunId', 'managedByPersonaKey', 'managedReviewStatus', 'delegationTaskId',
+    'humanCoachingDisabled', 'personaSnapshot', 'reviewHandoff',
 ];
-const HEADER_OMITTED_FIELD_SET = new Set(HEADER_OMITTED_FIELDS);
+const HEADER_FIELD_SET = new Set([...HEADER_FIELDS, 'personaSnapshot', 'delegation', 'reviewHandoff']);
 /**
  * Issue #708: resolve the conversation store bucket key for a given scope.
  * - 'manager'/'company' → a stable sentinel key (project-independent home).
@@ -361,18 +358,23 @@ function newestFirst(a, b) {
     return timestampValue(b.lastUpdatedAt) - timestampValue(a.lastUpdatedAt);
 }
 function toHeader(conv) {
-    const header = { ...conv };
-    const delegation = compactDelegationForHeader(header.delegation);
-    for (const field of HEADER_OMITTED_FIELDS)
-        delete header[field];
-    if (delegation)
-        header.delegation = delegation;
-    for (const field of Object.keys(header)) {
-        if (field.startsWith('_'))
-            delete header[field];
+    const header = pickHeaderFields(conv, HEADER_FIELDS);
+    if (conv.delegation !== undefined) {
+        header.delegation = compactDelegationForHeader(conv.delegation) ?? null;
     }
     return header;
 }
+function pickHeaderFields(raw, fields) {
+    const result = {};
+    if (!raw || typeof raw !== 'object')
+        return result;
+    const value = raw;
+    for (const field of fields) {
+        if (Object.prototype.hasOwnProperty.call(value, field))
+            result[field] = value[field];
+    }
+    return result;
+}
 function compactDelegationForHeader(raw) {
     if (!raw || typeof raw !== 'object')
         return undefined;
@@ -402,15 +404,15 @@ function compactDelegationForHeader(raw) {
     };
 }
 function headerNeedsSanitization(header) {
-    const value = header;
-    return Object.keys(value).some((field) => HEADER_OMITTED_FIELD_SET.has(field) || field.startsWith('_'));
+    return Object.keys(header).some((field) => !HEADER_FIELD_SET.has(field));
 }
 function sanitizeBucketIndex(index) {
     let changed = false;
     const headers = index.headers.map((header) => {
+        const compact = toHeader(header);
         if (headerNeedsSanitization(header))
             changed = true;
-        return toHeader(header);
+        return compact;
     }).sort(newestFirst);
     const activeId = index.activeId && headers.some((header) => header.id === index.activeId) ? index.activeId : null;
     if (activeId !== index.activeId)

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

@@ -603,7 +603,7 @@ function stringifyMentorCallArgs(rawArgs) {
 }
 function resultTextFromValue(value) {
     if (typeof value === 'string')
-        return value.trim() || null;
+        return value.trim() ? value : null;
     if (Array.isArray(value)) {
         const parts = value
             .map((entry) => resultTextFromValue(entry))
@@ -693,6 +693,9 @@ function parseMicroEventsSignal(hostId, line) {
         }
         else if (itemType !== 'agent_message' && itemType !== 'error') {
             events.push(microEventFromNonMentorToolCall(item) || { kind: 'tool_call', text: itemType });
+            const output = resultTextFromValue(item.result ?? item.output ?? item.aggregated_output);
+            if (output)
+                events.push({ kind: 'tool_result', text: output });
         }
     }
     if (item && item.type === 'mcp_tool_call' && isFraimTool(readToolName(item), 'seekMentoring')) {
@@ -724,7 +727,7 @@ function parseMicroEventsSignal(hostId, line) {
         }
         else if (root.type === 'tool.execution_complete') {
             const resultText = resultTextFromValue(data.result ?? data.output ?? data.content);
-            events.push({ kind: 'tool_call', text: resultText ? `${rootType}: ${resultText}` : rootType });
+            events.push({ kind: 'tool_result', text: resultText || rootType });
             rootTypeHandled = true;
         }
     }

package/dist/src/ai-hub/raw-event-log-store.js

@@ -6,16 +6,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AiHubRawEventLogStore = void 0;
 const node_crypto_1 = __importDefault(require("node:crypto"));
 const node_fs_1 = __importDefault(require("node:fs"));
-const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
+const types_1 = require("./types");
 const project_fraim_paths_1 = require("../core/utils/project-fraim-paths");
 function defaultRawEventLogRoot() {
-    try {
-        return node_path_1.default.join((0, project_fraim_paths_1.getUserFraimDirPath)(), 'ai-hub-event-logs');
-    }
-    catch {
-        return node_path_1.default.join(node_os_1.default.homedir(), '.fraim', 'ai-hub-event-logs');
-    }
+    return node_path_1.default.join((0, project_fraim_paths_1.getUserFraimDirPath)(), 'ai-hub-event-logs');
 }
 function hashSegment(value, length = 24) {
     return node_crypto_1.default.createHash('sha256').update(value || 'unknown').digest('hex').slice(0, length);
@@ -23,20 +18,39 @@ function hashSegment(value, length = 24) {
 function safeRunFileName(runId) {
     return `${hashSegment(runId, 40)}.jsonl`;
 }
+function parseEntry(line) {
+    try {
+        const value = JSON.parse(line);
+        if (typeof value.text !== 'string' || !['stdout', 'stderr', 'system'].includes(value.channel))
+            return null;
+        return { createdAt: typeof value.createdAt === 'string' ? value.createdAt : new Date(0).toISOString(), channel: value.channel, text: value.text,
+            ...(types_1.AI_HUB_MICRO_EVENT_KINDS.includes(value.hubKind) ? { hubKind: value.hubKind } : {}),
+            ...(typeof value.hostId === 'string' ? { hostId: value.hostId } : {}),
+            ...(Array.isArray(value.microEvents) ? { microEvents: value.microEvents.filter((event) => event && types_1.AI_HUB_MICRO_EVENT_KINDS.includes(event.kind) && typeof event.text === 'string') } : {}) };
+    }
+    catch {
+        return null;
+    }
+}
 class AiHubRawEventLogStore {
     constructor(rootDir = defaultRawEventLogRoot()) {
         this.rootDir = node_path_1.default.resolve(rootDir);
     }
     append(bucketKey, conversationId, runId, entry) {
         const dir = node_path_1.default.join(this.rootDir, hashSegment(bucketKey), hashSegment(conversationId));
-        node_fs_1.default.mkdirSync(dir, { recursive: true });
         const logPath = node_path_1.default.join(dir, safeRunFileName(runId));
         const metaPath = `${logPath}.meta.json`;
+        if (!this.resolveReadableLogPath(logPath) || !this.resolveReadableLogPath(metaPath))
+            throw new Error('Event archive path is outside its root');
+        node_fs_1.default.mkdirSync(dir, { recursive: true });
         const createdAt = entry.createdAt || new Date().toISOString();
         const line = {
             createdAt,
             channel: entry.channel,
             text: entry.text,
+            ...(entry.hubKind ? { hubKind: entry.hubKind } : {}),
+            ...(entry.hostId ? { hostId: entry.hostId } : {}),
+            ...(entry.microEvents ? { microEvents: entry.microEvents } : {}),
         };
         node_fs_1.default.appendFileSync(logPath, `${JSON.stringify(line)}\n`, 'utf8');
         const prior = this.readMeta(metaPath, runId, logPath);
@@ -48,6 +62,8 @@ class AiHubRawEventLogStore {
             eventCount: prior.eventCount + 1,
             createdAt: prior.createdAt || createdAt,
             updatedAt: createdAt,
+            ownerPid: process.pid,
+            ...(entry.hostId || prior.hostId ? { hostId: entry.hostId || prior.hostId } : {}),
             ...(prior.truncated ? { truncated: true } : {}),
         };
         node_fs_1.default.writeFileSync(metaPath, `${JSON.stringify(ref, null, 2)}\n`, 'utf8');
@@ -60,22 +76,90 @@ class AiHubRawEventLogStore {
         const lines = node_fs_1.default.readFileSync(logPath, 'utf8').split(/\r?\n/).filter(Boolean);
         const entries = [];
         for (const line of lines) {
+            const entry = parseEntry(line);
+            if (entry)
+                entries.push(entry);
+        }
+        return entries;
+    }
+    markEnded(ref, endedAt) {
+        const logPath = this.resolveReadableLogPath(ref.path);
+        if (!logPath || !node_fs_1.default.existsSync(logPath))
+            return ref;
+        if (!this.resolveReadableLogPath(`${logPath}.meta.json`))
+            throw new Error('Event archive metadata is outside its root');
+        const next = { ...this.readMeta(`${logPath}.meta.json`, ref.runId, logPath), endedAt };
+        delete next.ownerPid;
+        node_fs_1.default.writeFileSync(`${logPath}.meta.json`, `${JSON.stringify(next, null, 2)}\n`, 'utf8');
+        return next;
+    }
+    /** Read display-ready entries in chronological order without reconstructing host output. */
+    async readMicroEvents(refs) {
+        const events = [];
+        let missingArchives = 0;
+        let legacyArchives = 0;
+        for (const ref of refs) {
+            const logPath = this.resolveReadableLogPath(ref.path);
+            if (!logPath) {
+                missingArchives++;
+                continue;
+            }
+            let size;
+            try {
+                size = (await node_fs_1.default.promises.stat(logPath)).size;
+            }
+            catch (error) {
+                if (error.code === 'ENOENT') {
+                    missingArchives++;
+                    continue;
+                }
+                throw error;
+            }
+            if (!size)
+                continue;
+            let hasLegacyEntries = false;
+            // Snapshot the size; only newline-terminated records are committed. The
+            // stream owns its descriptor and decodes UTF-8 across chunk boundaries.
+            const stream = node_fs_1.default.createReadStream(logPath, { encoding: 'utf8', end: size - 1 });
+            let pending = '';
+            let lineNumber = 0;
             try {
-                const parsed = JSON.parse(line);
-                if (typeof parsed.text === 'string' &&
-                    (parsed.channel === 'stdout' || parsed.channel === 'stderr' || parsed.channel === 'system')) {
-                    entries.push({
-                        createdAt: typeof parsed.createdAt === 'string' ? parsed.createdAt : new Date(0).toISOString(),
-                        channel: parsed.channel,
-                        text: parsed.text,
-                    });
+                for await (const chunk of stream) {
+                    const lines = (pending + chunk).split('\n');
+                    pending = lines.pop();
+                    for (const line of lines) {
+                        const entry = parseEntry(line);
+                        const id = `${ref.runId}:${lineNumber++}`;
+                        if (!entry)
+                            continue;
+                        const displayed = entry.hubKind ? [{ kind: entry.hubKind, text: entry.text }] : entry.microEvents;
+                        if (!displayed) {
+                            hasLegacyEntries = true;
+                            continue;
+                        }
+                        displayed.forEach((event, index) => events.push({
+                            id: `${id}:${index}`, kind: event.kind, text: event.text,
+                            channel: event.kind === 'manager_input' ? 'manager' : entry.channel, createdAt: entry.createdAt,
+                        }));
+                    }
+                    await new Promise((resolve) => setImmediate(resolve));
                 }
             }
-            catch {
-                // Corrupt diagnostic lines are ignored; callers fall back to other session sources.
+            catch (error) {
+                if (error.code === 'ENOENT') {
+                    missingArchives++;
+                    continue;
+                }
+                throw error;
             }
+            finally {
+                stream.destroy();
+            }
+            if (hasLegacyEntries)
+                legacyArchives++;
         }
-        return entries;
+        events.sort((a, b) => Date.parse(a.createdAt) - Date.parse(b.createdAt));
+        return { events, archiveAvailable: refs.length > missingArchives, missingArchives, legacyArchives };
     }
     readMeta(metaPath, runId, logPath) {
         if (!node_fs_1.default.existsSync(metaPath)) {
@@ -90,6 +174,9 @@ class AiHubRawEventLogStore {
                 eventCount: typeof parsed.eventCount === 'number' ? parsed.eventCount : 0,
                 createdAt: typeof parsed.createdAt === 'string' ? parsed.createdAt : '',
                 updatedAt: typeof parsed.updatedAt === 'string' ? parsed.updatedAt : '',
+                ...(typeof parsed.endedAt === 'string' ? { endedAt: parsed.endedAt } : {}),
+                ...(typeof parsed.ownerPid === 'number' ? { ownerPid: parsed.ownerPid } : {}),
+                ...(typeof parsed.hostId === 'string' ? { hostId: parsed.hostId } : {}),
                 ...(parsed.truncated ? { truncated: true } : {}),
             };
         }
@@ -104,7 +191,30 @@ class AiHubRawEventLogStore {
         const rootPrefix = `${this.rootDir}${node_path_1.default.sep}`;
         const comparableResolved = process.platform === 'win32' ? resolved.toLowerCase() : resolved;
         const comparableRootPrefix = process.platform === 'win32' ? rootPrefix.toLowerCase() : rootPrefix;
-        return comparableResolved.startsWith(comparableRootPrefix) ? resolved : null;
+        if (!comparableResolved.startsWith(comparableRootPrefix))
+            return null;
+        // A symlink inside the archive root must not grant access outside it.
+        try {
+            const real = node_fs_1.default.realpathSync(resolved);
+            const root = node_fs_1.default.realpathSync(this.rootDir) + node_path_1.default.sep;
+            return (process.platform === 'win32' ? real.toLowerCase().startsWith(root.toLowerCase()) : real.startsWith(root)) ? real : null;
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                // Missing leaves still inherit the confinement of their nearest real
+                // parent, including Windows junctions inside a hashed bucket directory.
+                let parent = node_path_1.default.dirname(resolved);
+                while (!node_fs_1.default.existsSync(parent) && parent !== node_path_1.default.dirname(parent))
+                    parent = node_path_1.default.dirname(parent);
+                if (!node_fs_1.default.existsSync(this.rootDir))
+                    return resolved;
+                const realParent = node_fs_1.default.realpathSync(parent);
+                const realRoot = node_fs_1.default.realpathSync(this.rootDir);
+                const relative = node_path_1.default.relative(realRoot, realParent);
+                return relative === '' || (!relative.startsWith('..') && !node_path_1.default.isAbsolute(relative)) ? resolved : null;
+            }
+            throw error;
+        }
     }
 }
 exports.AiHubRawEventLogStore = AiHubRawEventLogStore;