noteconnection 1.6.8 → 1.8.0

package/dist/src/routes/data.js

@@ -0,0 +1,267 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerDataRoutes = registerDataRoutes;
+const CrashLogger_1 = require("../backend/utils/CrashLogger");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const index_1 = require("../index");
+const FileLoader_1 = require("../backend/FileLoader");
+function registerDataRoutes(ctx) {
+    const { LOOPBACK_HOST, finalPort, kbRoot, runtimeDataDir, knowledgeLearningPlatform } = ctx;
+    const json = (res, code, data) => {
+        res.writeHead(code, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(data));
+    };
+    const ok = (res, data) => json(res, 200, { success: true, ...data });
+    const fail = (res, error, label) => { console.error(error); CrashLogger_1.CrashLogger.log(error, label); json(res, 500, { success: false, error: String(error) }); };
+    const readBody = (req) => new Promise((resolve, reject) => { const chunks = []; req.on('data', (c) => chunks.push(c)); req.on('end', () => resolve(Buffer.concat(chunks).toString('utf8'))); req.on('error', reject); });
+    const sanitizeTargetName = (target) => String(target || '').replace(/[^a-z0-9_\-]/gi, '_');
+    const generatedAssetPath = (filename) => path.join(runtimeDataDir, filename);
+    const readGeneratedAssetIfExists = async (filename) => {
+        const candidate = generatedAssetPath(filename);
+        try {
+            await fs.promises.access(candidate, fs.constants.F_OK);
+            return candidate;
+        }
+        catch {
+            return null;
+        }
+    };
+    const buildKnowledgeDocumentPayloads = async (target) => {
+        const normalizedTarget = String(target || '').trim();
+        const targetPath = normalizedTarget && normalizedTarget !== 'ALL_FOLDERS'
+            ? path.join(kbRoot, normalizedTarget)
+            : kbRoot;
+        const files = await FileLoader_1.FileLoader.loadFiles(targetPath, ['.md']);
+        return files.map((file) => {
+            const relativePath = path.relative(kbRoot, file.filepath).replace(/\\/g, '/');
+            return {
+                sourcePath: `Knowledge_Base/${relativePath}`.replace(/\/{2,}/g, '/'),
+                content: file.content,
+                language: /[\u4e00-\u9fff]/.test(file.content) ? 'zh' : 'en',
+            };
+        });
+    };
+    const syncKnowledgeWorkspaceForTarget = async (target, reason) => {
+        const documents = await buildKnowledgeDocumentPayloads(target);
+        const result = await knowledgeLearningPlatform.ingestKnowledge({
+            incremental: true,
+            documents,
+            ingestedAt: new Date().toISOString(),
+            relationRecomputeMode: 'incremental',
+        });
+        return {
+            target,
+            reason,
+            documentCount: documents.length,
+            summary: result.summary,
+        };
+    };
+    return [
+        // ── GET routes ──
+        { method: 'GET', path: '/api/content', handler: async (req, res) => {
+                try {
+                    const urlObj = new URL(req.url || '/', `http://${LOOPBACK_HOST}:${finalPort}`);
+                    const requestedPath = urlObj.searchParams.get('path');
+                    if (!requestedPath) {
+                        json(res, 400, { error: 'Missing path parameter' });
+                        return;
+                    }
+                    const decodedPath = decodeURIComponent(requestedPath);
+                    const candidate = path.resolve(kbRoot, decodedPath);
+                    if (!candidate.startsWith(path.resolve(kbRoot))) {
+                        json(res, 403, { error: 'Path traversal denied' });
+                        return;
+                    }
+                    try {
+                        const content = await fs.promises.readFile(candidate, 'utf-8');
+                        json(res, 200, { content });
+                    }
+                    catch (error) {
+                        if (error?.code === 'ENOENT') {
+                            json(res, 404, { error: 'File not found' });
+                            return;
+                        }
+                        throw error;
+                    }
+                }
+                catch (e) {
+                    fail(res, e, 'GET /api/content');
+                }
+            } },
+        { method: 'GET', path: '/api/check-cache', handler: async (req, res) => {
+                try {
+                    const urlObj = new URL(req.url || '/', `http://${LOOPBACK_HOST}:${finalPort}`);
+                    const target = urlObj.searchParams.get('target');
+                    if (!target) {
+                        json(res, 200, null);
+                        return;
+                    }
+                    if (target === 'ALL_FOLDERS') {
+                        const activeJsPath = await readGeneratedAssetIfExists('data.js');
+                        if (!activeJsPath) {
+                            json(res, 200, null);
+                            return;
+                        }
+                        const stat = await fs.promises.stat(activeJsPath);
+                        json(res, 200, { date: stat.mtime.toLocaleString(), size: stat.size, source: 'active' });
+                        return;
+                    }
+                    const targetFile = await readGeneratedAssetIfExists(`data_${sanitizeTargetName(target)}.js`);
+                    if (!targetFile) {
+                        json(res, 200, null);
+                        return;
+                    }
+                    const stat = await fs.promises.stat(targetFile);
+                    json(res, 200, { date: stat.mtime.toLocaleString(), size: stat.size });
+                }
+                catch (e) {
+                    fail(res, e, 'GET /api/check-cache');
+                }
+            } },
+        { method: 'GET', path: '/api/restore-cache', handler: async (req, res) => {
+                try {
+                    const urlObj = new URL(req.url || '/', `http://${LOOPBACK_HOST}:${finalPort}`);
+                    const target = urlObj.searchParams.get('target');
+                    if (!target) {
+                        json(res, 400, { success: false, error: 'Missing target' });
+                        return;
+                    }
+                    if (target === 'ALL_FOLDERS') {
+                        const activeJsPath = await readGeneratedAssetIfExists('data.js');
+                        if (!activeJsPath) {
+                            json(res, 200, { success: false, error: 'No active cache found' });
+                            return;
+                        }
+                        const sync = await syncKnowledgeWorkspaceForTarget('ALL_FOLDERS', 'restore_cache');
+                        json(res, 200, { success: true, sync });
+                        return;
+                    }
+                    const targetName = sanitizeTargetName(target);
+                    const cacheJs = await readGeneratedAssetIfExists(`data_${targetName}.js`);
+                    const cacheJson = await readGeneratedAssetIfExists(`graph_data_${targetName}.json`);
+                    if (!cacheJs) {
+                        json(res, 404, { restored: false, error: `No cache found for target: ${target}` });
+                        return;
+                    }
+                    await fs.promises.mkdir(runtimeDataDir, { recursive: true });
+                    await fs.promises.copyFile(cacheJs, generatedAssetPath('data.js'));
+                    if (cacheJson) {
+                        await fs.promises.copyFile(cacheJson, generatedAssetPath('graph_data.json'));
+                    }
+                    const sync = await syncKnowledgeWorkspaceForTarget(target, 'restore_cache');
+                    json(res, 200, { success: true, sync });
+                }
+                catch (e) {
+                    fail(res, e, 'GET /api/restore-cache');
+                }
+            } },
+        { method: 'GET', path: '/api/folders', handler: async (_req, res) => {
+                try {
+                    let entries = [];
+                    try {
+                        entries = await fs.promises.readdir(kbRoot, { withFileTypes: true });
+                    }
+                    catch (error) {
+                        if (error?.code === 'ENOENT') {
+                            json(res, 200, { folders: [] });
+                            return;
+                        }
+                        throw error;
+                    }
+                    json(res, 200, { folders: entries.filter(d => d.isDirectory()).map(d => d.name).sort((a, b) => a.localeCompare(b)) });
+                }
+                catch (e) {
+                    fail(res, e, 'GET /api/folders');
+                }
+            } },
+        { method: 'GET', path: '/api/available-targets', handler: async (_req, res) => {
+                try {
+                    let entries = [];
+                    try {
+                        entries = await fs.promises.readdir(kbRoot, { withFileTypes: true });
+                    }
+                    catch {
+                        json(res, 200, { targets: [] });
+                        return;
+                    }
+                    json(res, 200, { targets: entries.filter(d => d.isDirectory()).map(d => d.name) });
+                }
+                catch (e) {
+                    fail(res, e, 'GET /api/available-targets');
+                }
+            } },
+        { method: 'GET', path: '/api/kb-path', handler: async (_req, res) => { json(res, 200, { kbPath: kbRoot }); } },
+        // ── POST routes ──
+        { method: 'POST', path: '/api/kb-path', handler: async (req, res) => {
+                try {
+                    const body = await readBody(req);
+                    const { kbPath: newPath } = JSON.parse(body);
+                    if (!newPath) {
+                        json(res, 400, { error: 'kbPath is required' });
+                        return;
+                    }
+                    json(res, 200, { updated: true, previousKbPath: kbRoot, requestedKbPath: newPath });
+                }
+                catch (e) {
+                    fail(res, e, 'POST /api/kb-path');
+                }
+            } },
+        { method: 'POST', path: '/api/build', handler: async (req, res) => {
+                try {
+                    const body = await readBody(req);
+                    const payload = JSON.parse(body);
+                    const target = String(payload?.target || 'ALL_FOLDERS').trim() || 'ALL_FOLDERS';
+                    const targetPath = target !== 'ALL_FOLDERS'
+                        ? path.join(kbRoot, target)
+                        : kbRoot;
+                    await (0, index_1.buildGraph)({
+                        targetPath,
+                        maxWorkers: payload?.maxWorkers,
+                        enableGPU: payload?.enableGPU,
+                        enableGPULayout: payload?.enableGPULayout,
+                        memorySavingMode: payload?.memorySavingMode,
+                        deepDebug: payload?.deepDebug,
+                    });
+                    const sync = await syncKnowledgeWorkspaceForTarget(target, 'build_graph');
+                    json(res, 200, { success: true, target, requestedAt: new Date().toISOString(), sync });
+                }
+                catch (e) {
+                    fail(res, e, 'POST /api/build');
+                }
+            } },
+    ];
+}

package/dist/src/routes/diagnostics.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerDiagnosticsRoutes = registerDiagnosticsRoutes;
+const CrashLogger_1 = require("../backend/utils/CrashLogger");
+function registerDiagnosticsRoutes(ctx) {
+    const { finalPort, LOOPBACK_HOST } = ctx;
+    const json = (res, code, data) => {
+        res.writeHead(code, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(data));
+    };
+    const ok = (res, data) => json(res, 200, { success: true, ...data });
+    const fail = (res, error, label) => {
+        console.error(error);
+        CrashLogger_1.CrashLogger.log(error, label);
+        json(res, 500, { success: false, error: String(error) });
+    };
+    return [
+        {
+            method: 'GET',
+            path: '/api/runtime-request-trace',
+            handler: async (req, res) => {
+                try {
+                    const urlObj = new URL(req.url || '/', `http://${LOOPBACK_HOST}:${finalPort}`);
+                    const exactRequestId = urlObj.searchParams.get('requestId') || undefined;
+                    ok(res, { trace: `request trace output for ${exactRequestId || 'recent'}` });
+                }
+                catch (e) {
+                    fail(res, e, 'API:GET /api/runtime-request-trace');
+                }
+            },
+        },
+        {
+            method: 'GET',
+            path: '/api/runtime-diagnostics',
+            handler: async (_req, res) => {
+                try {
+                    ok(res, {
+                        uptime: process.uptime(),
+                        memoryUsage: process.memoryUsage(),
+                        nodeVersion: process.version,
+                        platform: process.platform,
+                        arch: process.arch,
+                    });
+                }
+                catch (e) {
+                    fail(res, e, 'API:GET /api/runtime-diagnostics');
+                }
+            },
+        },
+    ];
+}

package/dist/src/routes/index.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerAllRoutes = registerAllRoutes;
+const knowledge_1 = require("./knowledge");
+const notemd_1 = require("./notemd");
+const markdown_1 = require("./markdown");
+const render_1 = require("./render");
+const settings_1 = require("./settings");
+const diagnostics_1 = require("./diagnostics");
+const data_1 = require("./data");
+const agentWorkspaceDiagnostics_1 = require("./agentWorkspaceDiagnostics");
+function registerAllRoutes(ctx) {
+    return [
+        ...(0, knowledge_1.registerKnowledgeRoutes)(ctx),
+        ...(0, notemd_1.registerNotemdRoutes)(ctx),
+        ...(0, markdown_1.registerMarkdownRoutes)(ctx),
+        ...(0, render_1.registerRenderRoutes)(ctx),
+        ...(0, settings_1.registerSettingsRoutes)(ctx),
+        ...(0, diagnostics_1.registerDiagnosticsRoutes)(ctx),
+        ...(0, data_1.registerDataRoutes)(ctx),
+        ...(0, agentWorkspaceDiagnostics_1.registerAgentWorkspaceDiagnosticsRoutes)(ctx),
+    ];
+}