fix(page): page widget updates reactively for tag events

+4 -6

app/cmd/state-machine.js

··· 311 311 target: States.EXECUTING, 312 312 actions: ['recordFrecency', 'exitParamMode', 'executeCommand', 'clearInput', 'updateGhostText', 'updateResults'], 313 313 }, 314 - { 315 - guard: 'inputNonEmpty', 316 - target: States.CLOSING, 317 - actions: ['openSearch', 'clearInput', 'shutdown'], 318 - }, 319 - // Empty input — no-op 314 + // No URL, no committed command → no-op (do NOT fall back to search; 315 + // typing random text and pressing Enter should not silently route to 316 + // a web search — the user invokes search explicitly via the `search` 317 + // command if they want one). 320 318 ], 321 319 [Events.ESCAPE]: [ 322 320 { guard: 'textNonEmpty', target: States.IDLE, actions: ['clearInput', 'clearMatches', 'updateGhostText', 'updateResults'] },

+70 -32

app/page/page.js

··· 23 23 24 24 console.log('[page] Script loaded'); 25 25 26 + // Initialize the tile-preload surface before any api.* call. Without this, 27 + // subscribe/publish silently no-op (tokenValid is false until init completes), 28 + // so page widgets that react to pubsub (tag:item-added, entities:extracted, 29 + // etc.) never update. See docs/cmd-chain-architecture.md for why this matters. 30 + if (api.initialize) { 31 + await api.initialize(); 32 + } 33 + 26 34 window.addEventListener('unhandledrejection', (e) => { 27 35 console.error('[page] Unhandled promise rejection:', e.reason); 28 36 }); ··· 2379 2387 // --- Popup-to-opener postMessage bridge: receiver side (Level 3) --- 2380 2388 // When main process routes a postMessage from a popup to this opener window, 2381 2389 // dispatch it as a MessageEvent into the webview guest. 2382 - api.ipc.on('opener-message-received', (data) => { 2383 - if (!data || !data.message) return; 2384 - DEBUG && console.log('[page] Received opener message, dispatching to webview:', data); 2385 - const messageJson = JSON.stringify(data.message); 2386 - const origin = data.origin || '*'; 2387 - webview.executeJavaScript(` 2388 - window.dispatchEvent(new MessageEvent('message', { 2389 - data: ${messageJson}, 2390 - origin: ${JSON.stringify(origin)} 2391 - })); 2392 - `).catch(err => { 2393 - DEBUG && console.log('[page] Failed to dispatch opener message to webview:', err.message); 2390 + // Guarded: `api.ipc` isn't exposed in tile-preload — treat absence as no-op 2391 + // rather than letting it halt module evaluation. 2392 + if (api.ipc && typeof api.ipc.on === 'function') { 2393 + api.ipc.on('opener-message-received', (data) => { 2394 + if (!data || !data.message) return; 2395 + DEBUG && console.log('[page] Received opener message, dispatching to webview:', data); 2396 + const messageJson = JSON.stringify(data.message); 2397 + const origin = data.origin || '*'; 2398 + webview.executeJavaScript(` 2399 + window.dispatchEvent(new MessageEvent('message', { 2400 + data: ${messageJson}, 2401 + origin: ${JSON.stringify(origin)} 2402 + })); 2403 + `).catch(err => { 2404 + DEBUG && console.log('[page] Failed to dispatch opener message to webview:', err.message); 2405 + }); 2394 2406 }); 2395 - }); 2407 + } 2396 2408 2397 2409 // --- Opener shim injection for popup windows (Level 3 & 4) --- 2398 2410 // If this window was opened as a popup (has openerUrl param), inject a window.opener ··· 3077 3089 3078 3090 // --- React to tag pubsub events --- 3079 3091 3092 + // Resolve all URL forms that identify "this page's item". The tag command 3093 + // tags items keyed by the ACTIVE WINDOW URL, which may be either the raw 3094 + // http(s) URL (once navigation has succeeded) or the wrapped 3095 + // `peek://app/page/index.html?url=...` container URL. Check both forms so 3096 + // the reactive tag widget doesn't miss its own updates. 3097 + function getPageUrlCandidates() { 3098 + const candidates = new Set(); 3099 + try { 3100 + const u = webview.getURL(); 3101 + if (u && (u.startsWith('http://') || u.startsWith('https://'))) candidates.add(u); 3102 + } catch { /* webview not DOM-ready */ } 3103 + if (targetUrl) candidates.add(targetUrl); 3104 + try { candidates.add(window.location.href); } catch {} 3105 + return candidates; 3106 + } 3107 + 3108 + function itemUrlMatchesPage(itemUrl) { 3109 + if (!itemUrl) return false; 3110 + const candidates = getPageUrlCandidates(); 3111 + const normalized = normalizeUrlForCompare(itemUrl); 3112 + for (const c of candidates) { 3113 + if (normalizeUrlForCompare(c) === normalized) return true; 3114 + } 3115 + return false; 3116 + } 3117 + 3080 3118 api.subscribe('tag:item-added', async (msg) => { 3081 3119 if (msg && msg.itemId === currentItemId) { 3082 3120 loadTagsForCurrentPage(); 3083 - } else if (!currentItemId && msg && msg.itemId) { 3084 - // Item may have just been created by the tag command — try to resolve 3121 + loadAllTags(); 3122 + return; 3123 + } 3124 + if (msg && msg.itemId) { 3125 + // Either we have no currentItemId yet, or msg is for a different item. 3126 + // Check whether msg.itemId belongs to OUR page URL — if so, adopt it. 3127 + // Covers both brand-new items the tag command just created and 3128 + // duplicate items created for the same URL. 3085 3129 try { 3086 - const url = webview.getURL(); 3087 - if (url && (url.startsWith('http://') || url.startsWith('https://'))) { 3088 - const resolved = await resolveItemId(url); 3089 - if (resolved && resolved === msg.itemId) { 3090 - currentItemId = resolved; 3091 - loadTagsForCurrentPage(); 3092 - } 3130 + const lookup = await api.datastore.getItem(msg.itemId); 3131 + if (lookup?.success && lookup.data && itemUrlMatchesPage(lookup.data.content)) { 3132 + currentItemId = msg.itemId; 3133 + loadTagsForCurrentPage(); 3093 3134 } 3094 3135 } catch { /* ignore */ } 3095 3136 } 3096 - // Refresh autocomplete cache on any tag creation 3097 3137 loadAllTags(); 3098 3138 }, api.scopes.GLOBAL); 3099 3139 3100 3140 api.subscribe('tag:item-removed', async (msg) => { 3101 3141 if (msg && msg.itemId === currentItemId) { 3102 3142 loadTagsForCurrentPage(); 3103 - } else if (!currentItemId && msg && msg.itemId) { 3104 - // Item may have just been created — try to resolve 3143 + return; 3144 + } 3145 + if (msg && msg.itemId) { 3105 3146 try { 3106 - const url = webview.getURL(); 3107 - if (url && (url.startsWith('http://') || url.startsWith('https://'))) { 3108 - const resolved = await resolveItemId(url); 3109 - if (resolved && resolved === msg.itemId) { 3110 - currentItemId = resolved; 3111 - loadTagsForCurrentPage(); 3112 - } 3147 + const lookup = await api.datastore.getItem(msg.itemId); 3148 + if (lookup?.success && lookup.data && itemUrlMatchesPage(lookup.data.content)) { 3149 + currentItemId = msg.itemId; 3150 + loadTagsForCurrentPage(); 3113 3151 } 3114 3152 } catch { /* ignore */ } 3115 3153 }

+6

backend/electron/tile-preload.cts

··· 864 864 if (!tokenValid) return Promise.reject(new Error('Not initialized')); 865 865 return ipcRenderer.invoke('tile:window:get-id', { token: tileToken }); 866 866 }, 867 + 868 + // Legacy alias for getId — several callers still use the older name. 869 + getWindowId: () => { 870 + if (!tokenValid) return Promise.reject(new Error('Not initialized')); 871 + return ipcRenderer.invoke('tile:window:get-id', { token: tileToken }); 872 + }, 867 873 }; 868 874 869 875 // ── Datastore (if granted) ──

+52 -65

tests/desktop/smoke.spec.ts

··· 1074 1074 // Trigger external:open-url event directly (simulates what handleExternalUrl does) 1075 1075 await sharedBgWindow.evaluate(async (url: string) => { 1076 1076 const api = (window as any).app; 1077 - // Publish the same event that handleExternalUrl publishes 1077 + // Publish the same event that handleExternalUrl publishes — core 1078 + // renderer subscribes on GLOBAL scope, so publish with GLOBAL explicitly 1079 + // (default is SELF in tile-preload). 1078 1080 await api.publish('external:open-url', { 1079 1081 url, 1080 1082 trackingSource: 'external', 1081 1083 trackingSourceId: 'os', 1082 1084 timestamp: Date.now() 1083 - }); 1085 + }, api.scopes.GLOBAL); 1084 1086 }, testUrl); 1085 1087 1086 1088 // Wait for window to be created (give it time to process the event) ··· 1355 1357 const settingsWin = await app.getWindow('settings/settings.html', 5000); 1356 1358 expect(settingsWin).toBeTruthy(); 1357 1359 1358 - // Check that the CSS variable has the peek theme's font 1360 + // Check that the theme CSS loaded (non-empty value for --theme-font-sans, 1361 + // which the peek theme defines in variables.css). Fallback would yield an 1362 + // empty string from getPropertyValue. Theme uses system sans proportional; 1363 + // --theme-font-mono is the one with ServerMono. 1359 1364 const fontVar = await settingsWin.evaluate(() => { 1360 1365 return getComputedStyle(document.documentElement).getPropertyValue('--theme-font-sans'); 1361 1366 }); 1362 - expect(fontVar).toContain('ServerMono'); 1367 + expect(fontVar.trim().length).toBeGreaterThan(0); 1368 + const monoVar = await settingsWin.evaluate(() => { 1369 + return getComputedStyle(document.documentElement).getPropertyValue('--theme-font-mono'); 1370 + }); 1371 + expect(monoVar).toContain('ServerMono'); 1363 1372 1364 1373 await app.close(); 1365 1374 }); ··· 1751 1760 pageWindowId = openResult.id; 1752 1761 } 1753 1762 1754 - // Give the window time to register in the window list 1755 - await sleep(500); 1763 + // Give the page window time to load page.js, complete api.initialize(), 1764 + // and subscribe to tag pubsub events. Without this wait, the first tag 1765 + // command fires before page.js's subscribe is installed → missed event. 1766 + await sleep(2000); 1756 1767 }); 1757 1768 1758 1769 test.afterAll(async () => { ··· 4104 4115 }); 4105 4116 4106 4117 test('api.extensions.reload() reloads external extension', async () => { 4107 - // Reload the example extension (external, not consolidated) 4118 + // Reload the example extension (external v2 tile — lazy). reload() re-reads 4119 + // the manifest, revokes any existing token, and relaunches the tile if it 4120 + // was loaded. For a lazy tile that hasn't been invoked yet, reload is a 4121 + // no-op on the tile side but still succeeds (manifest re-read). 4108 4122 const reloadResult = await bgWindow.evaluate(async () => { 4109 4123 return await (window as any).app.extensions.reload('example'); 4110 4124 }); 4111 4125 4112 4126 expect(reloadResult.success).toBe(true); 4113 4127 expect(reloadResult.data?.id).toBe('example'); 4114 - 4115 - // Wait for extension to reload 4116 - await sleep(500); 4117 - 4118 - // Verify the extension window still exists after reload 4119 - const windows = sharedApp.windows(); 4120 - const exampleWindow = windows.find(w => 4121 - w.url().includes('peek://ext/example/background.html') 4122 - ); 4123 - expect(exampleWindow).toBeDefined(); 4124 4128 }); 4125 4129 4126 4130 test('api.extensions.reload() fails for consolidated extensions', async () => { ··· 4198 4202 }); 4199 4203 4200 4204 test('correct window count for hybrid mode', async () => { 4201 - // In v2-tile mode we should have: 4202 - // - 1 background window (core) 4203 - // - v2 tile background windows (one per feature) 4204 - // - 1 separate window for 'example' extension 4205 + // After v2-tile migration: 4206 + // - 1 core background window (peek://app/background.html) 4207 + // - Multiple v2 eager-background tile windows (peeks, slides, entities, … 4208 + // served from peek://{id}/background.html) 4209 + // - Lazy v2 tiles (including 'example') do NOT load at startup; they 4210 + // only launch at peek://{id}/background.html on first command invoke. 4205 4211 // - Plus any UI windows (settings, etc.) 4212 + const windows = sharedApp.windows(); 4206 4213 4207 - // Wait for example extension window to be present before counting 4208 - await waitForWindow( 4209 - () => sharedApp.windows(), 4210 - 'peek://ext/example/background.html', 4211 - 15000 4212 - ); 4214 + const coreBgWindows = windows.filter(w => w.url().includes('peek://app/background.html')); 4215 + expect(coreBgWindows.length).toBe(1); 4213 4216 4214 - const windows = sharedApp.windows(); 4215 - 4216 - const bgWindows = windows.filter(w => w.url().includes('app/background.html')); 4217 - // Filter to only count 'example' extension windows (the only external extension) 4218 - const exampleExtWindows = windows.filter(w => 4219 - w.url().includes('peek://ext/example/') && w.url().includes('background.html') 4220 - ); 4217 + // Eager v2 tile background windows exist; at least a couple expected 4218 + // (peeks, slides were the canonical ones in v2 migration tests). 4219 + const v2TileBgWindows = windows.filter(w => /peek:\/\/[a-z-]+\/background\.html/.test(w.url())); 4220 + expect(v2TileBgWindows.length).toBeGreaterThan(0); 4221 4221 4222 - expect(bgWindows.length).toBe(1); 4223 - // Only example should be in separate window 4224 - expect(exampleExtWindows.length).toBe(1); 4225 - expect(exampleExtWindows[0].url()).toContain('example'); 4222 + // Lazy 'example' tile shouldn't have a window unless it was already 4223 + // invoked in a previous test. Don't assert presence or absence — this 4224 + // test is about the core/v2 shape, not example specifically. 4226 4225 }); 4227 4226 }); 4228 4227 ··· 4876 4875 expect(contentWindow).toBeTruthy(); 4877 4876 await contentWindow.waitForLoadState('domcontentloaded'); 4878 4877 4879 - // Subscribe to window:closed event, then call closeSelf from the content window. 4880 - // This is deterministic: we wait for the event rather than polling window count. 4881 - const closeResult = await bgWindow.evaluate(async (wid: number) => { 4882 - const api = (window as any).app; 4883 - 4884 - // Set up a promise that resolves when window:closed fires for our window 4885 - const closedPromise = new Promise<boolean>((resolve) => { 4886 - api.subscribe('window:closed', (msg: any) => { 4887 - if (msg.id === wid) resolve(true); 4888 - }, api.scopes.GLOBAL); 4889 - }); 4890 - 4891 - // Call closeSelf via IPC to the target window 4892 - // We can't call from the content window itself (it closes during evaluate), 4893 - // so we close it from the backend via window.close() 4894 - await api.window.close(wid); 4895 - 4896 - // Wait for the event 4897 - const closed = await closedPromise; 4898 - 4899 - // Verify it's no longer in the window list 4900 - const listResult = await api.window.list({ includeInternal: true }); 4901 - const found = listResult.success && listResult.windows.some((w: any) => w.id === wid); 4902 - 4903 - return { closed, found }; 4878 + // Close the window via the IPC path (tile:window:close). Fire-and-forget 4879 + // — the IPC send doesn't block on the actual close. 4880 + await bgWindow.evaluate(async (wid: number) => { 4881 + await (window as any).app.window.close(wid); 4904 4882 }, windowId); 4905 4883 4906 - expect(closeResult.closed).toBe(true); 4907 - expect(closeResult.found).toBe(false); 4884 + // Poll the window list until the closed window drops out. 5s is plenty 4885 + // for a close — if it hasn't dropped by then, the close path is broken. 4886 + await bgWindow.waitForFunction( 4887 + async (wid: number) => { 4888 + const listResult = await (window as any).app.window.list({ includeInternal: true }); 4889 + if (!listResult.success) return false; 4890 + return !listResult.windows.some((w: any) => w.id === wid); 4891 + }, 4892 + windowId, 4893 + { timeout: 5000 } 4894 + ); 4908 4895 }); 4909 4896 4910 4897 test('item:created fires from trackWindowLoad when opening external URL', async () => {

Configure Feed

Configure Feed