noteconnection 1.7.0 → 1.9.0

package/dist/src/routes/runtimeRunbookRouteOps.test.js

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const runtimeRunbookRouteOps_1 = require("./runtimeRunbookRouteOps");
+function createRuntimeCapabilityMatrix(overrides = {}) {
+    return {
+        generatedAt: '2026-06-06T10:00:00.000Z',
+        overallStatus: 'degraded',
+        summary: {
+            passCount: 0,
+            warnCount: 0,
+            failCount: 1,
+        },
+        checks: [
+            {
+                checkId: 'alpha_check',
+                status: 'fail',
+                message: 'alpha failed',
+                observed: 'observed',
+                priorityScore: 12,
+                recommendedActions: ['Inspect alpha'],
+            },
+        ],
+        signals: {
+            topRiskCheckId: 'alpha_check',
+        },
+        ...overrides,
+    };
+}
+function createDependencies(overrides = {}) {
+    return {
+        buildRuntimePayload: jest.fn(async (generatedAt) => ({
+            runtimeCapabilityMatrix: createRuntimeCapabilityMatrix({
+                generatedAt,
+            }),
+        })),
+        normalizeCheckId: jest.fn((value) => String(value || '').trim().toLowerCase()),
+        replayVerificationForCheck: jest.fn(async () => null),
+        buildIndexSyncHealthSummary: jest.fn(() => ({ health: 'index-sync-ok' })),
+        queryHistory: jest.fn(async (request) => request),
+        parseHistoryLimit: jest.fn((value) => Number(value || 20)),
+        parseHistorySinceMinutes: jest.fn((value) => Number(value || 1440)),
+        normalizeVerificationStatus: jest.fn((value) => String(value || '').trim().toLowerCase()),
+        queryChecks: jest.fn(async (request) => request),
+        parseChecksLimit: jest.fn((value) => Number(value || 8)),
+        queryActionQueue: jest.fn(async (request) => request),
+        parseActionQueueLimit: jest.fn((value) => Number(value || 12)),
+        normalizeActionQueuePriorityFilter: jest.fn((value) => String(value || '').trim().toLowerCase()),
+        normalizeActionQueueCategoryFilter: jest.fn((value) => String(value || '').trim().toLowerCase()),
+        normalizeActionQueueRemediationStatusFilter: jest.fn((value) => String(value || '').trim().toLowerCase()),
+        normalizeActionQueueRemediationTrendFilter: jest.fn((value) => String(value || '').trim().toLowerCase()),
+        queryRemediationHistory: jest.fn(async (request) => request),
+        parseRemediationLimit: jest.fn((value) => Number(value || 20)),
+        normalizeRemediationStatusQuery: jest.fn((value) => String(value || '').trim().toLowerCase()),
+        normalizeRemediationSource: jest.fn((value) => String(value || '').trim().toLowerCase()),
+        getReplaySchedule: jest.fn(async () => ({ enabled: true })),
+        normalizeRemediationEventPayload: jest.fn((payload, requestId) => ({
+            payload,
+            requestId,
+        })),
+        appendRemediationEventRecord: jest.fn(),
+        getRemediationEventCount: jest.fn(() => 3),
+        triggerReplayScheduleFromEvent: jest.fn(),
+        normalizeRemediationReplayRequestPayload: jest.fn((payload) => ({
+            normalizedReplayPayload: payload,
+        })),
+        replayRemediationEvents: jest.fn(async (payload) => payload),
+        updateReplaySchedule: jest.fn(async (payload) => ({
+            updated: payload,
+        })),
+        normalizeReplayScheduleTickPayload: jest.fn((payload) => ({
+            force: Boolean(payload?.force),
+            dryRunOverride: payload?.dryRunOverride,
+        })),
+        tickReplaySchedule: jest.fn(async (options) => options),
+        ...overrides,
+    };
+}
+describe('runtimeRunbookRouteOps', () => {
+    test('verify reuses replay result and resolves selected/effective check ids', async () => {
+        const deps = createDependencies({
+            replayVerificationForCheck: jest.fn(async () => ({
+                resolvedCheckId: 'alpha_check_resolved',
+                replayedAt: '2026-06-06T10:01:00.000Z',
+                selectedCheckStatus: 'fail',
+            })),
+        });
+        const ops = (0, runtimeRunbookRouteOps_1.createRuntimeRunbookRouteOps)(deps);
+        const result = await ops.verify?.({
+            checkId: 'alpha_check',
+            sinceMinutes: 60,
+            limit: 15,
+        });
+        expect(deps.replayVerificationForCheck).toHaveBeenCalledWith({
+            checkId: 'alpha_check',
+            sinceMinutes: 60,
+            traceLimit: 15,
+        });
+        expect(result).toMatchObject({
+            resolvedCheckId: 'alpha_check_resolved',
+            selectedCheckId: 'alpha_check_resolved',
+            effectiveCheckId: 'alpha_check_resolved',
+            selectedCheckStatus: 'fail',
+        });
+    });
+    test('verify returns stable fallback result when no verification history is available', async () => {
+        const deps = createDependencies();
+        const ops = (0, runtimeRunbookRouteOps_1.createRuntimeRunbookRouteOps)(deps);
+        const result = await ops.verify?.({
+            checkId: 'alpha_check',
+        });
+        expect(result).toMatchObject({
+            requestedCheckId: 'alpha_check',
+            selectedCheckId: '',
+            effectiveCheckId: '',
+            selectedCheckStatus: 'unknown',
+            selectedCheckEscalation: 'normal',
+            selectedCheckMessage: 'No verification history available yet.',
+            selectedCheckHistory: {
+                returnedRecords: 0,
+                activeRiskStreak: 0,
+                activeFailStreak: 0,
+                trendStatus: 'insufficient_data',
+            },
+            selectedCheckRemediation: {
+                latestStatus: '',
+                trendStatus: 'insufficient_data',
+                riskRatioPct: 0,
+            },
+            queryVectorAccelerationIndexSyncHealth: {
+                health: 'index-sync-ok',
+            },
+        });
+        expect(Array.isArray(result.verificationTargets)).toBe(true);
+        expect(result.verificationTargets.length).toBeGreaterThan(0);
+    });
+    test('getActionQueue delegates normalized filters to the query owner', async () => {
+        const deps = createDependencies();
+        const ops = (0, runtimeRunbookRouteOps_1.createRuntimeRunbookRouteOps)(deps);
+        await ops.getActionQueue?.({
+            limit: 9,
+            sinceMinutes: 33,
+            status: 'WARN',
+            checkQuery: 'alpha',
+            queueLimit: 7,
+            priority: 'P1',
+            category: 'trend',
+            checkId: 'ALPHA_CHECK',
+            remediationStatus: 'SUCCESS',
+            remediationTrend: 'REGRESSING',
+        });
+        expect(deps.queryActionQueue).toHaveBeenCalledWith({
+            checksQuery: {
+                limit: 9,
+                sinceMinutes: 33,
+                status: 'warn',
+                checkQuery: 'alpha',
+            },
+            queueLimit: 7,
+            priorityFilter: 'p1',
+            categoryFilter: 'trend',
+            checkIdFilter: 'alpha_check',
+            remediationStatusFilter: 'success',
+            remediationTrendFilter: 'regressing',
+        });
+    });
+    test('recordRemediationEvent appends the normalized record and returns count summary', async () => {
+        const deps = createDependencies();
+        const ops = (0, runtimeRunbookRouteOps_1.createRuntimeRunbookRouteOps)(deps);
+        const result = await ops.recordRemediationEvent?.({
+            action: 'retry',
+        }, 'req-123');
+        expect(deps.normalizeRemediationEventPayload).toHaveBeenCalledWith({
+            action: 'retry',
+        }, 'req-123');
+        expect(deps.appendRemediationEventRecord).toHaveBeenCalledWith({
+            payload: {
+                action: 'retry',
+            },
+            requestId: 'req-123',
+        });
+        expect(deps.triggerReplayScheduleFromEvent).toHaveBeenCalled();
+        expect(result).toEqual({
+            record: {
+                payload: {
+                    action: 'retry',
+                },
+                requestId: 'req-123',
+            },
+            summary: {
+                totalRecords: 3,
+            },
+        });
+    });
+});

package/dist/src/routes/settings.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSettingsRoutes = registerSettingsRoutes;
+function registerSettingsRoutes(_ctx) {
+    return [];
+}

package/dist/src/routes/staticFiles.js

@@ -0,0 +1,94 @@
+"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.getStaticContentType = getStaticContentType;
+exports.isPathInsideRoot = isPathInsideRoot;
+exports.resolveFrontendStaticPath = resolveFrontendStaticPath;
+exports.tryServeStaticFile = tryServeStaticFile;
+/**
+ * Static file serving utilities.
+ * Extracted from server.ts inline chain for reuse and testability.
+ */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function getStaticContentType(filePath) {
+    switch (path.extname(filePath).toLowerCase()) {
+        case '.html': return 'text/html';
+        case '.js': return 'text/javascript';
+        case '.css': return 'text/css';
+        case '.json': return 'application/json';
+        case '.png': return 'image/png';
+        case '.jpg':
+        case '.jpeg': return 'image/jpeg';
+        case '.svg': return 'image/svg+xml';
+        case '.ico': return 'image/x-icon';
+        case '.woff': return 'font/woff';
+        case '.woff2': return 'font/woff2';
+        case '.ttf': return 'font/ttf';
+        default: return 'application/octet-stream';
+    }
+}
+function isPathInsideRoot(target, root) {
+    const resolved = path.resolve(target);
+    const rootResolved = path.resolve(root) + path.sep;
+    return resolved.startsWith(rootResolved) || resolved === path.resolve(root);
+}
+function resolveFrontendStaticPath(rawUrl, frontendDir) {
+    const normalized = String(rawUrl || '').replace(/^\/+/, '');
+    const sanitized = normalized
+        .split('/')
+        .filter(segment => segment && segment !== '..')
+        .join('/');
+    if (!sanitized)
+        return null;
+    const resolved = path.resolve(frontendDir, sanitized);
+    if (!isPathInsideRoot(resolved, frontendDir))
+        return null;
+    return resolved;
+}
+async function tryServeStaticFile(filePath, res) {
+    try {
+        const stat = await fs.promises.stat(filePath);
+        if (!stat.isFile())
+            return false;
+        const content = await fs.promises.readFile(filePath);
+        res.writeHead(200, { 'Content-Type': getStaticContentType(filePath) });
+        res.end(content);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/src/routes/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/runtime.capabilities.test.js

@@ -56,6 +56,11 @@ describe('runtime capability gating contract', () => {
         expect(sourceManager).toContain('supports_mobile_wasm_compute');
         expect(sourceManager).toContain('mobile_wasm_reason');
         expect(sourceManager).toContain('detectMobileWasmCapability');
+        expect(sourceManager).toContain('storage_requested_provider');
+        expect(sourceManager).toContain('storage_resolved_provider');
+        expect(sourceManager).toContain('storage_fallback_reason');
+        expect(sourceManager).toContain('supports_sqlite');
+        expect(sourceManager).toContain('refreshStorageResolution');
     });
     test('source manager blocks build path when runtime does not support build', () => {
         const sourceManager = fs.readFileSync(sourceManagerPath, 'utf8');
@@ -76,18 +81,29 @@ describe('runtime capability gating contract', () => {
         expect(reader).toContain('supports_content_api');
         expect(reader).toContain("window.i18n.t('source.error.contentUnavailableMobile')");
     });
-    test('rust runtime capabilities command is registered and has android-safe defaults', () => {
+    test('rust runtime capabilities command is registered and keeps Godot Pathmode opt-in', () => {
         const tauriLib = fs.readFileSync(tauriLibPath, 'utf8');
         expect(tauriLib).toContain('fn get_runtime_capabilities()');
         expect(tauriLib).toContain('get_runtime_capabilities,');
         expect(tauriLib).toContain('choose_kb_path,');
+        expect(tauriLib).toContain('request_kb_path_change,');
+        expect(tauriLib).toContain('poll_kb_path_change,');
         expect(tauriLib).toContain('reset_kb_path,');
         expect(tauriLib).toContain('open_native_pathmode,');
         expect(tauriLib).toContain('build_graph_runtime,');
         expect(tauriLib).toContain('supports_sidecar: false');
         expect(tauriLib).toContain('supports_build: true');
         expect(tauriLib).toContain('supports_content_api: true');
-        expect(tauriLib).toContain('supports_native_pathmode: true');
+        expect(tauriLib).toContain('supports_kb_import: true');
+        expect(tauriLib).toContain('kb_import_mode: "android-saf-copy"');
+        expect(tauriLib).toContain('supports_projection_store: true');
+        expect(tauriLib).toContain('storage_requested_provider: "projection".to_string()');
+        expect(tauriLib).toContain('storage_resolved_provider: "projection".to_string()');
+        expect(tauriLib).toContain('storage_requested_provider: "sqlite".to_string()');
+        expect(tauriLib).toContain('storage_resolved_provider: "unknown".to_string()');
+        expect(tauriLib).toContain('supports_sqlite: false');
+        expect(tauriLib).toContain('supports_sqlite: true');
+        expect(tauriLib).toContain('supports_native_pathmode: option_env!("NOTE_CONNECTION_ANDROID_INCLUDE_GODOT_PATHMODE")');
         expect(tauriLib).toContain('read_node_content');
     });
     test('path mode entry prefers native android activity when capability is enabled', () => {

package/dist/src/runtime.transport.adapter.contract.test.js

@@ -35,9 +35,11 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const vm = __importStar(require("vm"));
 describe('runtime transport adapter consolidation contract', () => {
     const repoRoot = path.resolve(__dirname, '..');
     const runtimeBridgePath = path.join(repoRoot, 'src', 'frontend', 'runtime_bridge.js');
+    const appPath = path.join(repoRoot, 'src', 'frontend', 'app.js');
     const sourceManagerPath = path.join(repoRoot, 'src', 'frontend', 'source_manager.js');
     const readerPath = path.join(repoRoot, 'src', 'frontend', 'reader.js');
     const pathAppPath = path.join(repoRoot, 'src', 'frontend', 'path_app.js');
@@ -58,6 +60,85 @@ describe('runtime transport adapter consolidation contract', () => {
         expect(runtimeBridge).toContain("url.searchParams.set('token', state.authToken)");
         expect(runtimeBridge).toContain('function getBridgeWsUrl(clientTag)');
     });
+    test('runtime bridge refreshes sidecar config from Tauri after initial hydration', async () => {
+        const runtimeBridge = fs.readFileSync(runtimeBridgePath, 'utf8');
+        const sidecarConfigs = [
+            {
+                host: '127.0.0.1',
+                port: 14817,
+                bridgePort: 14818,
+                baseUrl: 'http://127.0.0.1:14817',
+                bridgeWsUrl: 'ws://127.0.0.1:14818',
+                authToken: 'old-token',
+            },
+            {
+                host: '127.0.0.1',
+                port: 24817,
+                bridgePort: 24818,
+                baseUrl: 'http://127.0.0.1:24817',
+                bridgeWsUrl: 'ws://127.0.0.1:24818',
+                authToken: 'new-token',
+            },
+        ];
+        let sidecarConfigIndex = 0;
+        const invokeCalls = [];
+        const windowObject = {
+            __TAURI__: {
+                core: {
+                    invoke: async (command) => {
+                        invokeCalls.push(command);
+                        if (command === 'get_runtime_capabilities') {
+                            return { supports_sidecar: true };
+                        }
+                        if (command === 'get_sidecar_runtime_config') {
+                            const config = sidecarConfigs[Math.min(sidecarConfigIndex, sidecarConfigs.length - 1)];
+                            sidecarConfigIndex += 1;
+                            return config;
+                        }
+                        if (command === 'get_app_runtime_config') {
+                            return { language: 'en', multiWindow: {} };
+                        }
+                        throw new Error(`Unexpected Tauri command: ${command}`);
+                    },
+                },
+            },
+            dispatchEvent: jest.fn(),
+        };
+        const context = {
+            window: windowObject,
+            document: {
+                readyState: 'complete',
+                addEventListener: jest.fn(),
+            },
+            console,
+            CustomEvent,
+            Headers,
+            URL,
+            WebSocket: class {
+            },
+            setTimeout,
+            clearTimeout,
+        };
+        vm.runInNewContext(runtimeBridge, context);
+        await windowObject.NoteConnectionRuntime.whenReady();
+        expect(windowObject.NoteConnectionRuntime.getAuthToken()).toBe('old-token');
+        await windowObject.NoteConnectionRuntime.refreshFromTauri();
+        expect(windowObject.NoteConnectionRuntime.getAuthToken()).toBe('new-token');
+        expect(windowObject.NoteConnectionRuntime.getBaseUrl()).toBe('http://127.0.0.1:24817');
+        expect(invokeCalls.filter((command) => command === 'get_sidecar_runtime_config')).toHaveLength(2);
+    });
+    test('agent settings runtime requests wait for runtime readiness and recover stale sidecar auth', () => {
+        const app = fs.readFileSync(appPath, 'utf8');
+        const requestRuntimeJsonStart = app.indexOf('const ensureRuntimeBridgeReady = async () => {');
+        expect(requestRuntimeJsonStart).toBeGreaterThan(-1);
+        const requestRuntimeJsonEnd = app.indexOf('    const isAnySettingsPanelOpen', requestRuntimeJsonStart);
+        expect(requestRuntimeJsonEnd).toBeGreaterThan(requestRuntimeJsonStart);
+        const runtimeRequestBlock = app.slice(requestRuntimeJsonStart, requestRuntimeJsonEnd);
+        expect(runtimeRequestBlock).toContain('await window.NoteConnectionRuntime.whenReady()');
+        expect(runtimeRequestBlock).toContain('response.status === 401');
+        expect(runtimeRequestBlock).toContain('await window.NoteConnectionRuntime.refreshFromTauri()');
+        expect(runtimeRequestBlock).toContain('const secondAttempt = await fetchRuntimeJsonOnce(resourcePath, init);');
+    });
     test('source manager and reader use shared runtime adapters (bridge + storage provider)', () => {
         const sourceManager = fs.readFileSync(sourceManagerPath, 'utf8');
         const reader = fs.readFileSync(readerPath, 'utf8');