fraim-framework 2.0.184 → 2.0.186

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

@@ -21,15 +21,6 @@ let isQuitting = false; // distinguishes window-close (→ tray) from app-quit
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
-function tryCreateDbService() {
-    try {
-        const loaded = require('../fraim/db-service');
-        return new loaded.FraimDbService();
-    }
-    catch {
-        return undefined;
-    }
-}
 function preferredWindowSize() {
     const { workAreaSize } = electron_1.screen.getPrimaryDisplay();
     return {
@@ -255,7 +246,8 @@ async function launchDesktopShell(options) {
     const certBundle = await (0, cert_store_1.loadOrCreateCert)();
     server = new server_1.AiHubServer({
         projectPath: options.projectPath,
-        dbService: tryCreateDbService(),
+        // Issue #701: no local DB. Persona/manager-team state resolves through the hosted
+        // server via the Hub's default remote gateway (authenticated by the user's API key).
         httpsPort,
         certBundle,
         folderPicker: async () => {

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

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createHubEvent = exports.createHubMessage = exports.ScriptedHostRuntime = exports.FakeHostRuntime = exports.CliHostRuntime = void 0;
 exports.parseSeekMentoringSignal = parseSeekMentoringSignal;
+exports.parseFraimJobLoadSignal = parseFraimJobLoadSignal;
 exports.parseUsageSignal = parseUsageSignal;
 exports.parseAgentIdentitySignal = parseAgentIdentitySignal;
 exports.detectEmployees = detectEmployees;
@@ -91,6 +92,58 @@ function parseSeekMentoringSignal(line) {
     }
     return null;
 }
+// Issue #710: extract the job name from a get_fraim_job tool call. This
+// is structured known-job evidence; the server still validates the job id
+// against the catalog before promoting any run.
+function parseFraimJobLoadSignal(line) {
+    if (!line.includes('get_fraim_job'))
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(line);
+    }
+    catch {
+        return null;
+    }
+    if (typeof parsed !== 'object' || parsed === null)
+        return null;
+    const obj = parsed;
+    // Codex shape: { type: 'item.started' | 'item.completed', item:
+    // { type: 'mcp_tool_call', tool: 'get_fraim_job', arguments: { job } } }.
+    if ((obj.type === 'item.started' || obj.type === 'item.completed') &&
+        typeof obj.item === 'object' && obj.item !== null) {
+        const item = obj.item;
+        const tool = typeof item.tool === 'string' ? item.tool : '';
+        if (item.type === 'mcp_tool_call' && isGetFraimJobTool(tool)) {
+            const sig = readFraimJobFromArgs(item.arguments);
+            if (sig)
+                return sig;
+        }
+    }
+    // Claude Code shape: tool_use blocks live inside message.content with
+    // an MCP-prefixed name such as mcp__fraim__get_fraim_job.
+    const candidates = [obj];
+    if (Array.isArray(obj.content))
+        candidates.push(...obj.content);
+    if (typeof obj.message === 'object' && obj.message !== null) {
+        const msg = obj.message;
+        if (Array.isArray(msg.content))
+            candidates.push(...msg.content);
+    }
+    for (const candidate of candidates) {
+        if (typeof candidate !== 'object' || candidate === null)
+            continue;
+        const c = candidate;
+        const isToolUse = c.type === 'tool_use' || c.type === 'function_call';
+        const nameField = typeof c.name === 'string' ? c.name : (typeof c.tool_name === 'string' ? c.tool_name : '');
+        if (!isToolUse || !isGetFraimJobTool(nameField))
+            continue;
+        const sig = readFraimJobFromArgs(c.input || c.arguments || c.parameters);
+        if (sig)
+            return sig;
+    }
+    return null;
+}
 // Issue #347 — extract per-turn usage from the host's JSON stream.
 // Codex: `{"type":"turn.completed","usage":{input_tokens, cached_input_tokens, output_tokens, reasoning_output_tokens}}`.
 // Claude Code: `{"type":"result", ..., "usage":{input_tokens, output_tokens, cache_creation_input_tokens, cache_read_input_tokens}, "total_cost_usd": ...}`.
@@ -256,6 +309,41 @@ function readAgentFromArgs(args) {
         return null;
     return { agentName, agentModel };
 }
+function isGetFraimJobTool(toolName) {
+    return toolName === 'get_fraim_job' ||
+        toolName === 'mcp__fraim__get_fraim_job' ||
+        toolName.endsWith('get_fraim_job');
+}
+function readFraimJobFromArgs(rawArgs) {
+    const args = normalizeToolArgs(rawArgs);
+    if (!args)
+        return null;
+    const rawJob = stringValue(args.job) ||
+        stringValue(args.jobName) ||
+        stringValue(args.job_id) ||
+        stringValue(args.name);
+    const jobId = rawJob.trim().toLowerCase();
+    if (!jobId)
+        return null;
+    return { jobId, source: 'get_fraim_job' };
+}
+function normalizeToolArgs(rawArgs) {
+    if (rawArgs && typeof rawArgs === 'object' && !Array.isArray(rawArgs)) {
+        return rawArgs;
+    }
+    if (typeof rawArgs !== 'string' || rawArgs.trim().length === 0)
+        return null;
+    try {
+        const parsed = JSON.parse(rawArgs);
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
 function numberOrNull(v) {
     return typeof v === 'number' && Number.isFinite(v) ? v : null;
 }
@@ -987,17 +1075,24 @@ function parseHostLine(hostId, line) {
     const trimmed = line.trim();
     if (!trimmed)
         return {};
-    // Issue #347: scan every line for the three signals the Hub UI cares
-    // about — seekMentoring (drives the tracker), turn-level usage
-    // (drives the totals tokens/cost), and the agent identity from
-    // fraim_connect (used to look up cost when the host doesn't emit it).
+    // Scan every line for structured signals the Hub UI cares about:
+    // seekMentoring (tracker), get_fraim_job (job identity promotion),
+    // turn-level usage (totals), and fraim_connect agent identity
+    // (cost lookup when the host doesn't emit it).
     const seekMentoring = parseSeekMentoringSignal(trimmed);
+    const fraimJob = parseFraimJobLoadSignal(trimmed);
     const usage = parseUsageSignal(trimmed);
     const agentIdentity = parseAgentIdentitySignal(trimmed);
     const withSignal = (event) => {
-        if (!seekMentoring && !usage && !agentIdentity)
+        if (!seekMentoring && !fraimJob && !usage && !agentIdentity)
             return event;
-        return { ...event, ...(seekMentoring ? { seekMentoring } : {}), ...(usage ? { usage } : {}), ...(agentIdentity ? { agentIdentity } : {}) };
+        return {
+            ...event,
+            ...(seekMentoring ? { seekMentoring } : {}),
+            ...(fraimJob ? { fraimJob } : {}),
+            ...(usage ? { usage } : {}),
+            ...(agentIdentity ? { agentIdentity } : {}),
+        };
     };
     if (hostId === 'codex') {
         try {
@@ -1339,9 +1434,10 @@ class ScriptedHostRuntime {
             { id: 'gemini', label: 'Gemini CLI', available: true, detail: 'Scripted test double.', supportsRaw: true },
             { id: 'copilot', label: 'GitHub Copilot CLI', available: true, detail: 'Scripted test double.', supportsRaw: true },
         ];
-        // Track each active run so the test can emit signals at it. Key is the
-        // sessionId we hand back on startRun; mapping sessionId → handlers
-        // lets emitPhase() reach the right run's onEvent callback.
+        // Track each active run so the test can emit signals at it. The Hub
+        // passes the run id as the requested start session id in test/demo paths;
+        // real resume flows still use the host session id. Resolving by the
+        // supplied id first lets concurrent scripted runs receive targeted events.
         this.handlersBySession = new Map();
         // Tracks runDiscriminant per sessionId so consecutive emitPhase calls
         // can resolve onSuccess routing without each test having to repeat it.
@@ -1352,8 +1448,8 @@ class ScriptedHostRuntime {
     }
     startRun(_hostId, _projectPath, _message, handlers, requestedSessionId) {
         const sessionId = requestedSessionId || (0, crypto_1.randomUUID)();
-        handlers.onEvent({ sessionId, raw: 'scripted-session-start' }, 'system');
         this.handlersBySession.set(sessionId, handlers);
+        handlers.onEvent({ sessionId, raw: 'scripted-session-start' }, 'system');
         return this.spawnDouble();
     }
     continueRun(_hostId, _projectPath, sessionId, _message, handlers) {
@@ -1363,6 +1459,7 @@ class ScriptedHostRuntime {
     }
     startDirectRun(_hostId, _message, _projectPath, handlers, requestedSessionId) {
         const sessionId = requestedSessionId || (0, crypto_1.randomUUID)();
+        this.handlersBySession.set(sessionId, handlers);
         handlers.onEvent({ sessionId, raw: 'scripted-direct-session-start' }, 'system');
         return this.spawnDouble();
     }
@@ -1420,6 +1517,18 @@ class ScriptedHostRuntime {
             },
         }, 'stdout');
     }
+    // Test API — emit the structured job-load signal that get_fraim_job
+    // produces before the first seekMentoring phase call.
+    emitFraimJobLoad(runId, jobId) {
+        const target = this.resolveSession(runId);
+        if (!target)
+            return;
+        target.handlers.onEvent({
+            sessionId: target.sessionId,
+            raw: `scripted-get_fraim_job:${jobId}`,
+            fraimJob: { jobId, source: 'get_fraim_job' },
+        }, 'stdout');
+    }
     // Test API — emit a per-turn usage signal in the normalized shape
     // the server expects. Mirrors what parseUsageSignal would produce
     // from a real host's stream.
@@ -1464,13 +1573,16 @@ class ScriptedHostRuntime {
         this.handlersBySession.clear();
         this.discriminantBySession.clear();
     }
-    // The Hub server keeps its own sessionId map keyed off run.sessionId —
-    // but at the time the test calls emitPhase(runId), we may only have
-    // one handler registered (the latest start). Resolve by sessionId
-    // first, fall back to the most recent registered handler.
-    resolveSession(_runId) {
+    // The Hub passes run.id as the requested session id for scripted starts,
+    // so tests/demo controls can target a specific run even when multiple runs
+    // are active. Fall back to the latest handler for older callers that do not
+    // provide a known id.
+    resolveSession(runId) {
         if (this.handlersBySession.size === 0)
             return null;
+        const direct = this.handlersBySession.get(runId);
+        if (direct)
+            return { sessionId: runId, handlers: direct };
         const entries = [...this.handlersBySession.entries()];
         const [sessionId, handlers] = entries[entries.length - 1];
         return { sessionId, handlers };

package/dist/src/ai-hub/openclaw-bridge.js

@@ -134,6 +134,7 @@ class OpenClawAiHubBridge {
                         jobId: run.jobId,
                         projectPath,
                         lastSeenAt: new Date().toISOString(),
+                        managerTexts: [inbound.text],
                     };
                     this.threads.set(key, state);
                     this.persistThreadState();
@@ -147,6 +148,7 @@ class OpenClawAiHubBridge {
                     }
                     run = continued.data;
                     state.lastSeenAt = new Date().toISOString();
+                    state.managerTexts = [...(state.managerTexts ?? []), inbound.text];
                     this.persistThreadState();
                 }
                 const settled = await this.waitForSettlement(run.id);
@@ -193,6 +195,19 @@ class OpenClawAiHubBridge {
         return this.fetchRun(runId);
     }
     presentThread(state, run) {
+        // The Hub records the invocation it sent as each manager bubble (#696). For a channel
+        // transcript we substitute the user's own words (state.managerTexts, in turn order)
+        // for manager-role messages, so the thread reflects what the user actually typed.
+        const managerTexts = state.managerTexts ?? [];
+        let managerIdx = 0;
+        const transcript = run.messages.map((message) => ({
+            role: message.role,
+            text: message.role === 'manager' && managerIdx < managerTexts.length
+                ? managerTexts[managerIdx++]
+                : message.text,
+            createdAt: message.createdAt,
+        }));
+        const latestManagerMessage = [...transcript].reverse().find((m) => m.role === 'manager')?.text || null;
         return {
             channelId: state.channelId,
             threadId: state.threadId,
@@ -204,13 +219,9 @@ class OpenClawAiHubBridge {
             currentPhase: run.currentPhase || null,
             stages: run.stages || [],
             totals: run.totals || null,
-            latestManagerMessage: lastMessage(run.messages, 'manager')?.text || null,
+            latestManagerMessage,
             latestEmployeeMessage: lastMessage(run.messages, 'employee')?.text || null,
-            transcript: run.messages.map((message) => ({
-                role: message.role,
-                text: message.text,
-                createdAt: message.createdAt,
-            })),
+            transcript,
         };
     }
     threadKey(channelId, threadId) {

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

@@ -0,0 +1,88 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpHubRemoteGateway = void 0;
+exports.resolveFraimRemoteUrl = resolveFraimRemoteUrl;
+const axios_1 = __importDefault(require("axios"));
+function resolveFraimRemoteUrl(explicit) {
+    return (explicit || process.env.FRAIM_REMOTE_URL || 'https://fraim.wellnessatwork.me').replace(/\/+$/, '');
+}
+/**
+ * Default HTTP-backed gateway. Mirrors the ProviderClient axios pattern:
+ * base URL from FRAIM_REMOTE_URL, `x-api-key` auth header, 10s timeout.
+ */
+class HttpHubRemoteGateway {
+    constructor(serverUrl) {
+        this.baseURL = resolveFraimRemoteUrl(serverUrl);
+    }
+    client(apiKey) {
+        return axios_1.default.create({
+            baseURL: this.baseURL,
+            headers: { 'x-api-key': apiKey, 'Content-Type': 'application/json' },
+            timeout: 10000,
+        });
+    }
+    async getPersonaState(apiKey) {
+        if (!apiKey)
+            return null;
+        try {
+            const res = await this.client(apiKey).get('/api/personas/me');
+            return res.data;
+        }
+        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.
+            const status = err?.response?.status;
+            if (status === 401 || status === 404)
+                return null;
+            console.warn('[ai-hub] getPersonaState failed:', err?.message || err);
+            return null;
+        }
+    }
+    async listManagerTeam(apiKey) {
+        if (!apiKey)
+            return [];
+        try {
+            const res = await this.client(apiKey).get('/api/ai-hub/manager-team');
+            const team = (res.data?.team ?? []);
+            return Array.isArray(team) ? team : [];
+        }
+        catch (err) {
+            const status = err?.response?.status;
+            if (status === 401 || status === 404)
+                return [];
+            console.warn('[ai-hub] listManagerTeam failed:', err?.message || err);
+            return [];
+        }
+    }
+    async assignManagerTeam(apiKey, personaKey) {
+        if (!apiKey)
+            return { status: 401, body: { error: 'authentication_required' } };
+        try {
+            const res = await this.client(apiKey).post('/api/ai-hub/manager-team/assign', { personaKey });
+            return { status: res.status, body: res.data };
+        }
+        catch (err) {
+            if (err?.response)
+                return { status: err.response.status, body: err.response.data };
+            console.warn('[ai-hub] assignManagerTeam failed:', err?.message || err);
+            return { status: 500, body: { error: 'internal_error' } };
+        }
+    }
+    async removeManagerTeam(apiKey, personaKey) {
+        if (!apiKey)
+            return;
+        try {
+            await this.client(apiKey).delete(`/api/ai-hub/manager-team/assign/${encodeURIComponent(personaKey)}`);
+        }
+        catch (err) {
+            const status = err?.response?.status;
+            if (status === 401 || status === 404)
+                return;
+            console.warn('[ai-hub] removeManagerTeam failed:', err?.message || err);
+        }
+    }
+}
+exports.HttpHubRemoteGateway = HttpHubRemoteGateway;