fraim 2.0.154 → 2.0.160

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

@@ -0,0 +1,138 @@
+"use strict";
+/**
+ * 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
+ *          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
+ *          ~/Library/Containers/<bundle>/Data/Documents/wef/<guid>.xml
+ *
+ * NOTE: the manifest XML itself must be ASCII-clean (no smart quotes, em/en
+ * dashes, or BOM) or Office's parser hard-fails with -1072894428 and the pane
+ * silently never appears. See project_rules.md.
+ *
+ * Both paths are non-admin and survive app updates (keyed by manifest GUID).
+ * Safe to call multiple times — idempotent.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSideloaded = isSideloaded;
+exports.sideloadManifest = sideloadManifest;
+exports.removeSideload = removeSideload;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const child_process_1 = require("child_process");
+const WEF_DEVELOPER_KEY = 'HKCU\\SOFTWARE\\Microsoft\\Office\\16.0\\WEF\\Developer';
+const MANIFESTS = [
+    {
+        guid: 'd1090951-50cf-4cf2-9d12-b0f8541d265c',
+        candidates: (base) => [
+            path_1.default.resolve(base, 'extensions/office-word/manifest.xml'),
+            path_1.default.resolve(__dirname, '..', '..', 'extensions/office-word/manifest.xml'),
+            path_1.default.resolve(__dirname, '..', '..', '..', 'extensions/office-word/manifest.xml'),
+        ],
+        macContainer: 'com.microsoft.Word',
+    },
+    {
+        guid: 'e7a3c812-91fd-4b2e-8c15-d4f6a903b71e',
+        candidates: (base) => [
+            path_1.default.resolve(base, 'public/ai-hub/powerpoint-taskpane/manifest.xml'),
+            path_1.default.resolve(__dirname, '..', '..', 'public/ai-hub/powerpoint-taskpane/manifest.xml'),
+            path_1.default.resolve(__dirname, '..', '..', '..', 'public/ai-hub/powerpoint-taskpane/manifest.xml'),
+        ],
+        macContainer: 'com.microsoft.Powerpoint',
+    },
+];
+function resolveManifestPath(entry, projectPath) {
+    return entry.candidates(projectPath).find(c => fs_1.default.existsSync(c)) ?? null;
+}
+function macWefPath(container, guid) {
+    return path_1.default.join(os_1.default.homedir(), 'Library', 'Containers', container, 'Data', 'Documents', 'wef', `${guid}.xml`);
+}
+// ---------------------------------------------------------------------------
+// Windows registry helpers
+// ---------------------------------------------------------------------------
+function winRegisteredValue(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 null;
+    const idx = line.indexOf('REG_SZ');
+    return line.slice(idx + 'REG_SZ'.length).trim() || null;
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/** Returns true when ALL manifests are sideloaded with the correct value. */
+function isSideloaded() {
+    return MANIFESTS.every(m => isManifestSideloaded(m));
+}
+function isManifestSideloaded(m) {
+    if (process.platform === 'win32') {
+        const value = winRegisteredValue(m.guid);
+        // Must be a real file path that exists — a URL or a stale/missing path
+        // means we have NOT correctly sideloaded and should re-register.
+        return !!value && !/^https?:\/\//i.test(value) && fs_1.default.existsSync(value);
+    }
+    if (process.platform === 'darwin')
+        return fs_1.default.existsSync(macWefPath(m.macContainer, m.guid));
+    return false;
+}
+/**
+ * Sideloads all manifests. Returns ok:true if every manifest was registered.
+ * Returns ok:false with the first failure reason.
+ */
+function sideloadManifest(projectPath) {
+    for (const entry of MANIFESTS) {
+        const manifestPath = resolveManifestPath(entry, projectPath);
+        if (!manifestPath) {
+            return { ok: false, reason: `Manifest not found for GUID ${entry.guid} — check extensions/office-word/ and public/ai-hub/powerpoint-taskpane/` };
+        }
+        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', manifestPath, '/f',
+            ], { encoding: 'utf8' });
+            if (r.status !== 0)
+                return { ok: false, reason: r.stderr || `reg add failed for ${entry.guid}` };
+            continue;
+        }
+        if (process.platform === 'darwin') {
+            const dest = macWefPath(entry.macContainer, entry.guid);
+            try {
+                fs_1.default.mkdirSync(path_1.default.dirname(dest), { recursive: true });
+                fs_1.default.copyFileSync(manifestPath, dest);
+            }
+            catch (err) {
+                return { ok: false, reason: String(err) };
+            }
+            continue;
+        }
+        return { ok: false, reason: `Unsupported platform: ${process.platform}` };
+    }
+    return { ok: true };
+}
+/** Removes all sideloaded manifests. */
+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' });
+        }
+        else if (process.platform === 'darwin') {
+            const target = macWefPath(entry.macContainer, entry.guid);
+            if (fs_1.default.existsSync(target))
+                fs_1.default.unlinkSync(target);
+        }
+    }
+}

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

@@ -0,0 +1,239 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenClawAiHubBridge = void 0;
+const express_1 = __importDefault(require("express"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const axios_1 = __importDefault(require("axios"));
+function lastMessage(messages, role) {
+    return [...messages].reverse().find((message) => message.role === role);
+}
+function buildStatusLine(run) {
+    const status = run.status.toUpperCase();
+    const phase = run.currentPhase ? ` | phase: ${run.currentPhase}` : '';
+    return `${status} | ${run.jobId} | ${run.hostId}${phase}`;
+}
+function buildStagesLine(run) {
+    if (!run.stages?.length)
+        return null;
+    const line = run.stages
+        .map((stage) => {
+        const marker = stage.state === 'done' ? '[done]' : stage.state === 'current' ? '[now]' : '[todo]';
+        return `${marker} ${stage.label}`;
+    })
+        .join(' | ');
+    return line || null;
+}
+function buildBridgeReply(run) {
+    const replyParts = [buildStatusLine(run)];
+    const employee = lastMessage(run.messages, 'employee');
+    if (employee?.text)
+        replyParts.push(employee.text);
+    const stages = buildStagesLine(run);
+    if (stages)
+        replyParts.push(`Stages: ${stages}`);
+    return replyParts.join('\n\n');
+}
+class OpenClawAiHubBridge {
+    constructor(options) {
+        this.app = (0, express_1.default)();
+        this.threads = new Map();
+        this.api = axios_1.default.create({
+            baseURL: options.hubBaseUrl.replace(/\/$/, ''),
+            timeout: 5000,
+            validateStatus: () => true,
+        });
+        this.defaultProjectPath = options.defaultProjectPath;
+        this.defaultHostId = options.defaultHostId || 'codex';
+        this.defaultJobId = options.defaultJobId;
+        this.pollingIntervalMs = options.pollingIntervalMs ?? 40;
+        this.pollingTimeoutMs = options.pollingTimeoutMs ?? 4000;
+        this.threadStatePath = options.threadStatePath ? path_1.default.resolve(options.threadStatePath) : undefined;
+        this.missingJobReplyText = options.missingJobReplyText || 'Send /fraim <job-id> <request> to start a FRAIM thread.';
+        this.loadThreadState();
+        this.app.use(express_1.default.json());
+        this.registerRoutes();
+    }
+    async start(port) {
+        if (this.httpServer)
+            return;
+        await new Promise((resolve) => {
+            this.httpServer = this.app.listen(port, '127.0.0.1', () => resolve());
+        });
+    }
+    async stop() {
+        if (!this.httpServer)
+            return;
+        await new Promise((resolve, reject) => {
+            this.httpServer?.close((error) => (error ? reject(error) : resolve()));
+        });
+        this.httpServer = undefined;
+    }
+    registerRoutes() {
+        this.app.get('/api/openclaw-bridge/health', (_req, res) => {
+            res.json({ status: 'ok', service: 'openclaw-ai-hub-bridge', threadCount: this.threads.size });
+        });
+        this.app.get('/api/openclaw-bridge/threads', async (req, res) => {
+            try {
+                const channelId = String(req.query.channelId || 'telegram').trim();
+                const threadId = String(req.query.threadId || '').trim();
+                if (!threadId)
+                    return res.status(400).json({ error: 'threadId is required.' });
+                const state = this.threads.get(this.threadKey(channelId, threadId));
+                if (!state)
+                    return res.status(404).json({ error: 'Thread not found.' });
+                const run = await this.fetchRun(state.runId);
+                return res.json(this.presentThread(state, run));
+            }
+            catch (error) {
+                return res.status(500).json({ error: error instanceof Error ? error.message : 'Could not load thread.' });
+            }
+        });
+        this.app.post('/api/openclaw-bridge/messages', async (req, res) => {
+            try {
+                const inbound = this.normalizeInbound(req.body);
+                if (!inbound.threadId)
+                    return res.status(400).json({ error: 'threadId is required.' });
+                if (!inbound.text)
+                    return res.status(400).json({ error: 'text is required.' });
+                const key = this.threadKey(inbound.channelId, inbound.threadId);
+                let state = this.threads.get(key);
+                let run;
+                const startedNewRun = !state;
+                if (!state) {
+                    const hostId = inbound.hostId || this.defaultHostId;
+                    const projectPath = inbound.projectPath || this.defaultProjectPath;
+                    const jobId = inbound.jobId || this.defaultJobId;
+                    const start = await this.api.post('/api/ai-hub/runs', {
+                        projectPath,
+                        hostId,
+                        ...(jobId ? { jobId } : {}),
+                        instructions: inbound.text,
+                    });
+                    if (start.status !== 201) {
+                        const errorText = typeof start.data?.error === 'string' ? start.data.error : '';
+                        if (!jobId && /choose a fraim job/i.test(errorText)) {
+                            return res.json({
+                                ok: true,
+                                startedNewRun: false,
+                                thread: null,
+                                outboundMessages: [{ text: this.missingJobReplyText }],
+                            });
+                        }
+                        return res.status(start.status || 400).json(start.data);
+                    }
+                    run = start.data;
+                    state = {
+                        channelId: inbound.channelId,
+                        threadId: inbound.threadId,
+                        runId: run.id,
+                        hostId,
+                        jobId: run.jobId,
+                        projectPath,
+                        lastSeenAt: new Date().toISOString(),
+                    };
+                    this.threads.set(key, state);
+                    this.persistThreadState();
+                }
+                else {
+                    const continued = await this.api.post(`/api/ai-hub/runs/${state.runId}/messages`, {
+                        instructions: inbound.text,
+                    });
+                    if (continued.status !== 200) {
+                        return res.status(continued.status || 400).json(continued.data);
+                    }
+                    run = continued.data;
+                    state.lastSeenAt = new Date().toISOString();
+                    this.persistThreadState();
+                }
+                const settled = await this.waitForSettlement(run.id);
+                return res.json({
+                    ok: true,
+                    startedNewRun,
+                    thread: this.presentThread(state, settled),
+                    outboundMessages: [{ text: buildBridgeReply(settled) }],
+                });
+            }
+            catch (error) {
+                return res.status(500).json({ error: error instanceof Error ? error.message : 'Could not process message.' });
+            }
+        });
+    }
+    normalizeInbound(body) {
+        const context = body.context || {};
+        const metadata = context.metadata || {};
+        const metaThreadId = typeof metadata.threadId === 'string' ? metadata.threadId : null;
+        const metaChatId = typeof metadata.chatId === 'string' ? metadata.chatId : null;
+        const metaSenderId = typeof metadata.senderId === 'string' ? metadata.senderId : null;
+        return {
+            ...body,
+            channelId: String(body.channelId || context.channelId || 'telegram').trim(),
+            threadId: String(body.threadId || context.threadId || metaThreadId || body.chatId || body.senderId || metaChatId || metaSenderId || '').trim(),
+            text: String(body.text || context.content || '').trim(),
+        };
+    }
+    async fetchRun(runId) {
+        const response = await this.api.get(`/api/ai-hub/runs/${runId}`);
+        if (response.status !== 200) {
+            throw new Error(`AI Hub returned ${response.status} while loading run ${runId}.`);
+        }
+        return response.data;
+    }
+    async waitForSettlement(runId) {
+        const startedAt = Date.now();
+        while (Date.now() - startedAt < this.pollingTimeoutMs) {
+            const run = await this.fetchRun(runId);
+            if (run.status !== 'running')
+                return run;
+            await new Promise((resolve) => setTimeout(resolve, this.pollingIntervalMs));
+        }
+        return this.fetchRun(runId);
+    }
+    presentThread(state, run) {
+        return {
+            channelId: state.channelId,
+            threadId: state.threadId,
+            runId: state.runId,
+            hostId: state.hostId,
+            jobId: state.jobId,
+            projectPath: state.projectPath,
+            status: run.status,
+            currentPhase: run.currentPhase || null,
+            stages: run.stages || [],
+            totals: run.totals || null,
+            latestManagerMessage: lastMessage(run.messages, 'manager')?.text || null,
+            latestEmployeeMessage: lastMessage(run.messages, 'employee')?.text || null,
+            transcript: run.messages.map((message) => ({
+                role: message.role,
+                text: message.text,
+                createdAt: message.createdAt,
+            })),
+        };
+    }
+    threadKey(channelId, threadId) {
+        return `${channelId}:${threadId}`;
+    }
+    loadThreadState() {
+        if (!this.threadStatePath || !fs_1.default.existsSync(this.threadStatePath))
+            return;
+        try {
+            const raw = JSON.parse(fs_1.default.readFileSync(this.threadStatePath, 'utf8'));
+            for (const thread of raw.threads || []) {
+                this.threads.set(this.threadKey(thread.channelId, thread.threadId), thread);
+            }
+        }
+        catch {
+            // Ignore corrupt or partial state and start fresh.
+        }
+    }
+    persistThreadState() {
+        if (!this.threadStatePath)
+            return;
+        fs_1.default.mkdirSync(path_1.default.dirname(this.threadStatePath), { recursive: true });
+        fs_1.default.writeFileSync(this.threadStatePath, JSON.stringify({ threads: [...this.threads.values()] }, null, 2), 'utf8');
+    }
+}
+exports.OpenClawAiHubBridge = OpenClawAiHubBridge;