noteconnection 1.7.0 → 1.8.0

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.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');