experiments in a post-browser web
fix: deterministic lazy loading, websearch commands, URL window reuse, link tooltip
- Fix extension ID mismatch: config.js IDs now match manifest IDs
- Fix ext:ready ordering: all background.html files call init() before publishing ext:ready
- Remove BroadcastChannel from websearch (origin mismatch), use IPC pubsub
- Add URL-based window dedup: opening same http/https URL focuses existing window
- Add link hover tooltip: status bar shows URL on webview link hover
- Remove debug TRACE logging from pubsub.ts, ipc.ts, preload.js, commands.js
- Add Playwright tests for websearch commands and window URL handling
+844
-199
+32
app/page/index.html
+32
app/page/index.html
···
1175
1175
font-size: 10px;
1176
1176
color: var(--theme-text-muted, #777);
1177
1177
}
1178
+
1179
+
/* --- Link status bar (bottom-left, shown on hover over links) --- */
1180
+
1181
+
.link-status-bar {
1182
+
position: absolute;
1183
+
bottom: 8px;
1184
+
left: 8px;
1185
+
z-index: 200;
1186
+
max-width: 60%;
1187
+
padding: 4px 8px;
1188
+
background: color-mix(in srgb, var(--base00, #1e1e1e) 90%, transparent);
1189
+
backdrop-filter: blur(12px);
1190
+
-webkit-backdrop-filter: blur(12px);
1191
+
border: 1px solid color-mix(in srgb, var(--theme-border, rgba(255,255,255,0.1)) 40%, transparent);
1192
+
border-radius: 6px;
1193
+
color: var(--theme-text-secondary, #aaa);
1194
+
font-family: var(--theme-font-sans, system-ui, -apple-system, BlinkMacSystemFont, sans-serif);
1195
+
font-size: 11px;
1196
+
line-height: 1.3;
1197
+
white-space: nowrap;
1198
+
overflow: hidden;
1199
+
text-overflow: ellipsis;
1200
+
pointer-events: none;
1201
+
opacity: 0;
1202
+
transition: opacity 0.15s ease;
1203
+
}
1204
+
1205
+
.link-status-bar.visible {
1206
+
opacity: 1;
1207
+
}
1178
1208
</style>
1179
1209
</head>
1180
1210
<body data-no-drag>
···
1258
1288
</div>
1259
1289
1260
1290
<div class="widget-container" id="widget-container"></div>
1291
+
<!-- Link status bar (shows URL on hover, like browser status bar) -->
1292
+
<div class="link-status-bar" id="link-status-bar"></div>
1261
1293
</div>
1262
1294
<div class="right-gutter"></div>
1263
1295
</div>
+12
app/page/page.js
+12
app/page/page.js
···
3115
3115
}
3116
3116
});
3117
3117
3118
+
// --- Link hover status bar ---
3119
+
// Show the URL of the link the user is hovering over, like a browser status bar.
3120
+
const linkStatusBar = document.getElementById('link-status-bar');
3121
+
webview.addEventListener('update-target-url', (e) => {
3122
+
if (e.url) {
3123
+
linkStatusBar.textContent = e.url;
3124
+
linkStatusBar.classList.add('visible');
3125
+
} else {
3126
+
linkStatusBar.classList.remove('visible');
3127
+
}
3128
+
});
3129
+
3118
3130
DEBUG && console.log('[page] Minimal page host initialized for:', targetUrl);
+1
backend/electron/index.ts
+1
backend/electron/index.ts
+15
backend/electron/ipc.ts
+15
backend/electron/ipc.ts
···
104
104
getWindowInfo,
105
105
removeWindow,
106
106
findWindowByKey,
107
+
findWindowByUrl,
107
108
getAllWindows,
108
109
validateThemeCSS,
109
110
popClosedWindow,
···
2204
2205
2205
2206
// Mark this key as pending creation
2206
2207
pendingWindowKeys.add(fullKey);
2208
+
}
2209
+
2210
+
// Check if any existing window already has this URL loaded (for http/https URLs).
2211
+
// This catches duplicate windows even when no key was provided.
2212
+
if (url.startsWith('http://') || url.startsWith('https://')) {
2213
+
const existingByUrl = findWindowByUrl(url);
2214
+
if (existingByUrl) {
2215
+
DEBUG && console.log('Reusing existing window with same URL:', url);
2216
+
if (!isHeadless()) {
2217
+
existingByUrl.window.show();
2218
+
existingByUrl.window.focus();
2219
+
}
2220
+
return { success: true, id: existingByUrl.id, reused: true };
2221
+
}
2207
2222
}
2208
2223
2209
2224
// Determine frame setting based on explicit option or preference
+38
-35
backend/electron/main.ts
+38
-35
backend/electron/main.ts
···
616
616
.map((cmd: ManifestCommand) => `cmd:execute:${cmd.name}`);
617
617
}
618
618
619
-
const VERIFY_POLL_INTERVAL_MS = 5;
620
-
const VERIFY_MAX_ATTEMPTS = 10;
621
-
622
-
function handleLazyExtensionReady(extId: string): void {
623
-
DEBUG && console.log(`[ext:lazy] Extension ready: ${extId}`);
619
+
function handleLazyExtensionReady(extId: string, registeredTopics?: string[]): void {
624
620
lazyExtensionLoaded.add(extId);
625
621
loadedConsolidatedExtensions.add(extId);
626
622
627
623
const callbacks = lazyLoadCallbacks.get(extId) || [];
628
624
lazyLoadCallbacks.delete(extId);
629
625
626
+
// Assert-and-trust: verify subscribers are registered, log errors but resolve immediately
630
627
const expectedTopics = getExpectedCommandTopics(extId);
631
-
632
-
function allSubscribed(): boolean {
633
-
// Exclude lazy-stub subscribers — they're about to be removed
634
-
return expectedTopics.every(topic => hasSubscriber(topic, undefined, 'lazy-stub/'));
635
-
}
636
-
637
-
function resolveAll(): void {
638
-
for (const cb of callbacks) {
639
-
cb();
628
+
if (expectedTopics.length > 0) {
629
+
const missing = expectedTopics.filter(t => !hasSubscriber(t, undefined, 'lazy-stub/'));
630
+
if (missing.length > 0) {
631
+
// Cross-check with registeredTopics from the extension if provided
632
+
if (registeredTopics && registeredTopics.length > 0) {
633
+
const extMissing = expectedTopics.filter(t => !registeredTopics.includes(t));
634
+
if (extMissing.length > 0) {
635
+
console.error(`[ext:lazy] Extension ${extId} did not register expected topics: ${extMissing.join(', ')}`);
636
+
}
637
+
}
638
+
console.error(`[ext:lazy] Extension ${extId} ready but missing subscribers: ${missing.join(', ')}`);
640
639
}
641
640
}
642
641
643
-
// Fast path: all subscriptions already registered (common case)
644
-
if (expectedTopics.length === 0 || allSubscribed()) {
645
-
resolveAll();
646
-
return;
642
+
DEBUG && console.log(`[ext:lazy] Extension ${extId} ready, resolving ${callbacks.length} callbacks`);
643
+
644
+
// Resolve immediately — the extension said it's ready, trust it
645
+
for (const cb of callbacks) {
646
+
cb();
647
647
}
648
-
649
-
// Poll briefly for subscriptions to appear
650
-
let attempts = 0;
651
-
const timer = setInterval(() => {
652
-
attempts++;
653
-
if (allSubscribed()) {
654
-
clearInterval(timer);
655
-
resolveAll();
656
-
} else if (attempts >= VERIFY_MAX_ATTEMPTS) {
657
-
clearInterval(timer);
658
-
const missing = expectedTopics.filter(t => !hasSubscriber(t));
659
-
console.warn(`[ext:lazy] Extension ${extId} ready but missing subscribers after ${VERIFY_MAX_ATTEMPTS} attempts: ${missing.join(', ')}`);
660
-
resolveAll(); // Resolve anyway to avoid hang
661
-
}
662
-
}, VERIFY_POLL_INTERVAL_MS);
663
648
}
664
649
665
650
/**
···
687
672
lazyCommandPending.set(cmd.name, msg);
688
673
689
674
if (alreadyLoading) {
690
-
DEBUG && console.log(`[ext:lazy] Command ${cmd.name} invoked again during load, buffering`);
691
675
return;
692
676
}
693
677
···
1272
1256
// This resolves lazy-load promises so the stub can safely re-publish commands.
1273
1257
subscribe(getSystemAddress(), scopes.SYSTEM, 'ext:ready', (data: unknown) => {
1274
1258
const extId = (data as { id?: string })?.id;
1259
+
const registeredTopics = (data as { registeredTopics?: string[] })?.registeredTopics;
1275
1260
if (extId) {
1276
-
handleLazyExtensionReady(extId);
1261
+
handleLazyExtensionReady(extId, registeredTopics);
1277
1262
}
1278
1263
});
1279
1264
···
1646
1631
if (win.source === source && win.params && win.params.key === key) {
1647
1632
const browserWindow = BrowserWindow.fromId(id);
1648
1633
if (browserWindow) {
1634
+
return { id, window: browserWindow, data: win };
1635
+
}
1636
+
}
1637
+
}
1638
+
return null;
1639
+
}
1640
+
1641
+
/**
1642
+
* Find an existing window that has the given URL loaded (by address param).
1643
+
* Only searches for http/https URLs. Returns the first match.
1644
+
*/
1645
+
export function findWindowByUrl(url: string): { id: number; window: BrowserWindow; data: unknown } | null {
1646
+
if (!url || (!url.startsWith('http://') && !url.startsWith('https://'))) return null;
1647
+
1648
+
for (const [id, win] of windowRegistry) {
1649
+
if (win.params && win.params.address === url) {
1650
+
const browserWindow = BrowserWindow.fromId(id);
1651
+
if (browserWindow && !browserWindow.isDestroyed()) {
1649
1652
return { id, window: browserWindow, data: win };
1650
1653
}
1651
1654
}
+5
features/editor/background.html
+5
features/editor/background.html
···
23
23
await extension.init();
24
24
}
25
25
26
+
// Collect registered command topics for assertion verification
27
+
const registeredTopics = Object.keys(window._cmdHandlers || {})
28
+
.map(name => `cmd:execute:${name}`);
29
+
26
30
// Signal ready to main process
27
31
api.publish('ext:ready', {
28
32
id: extId,
33
+
registeredTopics,
29
34
manifest: {
30
35
id: extension.id,
31
36
labels: extension.labels,
+7
-6
features/entities/background.html
+7
-6
features/entities/background.html
···
14
14
15
15
console.log(`[ext:${extId}] background.html loaded`);
16
16
17
+
// Initialize extension BEFORE publishing ext:ready
18
+
// (commands must be registered before lazy stub re-publishes)
19
+
if (extension.init) {
20
+
console.log(`[ext:${extId}] calling init()`);
21
+
await extension.init();
22
+
}
23
+
17
24
// Signal ready to main process
18
25
api.publish('ext:ready', {
19
26
id: extId,
···
23
30
version: '1.0.0'
24
31
}
25
32
}, api.scopes.SYSTEM);
26
-
27
-
// Initialize extension
28
-
if (extension.init) {
29
-
console.log(`[ext:${extId}] calling init()`);
30
-
extension.init();
31
-
}
32
33
33
34
// Handle shutdown request from main process
34
35
api.subscribe('app:shutdown', () => {
+12
-6
features/files/background.html
+12
-6
features/files/background.html
···
14
14
15
15
console.log(`[ext:${extId}] background.html loaded`);
16
16
17
+
// Initialize extension BEFORE publishing ext:ready
18
+
// (commands must be registered before lazy stub re-publishes)
19
+
if (extension.init) {
20
+
console.log(`[ext:${extId}] calling init()`);
21
+
await extension.init();
22
+
}
23
+
24
+
// Collect registered command topics for assertion verification
25
+
const registeredTopics = Object.keys(window._cmdHandlers || {})
26
+
.map(name => `cmd:execute:${name}`);
27
+
17
28
// Signal ready to main process
18
29
api.publish('ext:ready', {
19
30
id: extId,
31
+
registeredTopics,
20
32
manifest: {
21
33
id: extension.id,
22
34
labels: extension.labels,
23
35
version: '1.0.0'
24
36
}
25
37
}, api.scopes.SYSTEM);
26
-
27
-
// Initialize extension
28
-
if (extension.init) {
29
-
console.log(`[ext:${extId}] calling init()`);
30
-
extension.init();
31
-
}
32
38
33
39
// Handle shutdown request from main process
34
40
api.subscribe('app:shutdown', () => {
+12
-6
features/groups/background.html
+12
-6
features/groups/background.html
···
14
14
15
15
console.log(`[ext:${extId}] background.html loaded`);
16
16
17
+
// Initialize extension BEFORE publishing ext:ready
18
+
// (commands must be registered before lazy stub re-publishes)
19
+
if (extension.init) {
20
+
console.log(`[ext:${extId}] calling init()`);
21
+
await extension.init();
22
+
}
23
+
24
+
// Collect registered command topics for assertion verification
25
+
const registeredTopics = Object.keys(window._cmdHandlers || {})
26
+
.map(name => `cmd:execute:${name}`);
27
+
17
28
// Signal ready to main process
18
29
api.publish('ext:ready', {
19
30
id: extId,
31
+
registeredTopics,
20
32
manifest: {
21
33
id: extension.id,
22
34
labels: extension.labels,
23
35
version: '1.0.0'
24
36
}
25
37
}, api.scopes.SYSTEM);
26
-
27
-
// Initialize extension
28
-
if (extension.init) {
29
-
console.log(`[ext:${extId}] calling init()`);
30
-
extension.init();
31
-
}
32
38
33
39
// Handle shutdown request from main process
34
40
api.subscribe('app:shutdown', () => {
+1
-1
features/groups/config.js
+1
-1
features/groups/config.js
+27
features/groups/home.css
+27
features/groups/home.css
···
197
197
color: var(--base00);
198
198
}
199
199
200
+
/* Card remove-from-group button */
201
+
.card-remove-group-btn {
202
+
display: flex;
203
+
align-items: center;
204
+
justify-content: center;
205
+
width: 22px;
206
+
height: 22px;
207
+
background: transparent;
208
+
border: none;
209
+
border-radius: 4px;
210
+
cursor: pointer;
211
+
color: var(--base03);
212
+
flex-shrink: 0;
213
+
transition: all 0.15s;
214
+
padding: 0;
215
+
opacity: 0;
216
+
}
217
+
218
+
peek-card:hover .card-remove-group-btn {
219
+
opacity: 1;
220
+
}
221
+
222
+
.card-remove-group-btn:hover {
223
+
background: var(--base08);
224
+
color: var(--base00);
225
+
}
226
+
200
227
/* Card tags */
201
228
.card-tags {
202
229
display: flex;
+32
features/groups/home.js
+32
features/groups/home.js
···
933
933
934
934
card.dataset.addressId = address.id;
935
935
936
+
// Add "remove from group" button when viewing a real tag group (not untagged)
937
+
if (state.currentTag && !state.currentTag.isSpecial) {
938
+
const header = card.querySelector('[slot="header"]');
939
+
if (header) {
940
+
// Find or create the button group container
941
+
let btnGroup = header.querySelector('.card-btn-group');
942
+
if (!btnGroup) {
943
+
btnGroup = document.createElement('span');
944
+
btnGroup.className = 'card-btn-group';
945
+
header.appendChild(btnGroup);
946
+
}
947
+
const removeBtn = document.createElement('button');
948
+
removeBtn.className = 'card-remove-group-btn';
949
+
removeBtn.title = `Remove from ${state.currentTag.name}`;
950
+
removeBtn.innerHTML =
951
+
'<svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">' +
952
+
'<line x1="18" y1="6" x2="6" y2="18"></line>' +
953
+
'<line x1="6" y1="6" x2="18" y2="18"></line>' +
954
+
'</svg>';
955
+
removeBtn.addEventListener('click', async (e) => {
956
+
e.stopPropagation();
957
+
try {
958
+
await api.datastore.untagItem(address.id, state.currentTag.id);
959
+
api.publish('tag:item-removed', { itemId: address.id, tagId: state.currentTag.id }, api.scopes.GLOBAL);
960
+
} catch (err) {
961
+
console.error('[groups] Failed to remove item from group:', err);
962
+
}
963
+
});
964
+
btnGroup.appendChild(removeBtn);
965
+
}
966
+
}
967
+
936
968
// Show pin indicator if item is pinned in this group
937
969
if (address._pinned) {
938
970
const header = card.querySelector('[slot="header"]');
+12
-6
features/helpdocs/background.html
+12
-6
features/helpdocs/background.html
···
14
14
15
15
console.log(`[ext:${extId}] background.html loaded`);
16
16
17
+
// Initialize extension BEFORE publishing ext:ready
18
+
// (commands must be registered before lazy stub re-publishes)
19
+
if (extension.init) {
20
+
console.log(`[ext:${extId}] calling init()`);
21
+
await extension.init();
22
+
}
23
+
24
+
// Collect registered command topics for assertion verification
25
+
const registeredTopics = Object.keys(window._cmdHandlers || {})
26
+
.map(name => `cmd:execute:${name}`);
27
+
17
28
// Signal ready to main process
18
29
api.publish('ext:ready', {
19
30
id: extId,
31
+
registeredTopics,
20
32
manifest: {
21
33
id: extension.id,
22
34
labels: extension.labels,
23
35
version: '1.0.0'
24
36
}
25
37
}, api.scopes.SYSTEM);
26
-
27
-
// Initialize extension
28
-
if (extension.init) {
29
-
console.log(`[ext:${extId}] calling init()`);
30
-
extension.init();
31
-
}
32
38
33
39
// Handle shutdown request from main process
34
40
api.subscribe('app:shutdown', () => {
+5
features/lex/background.html
+5
features/lex/background.html
···
24
24
await extension.init();
25
25
}
26
26
27
+
// Collect registered command topics for assertion verification
28
+
const registeredTopics = Object.keys(window._cmdHandlers || {})
29
+
.map(name => `cmd:execute:${name}`);
30
+
27
31
// Signal ready to main process (after init so noun handlers are registered)
28
32
api.publish('ext:ready', {
29
33
id: extId,
34
+
registeredTopics,
30
35
manifest: {
31
36
id: extension.id,
32
37
labels: extension.labels,
+5
features/lists/background.html
+5
features/lists/background.html
···
18
18
await extension.init();
19
19
}
20
20
21
+
// Collect registered command topics for assertion verification
22
+
const registeredTopics = Object.keys(window._cmdHandlers || {})
23
+
.map(name => `cmd:execute:${name}`);
24
+
21
25
// Signal ready to main process
22
26
api.publish('ext:ready', {
23
27
id: extId,
28
+
registeredTopics,
24
29
manifest: {
25
30
id: extension.id,
26
31
labels: extension.labels,
+12
-6
features/page/background.html
+12
-6
features/page/background.html
···
14
14
15
15
console.log(`[ext:${extId}] background.html loaded`);
16
16
17
+
// Initialize extension BEFORE publishing ext:ready
18
+
// (commands must be registered before lazy stub re-publishes)
19
+
if (extension.init) {
20
+
console.log(`[ext:${extId}] calling init()`);
21
+
await extension.init();
22
+
}
23
+
24
+
// Collect registered command topics for assertion verification
25
+
const registeredTopics = Object.keys(window._cmdHandlers || {})
26
+
.map(name => `cmd:execute:${name}`);
27
+
17
28
// Signal ready to main process
18
29
api.publish('ext:ready', {
19
30
id: extId,
31
+
registeredTopics,
20
32
manifest: {
21
33
id: extension.id,
22
34
labels: extension.labels,
23
35
version: '1.0.0'
24
36
}
25
37
}, api.scopes.SYSTEM);
26
-
27
-
// Initialize extension
28
-
if (extension.init) {
29
-
console.log(`[ext:${extId}] calling init()`);
30
-
extension.init();
31
-
}
32
38
33
39
// Handle shutdown request from main process
34
40
api.subscribe('app:shutdown', () => {
+5
features/pagestream/background.html
+5
features/pagestream/background.html
···
21
21
await extension.init();
22
22
}
23
23
24
+
// Collect registered command topics for assertion verification
25
+
const registeredTopics = Object.keys(window._cmdHandlers || {})
26
+
.map(name => `cmd:execute:${name}`);
27
+
24
28
// Signal ready to main process
25
29
api.publish('ext:ready', {
26
30
id: extId,
31
+
registeredTopics,
27
32
manifest: {
28
33
id: extension.id,
29
34
labels: extension.labels,
+1
-1
features/pagestream/config.js
+1
-1
features/pagestream/config.js
+7
-6
features/peeks/background.html
+7
-6
features/peeks/background.html
···
14
14
15
15
console.log(`[ext:${extId}] background.html loaded`);
16
16
17
+
// Initialize extension BEFORE publishing ext:ready
18
+
// (commands must be registered before lazy stub re-publishes)
19
+
if (extension.init) {
20
+
console.log(`[ext:${extId}] calling init()`);
21
+
await extension.init();
22
+
}
23
+
17
24
// Signal ready to main process
18
25
api.publish('ext:ready', {
19
26
id: extId,
···
23
30
version: '1.0.0'
24
31
}
25
32
}, api.scopes.SYSTEM);
26
-
27
-
// Initialize extension
28
-
if (extension.init) {
29
-
console.log(`[ext:${extId}] calling init()`);
30
-
extension.init();
31
-
}
32
33
33
34
// Handle shutdown request from main process
34
35
api.subscribe('app:shutdown', () => {
+1
-1
features/peeks/config.js
+1
-1
features/peeks/config.js
+7
-6
features/scripts/background.html
+7
-6
features/scripts/background.html
···
14
14
15
15
console.log(`[ext:${extId}] background.html loaded`);
16
16
17
+
// Initialize extension BEFORE publishing ext:ready
18
+
// (commands must be registered before lazy stub re-publishes)
19
+
if (extension.init) {
20
+
console.log(`[ext:${extId}] calling init()`);
21
+
await extension.init();
22
+
}
23
+
17
24
// Signal ready to main process
18
25
api.publish('ext:ready', {
19
26
id: extId,
···
23
30
version: '1.0.0'
24
31
}
25
32
}, api.scopes.SYSTEM);
26
-
27
-
// Initialize extension
28
-
if (extension.init) {
29
-
console.log(`[ext:${extId}] calling init()`);
30
-
extension.init();
31
-
}
32
33
33
34
// Handle shutdown request from main process
34
35
api.subscribe('app:shutdown', () => {
+5
features/search/background.html
+5
features/search/background.html
···
18
18
await extension.init();
19
19
}
20
20
21
+
// Collect registered command topics for assertion verification
22
+
const registeredTopics = Object.keys(window._cmdHandlers || {})
23
+
.map(name => `cmd:execute:${name}`);
24
+
21
25
// Signal ready to main process
22
26
api.publish('ext:ready', {
23
27
id: extId,
28
+
registeredTopics,
24
29
manifest: {
25
30
id: extension.id,
26
31
version: '1.0.0'
+12
-6
features/sheets/background.html
+12
-6
features/sheets/background.html
···
14
14
15
15
console.log(`[ext:${extId}] background.html loaded`);
16
16
17
+
// Initialize extension BEFORE publishing ext:ready
18
+
// (commands must be registered before lazy stub re-publishes)
19
+
if (extension.init) {
20
+
console.log(`[ext:${extId}] calling init()`);
21
+
await extension.init();
22
+
}
23
+
24
+
// Collect registered command topics for assertion verification
25
+
const registeredTopics = Object.keys(window._cmdHandlers || {})
26
+
.map(name => `cmd:execute:${name}`);
27
+
17
28
// Signal ready to main process
18
29
api.publish('ext:ready', {
19
30
id: extId,
31
+
registeredTopics,
20
32
manifest: {
21
33
id: extension.id,
22
34
labels: extension.labels,
23
35
version: '1.0.0'
24
36
}
25
37
}, api.scopes.SYSTEM);
26
-
27
-
// Initialize extension
28
-
if (extension.init) {
29
-
console.log(`[ext:${extId}] calling init()`);
30
-
extension.init();
31
-
}
32
38
33
39
// Handle shutdown request from main process
34
40
api.subscribe('app:shutdown', () => {
+7
-6
features/slides/background.html
+7
-6
features/slides/background.html
···
14
14
15
15
console.log(`[ext:${extId}] background.html loaded`);
16
16
17
+
// Initialize extension BEFORE publishing ext:ready
18
+
// (commands must be registered before lazy stub re-publishes)
19
+
if (extension.init) {
20
+
console.log(`[ext:${extId}] calling init()`);
21
+
await extension.init();
22
+
}
23
+
17
24
// Signal ready to main process
18
25
api.publish('ext:ready', {
19
26
id: extId,
···
23
30
version: '1.0.0'
24
31
}
25
32
}, api.scopes.SYSTEM);
26
-
27
-
// Initialize extension
28
-
if (extension.init) {
29
-
console.log(`[ext:${extId}] calling init()`);
30
-
extension.init();
31
-
}
32
33
33
34
// Handle shutdown request from main process
34
35
api.subscribe('app:shutdown', () => {
+1
-1
features/slides/config.js
+1
-1
features/slides/config.js
+7
-6
features/sync/background.html
+7
-6
features/sync/background.html
···
14
14
15
15
console.log(`[ext:${extId}] background.html loaded`);
16
16
17
+
// Initialize extension BEFORE publishing ext:ready
18
+
// (commands must be registered before lazy stub re-publishes)
19
+
if (extension.init) {
20
+
console.log(`[ext:${extId}] calling init()`);
21
+
await extension.init();
22
+
}
23
+
17
24
// Signal ready to main process
18
25
api.publish('ext:ready', {
19
26
id: extId,
···
23
30
version: '1.0.0'
24
31
}
25
32
}, api.scopes.SYSTEM);
26
-
27
-
// Initialize extension
28
-
if (extension.init) {
29
-
console.log(`[ext:${extId}] calling init()`);
30
-
extension.init();
31
-
}
32
33
33
34
// Handle shutdown request from main process
34
35
api.subscribe('app:shutdown', () => {
+5
features/timers/background.html
+5
features/timers/background.html
···
18
18
await extension.init();
19
19
}
20
20
21
+
// Collect registered command topics for assertion verification
22
+
const registeredTopics = Object.keys(window._cmdHandlers || {})
23
+
.map(name => `cmd:execute:${name}`);
24
+
21
25
// Signal ready to main process
22
26
api.publish('ext:ready', {
23
27
id: extId,
28
+
registeredTopics,
24
29
manifest: {
25
30
id: extension.id,
26
31
labels: extension.labels,
+5
features/websearch/background.html
+5
features/websearch/background.html
···
18
18
await extension.init();
19
19
}
20
20
21
+
// Collect registered command topics for assertion verification
22
+
const registeredTopics = Object.keys(window._cmdHandlers || {})
23
+
.map(name => `cmd:execute:${name}`);
24
+
21
25
// Signal ready to main process
22
26
api.publish('ext:ready', {
23
27
id: extId,
28
+
registeredTopics,
24
29
manifest: {
25
30
id: extension.id,
26
31
labels: extension.labels,
+32
-57
features/websearch/background.js
+32
-57
features/websearch/background.js
···
20
20
const api = window.app;
21
21
const debug = api.debug;
22
22
23
-
// ===== BroadcastChannel for intra-extension messaging =====
24
-
// Falls back to IPC pubsub if BroadcastChannel is unavailable (e.g., custom protocol origins)
25
-
26
-
let wsChannel = null;
27
-
const wsChannelHandlers = {};
28
-
29
-
try {
30
-
wsChannel = new BroadcastChannel('websearch');
31
-
wsChannel.onmessage = (e) => {
32
-
const { topic, data } = e.data;
33
-
if (wsChannelHandlers[topic]) {
34
-
for (const handler of wsChannelHandlers[topic]) {
35
-
handler(data);
36
-
}
37
-
}
38
-
};
39
-
} catch (err) {
40
-
console.warn('[ext:websearch] BroadcastChannel unavailable, using IPC fallback:', err.message);
41
-
}
23
+
// ===== IPC pubsub messaging =====
24
+
// Background runs at peek://ext/websearch/ while home runs at peek://websearch/
25
+
// — different origins, so BroadcastChannel cannot work. Use IPC pubsub instead.
42
26
43
27
function onChannel(topic, handler) {
44
-
if (!wsChannelHandlers[topic]) wsChannelHandlers[topic] = [];
45
-
wsChannelHandlers[topic].push(handler);
46
-
// IPC fallback
47
-
if (!wsChannel) {
48
-
api.subscribe(topic, handler, api.scopes.GLOBAL);
49
-
}
28
+
api.subscribe(topic, handler, api.scopes.GLOBAL);
50
29
}
51
30
52
31
function emitChannel(topic, data) {
53
-
if (wsChannel) {
54
-
wsChannel.postMessage({ topic, data });
55
-
} else {
56
-
api.publish(topic, data, api.scopes.GLOBAL);
57
-
}
32
+
api.publish(topic, data, api.scopes.GLOBAL);
58
33
}
59
34
60
-
// Use peek://websearch/ origin (same as background iframe) so BroadcastChannel works
61
35
const address = 'peek://websearch/home.html';
62
36
63
37
// ===== State =====
···
224
198
const url = buildSearchUrl(engine.searchUrl, query.trim());
225
199
debug && console.log('[ext:websearch] Searching:', engine.name, query, '->', url);
226
200
227
-
try {
228
-
await api.window.open(url, {
229
-
role: 'content',
230
-
key: url,
231
-
width: 1024,
232
-
height: 768,
233
-
trackingSource: 'websearch',
234
-
trackingSourceId: engine.id
235
-
});
236
-
} catch (err) {
201
+
api.window.open(url, {
202
+
role: 'content',
203
+
key: url,
204
+
width: 1024,
205
+
height: 768,
206
+
trackingSource: 'websearch',
207
+
trackingSourceId: engine.id
208
+
}).catch(err => {
237
209
console.error('[ext:websearch] Failed to open search window:', err);
238
-
}
210
+
});
239
211
};
240
212
241
213
// ===== Search Suggestions =====
···
459
431
// ===== Search Window =====
460
432
461
433
let isOpeningSearch = false;
462
-
const openSearchWindow = async () => {
434
+
const openSearchWindow = () => {
463
435
if (isOpeningSearch) return;
464
436
isOpeningSearch = true;
465
-
try {
466
-
const params = {
467
-
role: 'workspace',
468
-
key: address,
469
-
height: 500,
470
-
width: 600,
471
-
trackingSource: 'cmd',
472
-
trackingSourceId: 'websearch'
473
-
};
474
437
475
-
const window = await api.window.open(address, params);
438
+
const params = {
439
+
role: 'workspace',
440
+
key: address,
441
+
height: 500,
442
+
width: 600,
443
+
trackingSource: 'cmd',
444
+
trackingSourceId: 'websearch'
445
+
};
446
+
447
+
api.window.open(address, params).then(window => {
476
448
debug && console.log('[ext:websearch] Search window opened:', window);
477
449
searchWindowId = window?.id || null;
478
-
} catch (error) {
450
+
}).catch(error => {
479
451
console.error('[ext:websearch] Failed to open search window:', error);
480
-
} finally {
452
+
}).finally(() => {
481
453
isOpeningSearch = false;
482
-
}
454
+
});
483
455
};
484
456
485
457
// ===== Command Definitions =====
···
496
468
} else {
497
469
openSearchWindow();
498
470
}
471
+
return { success: true };
499
472
}
500
473
},
501
474
{
···
503
476
description: 'Open the web search window',
504
477
execute: async (ctx) => {
505
478
openSearchWindow();
479
+
return { success: true };
506
480
}
507
481
}
508
482
];
···
528
502
} else {
529
503
openSearchWindow();
530
504
}
505
+
return { success: true };
531
506
}
532
507
};
533
508
api.commands.register(cmd);
···
694
669
// Load custom engines from datastore
695
670
await loadEngines();
696
671
697
-
// Register commands (cmd loads first with its subscribers ready via 100ms head start)
672
+
// Register commands (after settings/engines are loaded so we register once)
698
673
initCommands();
699
674
700
675
// Listen for page load events for OpenSearch discovery
+1
-1
features/websearch/config.js
+1
-1
features/websearch/config.js
+1
-1
features/websearch/home.html
+1
-1
features/websearch/home.html
···
31
31
<body>
32
32
<div class="search-container">
33
33
<div class="engine-indicator" id="engine-indicator">
34
-
<img id="engine-icon" class="engine-icon" src="" alt="">
34
+
<img id="engine-icon" class="engine-icon" src="" alt="" style="display:none">
35
35
<span id="engine-name" class="engine-name"></span>
36
36
</div>
37
37
<peek-input
+5
-29
features/websearch/home.js
+5
-29
features/websearch/home.js
···
11
11
const api = window.app;
12
12
const debug = api.debug;
13
13
14
-
// ===== BroadcastChannel for intra-extension messaging =====
15
-
// Falls back to IPC pubsub if BroadcastChannel is unavailable (e.g., custom protocol origins)
16
-
17
-
let wsChannel = null;
18
-
const wsChannelHandlers = {};
19
-
20
-
try {
21
-
wsChannel = new BroadcastChannel('websearch');
22
-
wsChannel.onmessage = (e) => {
23
-
const { topic, data } = e.data;
24
-
if (wsChannelHandlers[topic]) {
25
-
for (const handler of wsChannelHandlers[topic]) {
26
-
handler(data);
27
-
}
28
-
}
29
-
};
30
-
} catch (err) {
31
-
console.warn('[websearch] BroadcastChannel unavailable, using IPC fallback:', err.message);
32
-
}
14
+
// ===== IPC pubsub messaging =====
15
+
// Background runs at peek://ext/websearch/ while home runs at peek://websearch/
16
+
// — different origins, so BroadcastChannel cannot work. Use IPC pubsub instead.
33
17
34
18
function onChannel(topic, handler) {
35
-
if (!wsChannelHandlers[topic]) wsChannelHandlers[topic] = [];
36
-
wsChannelHandlers[topic].push(handler);
37
-
if (!wsChannel) {
38
-
api.subscribe(topic, handler, api.scopes.GLOBAL);
39
-
}
19
+
api.subscribe(topic, handler, api.scopes.GLOBAL);
40
20
}
41
21
42
22
function emitChannel(topic, data) {
43
-
if (wsChannel) {
44
-
wsChannel.postMessage({ topic, data });
45
-
} else {
46
-
api.publish(topic, data, api.scopes.GLOBAL);
47
-
}
23
+
api.publish(topic, data, api.scopes.GLOBAL);
48
24
}
49
25
50
26
// ===== Utilities =====
+12
-6
features/windows/background.html
+12
-6
features/windows/background.html
···
14
14
15
15
console.log(`[ext:${extId}] background.html loaded`);
16
16
17
+
// Initialize extension BEFORE publishing ext:ready
18
+
// (commands must be registered before lazy stub re-publishes)
19
+
if (extension.init) {
20
+
console.log(`[ext:${extId}] calling init()`);
21
+
await extension.init();
22
+
}
23
+
24
+
// Collect registered command topics for assertion verification
25
+
const registeredTopics = Object.keys(window._cmdHandlers || {})
26
+
.map(name => `cmd:execute:${name}`);
27
+
17
28
// Signal ready to main process
18
29
api.publish('ext:ready', {
19
30
id: extId,
31
+
registeredTopics,
20
32
manifest: {
21
33
id: extension.id,
22
34
labels: extension.labels,
23
35
version: '1.0.0'
24
36
}
25
37
}, api.scopes.SYSTEM);
26
-
27
-
// Initialize extension
28
-
if (extension.init) {
29
-
console.log(`[ext:${extId}] calling init()`);
30
-
extension.init();
31
-
}
32
38
33
39
// Handle shutdown request from main process
34
40
api.subscribe('app:shutdown', () => {
+2
preload.js
+2
preload.js
+348
tests/desktop/websearch-cmd.spec.ts
+348
tests/desktop/websearch-cmd.spec.ts
···
1
+
/**
2
+
* Websearch Command Panel Hang Regression Test
3
+
*
4
+
* Regression test for the bug where running "kagi test" from the cmd palette UI
5
+
* would hang (progress bar spins forever, 30s timeout), even though the same
6
+
* command works fine when invoked directly via pubsub.
7
+
*
8
+
* The test goes through the actual cmd panel UI flow:
9
+
* Open cmd panel → type "kagi test" → Enter → wait for result
10
+
*
11
+
* If the command hangs, the test FAILS (20s timeout, well under the 30s proxy timeout).
12
+
* Includes a direct pubsub control test to confirm the extension itself works.
13
+
*
14
+
* Run with:
15
+
* yarn test:electron:x
16
+
*/
17
+
18
+
import { test, expect, DesktopApp, getSharedApp, closeSharedApp } from '../fixtures/desktop-app';
19
+
import { Page } from '@playwright/test';
20
+
import {
21
+
waitForExtensionsReady,
22
+
waitForCommandResults,
23
+
waitForPanelCommandsLoaded,
24
+
sleep,
25
+
} from '../helpers/window-utils';
26
+
27
+
let sharedApp: DesktopApp;
28
+
let sharedBgWindow: Page;
29
+
30
+
test.beforeAll(async () => {
31
+
sharedApp = await getSharedApp();
32
+
sharedBgWindow = await sharedApp.getBackgroundWindow();
33
+
await waitForExtensionsReady(sharedBgWindow);
34
+
});
35
+
36
+
test.afterAll(async () => {
37
+
await closeSharedApp();
38
+
});
39
+
40
+
// Helper to open the cmd panel and return the panel window + open result
41
+
async function openCmdPanel(bgWindow: Page, app: DesktopApp) {
42
+
const openResult = await bgWindow.evaluate(async () => {
43
+
return await (window as any).app.window.open('peek://ext/cmd/panel.html', {
44
+
modal: true,
45
+
width: 600,
46
+
height: 50,
47
+
frame: false,
48
+
transparent: true,
49
+
alwaysOnTop: true,
50
+
center: true,
51
+
});
52
+
});
53
+
expect(openResult.success).toBe(true);
54
+
55
+
const cmdWindow = await app.getWindow('cmd/panel.html', 5000);
56
+
expect(cmdWindow).toBeTruthy();
57
+
58
+
await cmdWindow.waitForSelector('input', { timeout: 5000 });
59
+
await waitForPanelCommandsLoaded(cmdWindow, 10000);
60
+
61
+
return { cmdWindow, windowId: openResult.id };
62
+
}
63
+
64
+
// Helper to close cmd panel
65
+
async function closeCmdPanel(bgWindow: Page, windowId: number) {
66
+
try {
67
+
await bgWindow.evaluate(async (id: number) => {
68
+
return await (window as any).app.window.close(id);
69
+
}, windowId);
70
+
} catch {
71
+
// Panel may have already closed
72
+
}
73
+
}
74
+
75
+
// Ensure the websearch extension is loaded before our UI tests
76
+
async function ensureWebsearchLoaded(bgWindow: Page) {
77
+
const loaded = await bgWindow.evaluate(async () => {
78
+
const api = (window as any).app;
79
+
80
+
// Check if already loaded
81
+
const extResult = await api.extensions.list();
82
+
if (extResult.success && extResult.data.some(
83
+
(e: { id: string; status: string }) => e.id === 'websearch' && e.status === 'running'
84
+
)) {
85
+
return true;
86
+
}
87
+
88
+
// Trigger lazy load via a non-hanging command
89
+
api.publish('cmd:execute:open web search', {}, api.scopes.GLOBAL);
90
+
91
+
// Wait for it to be running
92
+
const start = Date.now();
93
+
while (Date.now() - start < 15000) {
94
+
const result = await api.extensions.list();
95
+
if (result.success && result.data.some(
96
+
(e: { id: string; status: string }) => e.id === 'websearch' && e.status === 'running'
97
+
)) {
98
+
return true;
99
+
}
100
+
await new Promise(r => setTimeout(r, 200));
101
+
}
102
+
return false;
103
+
});
104
+
expect(loaded).toBe(true);
105
+
106
+
// Close any websearch window that was opened
107
+
await sleep(500);
108
+
const windows = sharedApp.windows();
109
+
for (const w of windows) {
110
+
if (w.url().includes('websearch/home.html')) {
111
+
const id = await bgWindow.evaluate(async (url: string) => {
112
+
const result = await (window as any).app.window.list({ includeInternal: false });
113
+
if (!result.success) return null;
114
+
const win = result.windows.find((w: any) => w.url?.includes('websearch/home.html'));
115
+
return win?.id || null;
116
+
}, w.url());
117
+
if (id) await closeCmdPanel(bgWindow, id);
118
+
}
119
+
}
120
+
}
121
+
122
+
test.describe('Websearch Cold-Start Lazy Loading @desktop', () => {
123
+
124
+
test('cold-start: kagi command triggers lazy load and completes', async () => {
125
+
// This test exercises the full cold-start lazy loading path:
126
+
// stub fires → load extension → verify → replay → execute
127
+
// The websearch extension must NOT be pre-loaded.
128
+
129
+
// Verify websearch is NOT loaded yet (it's lazy, not eager)
130
+
const isLoaded = await sharedBgWindow.evaluate(async () => {
131
+
const result = await (window as any).app.extensions.list();
132
+
if (!result.success) return false;
133
+
return result.data.some(
134
+
(e: { id: string; status: string }) => e.id === 'websearch' && e.status === 'running'
135
+
);
136
+
});
137
+
// If it's already loaded (e.g., test order changed), skip gracefully
138
+
if (isLoaded) {
139
+
console.log('websearch already loaded — cold-start test skipped (run this test first for coverage)');
140
+
return;
141
+
}
142
+
143
+
// Verify the kagi command exists as a lazy stub (registered from manifest)
144
+
const hasKagiStub = await sharedBgWindow.evaluate(async () => {
145
+
const result = await (window as any).app.commands.list();
146
+
if (!result.success) return false;
147
+
return result.data.some((c: { name: string }) => c.name === 'kagi');
148
+
});
149
+
expect(hasKagiStub).toBe(true);
150
+
151
+
// Open cmd panel
152
+
const { cmdWindow, windowId } = await openCmdPanel(sharedBgWindow, sharedApp);
153
+
154
+
try {
155
+
// Type "kagi test" and execute — this triggers the lazy loading path
156
+
await cmdWindow.fill('input', 'kagi test');
157
+
await cmdWindow.keyboard.press('Enter');
158
+
159
+
// Wait for the command to complete.
160
+
// The full path is: stub intercepts → loadLazyExtension → iframe created →
161
+
// extension init() → ext:ready → handleLazyExtensionReady (assert-and-trust) →
162
+
// callbacks resolve → stub replays message → command executes → result published
163
+
// This should complete well within 20s even with the extension loading overhead.
164
+
const executionResult = await cmdWindow.waitForFunction(
165
+
() => {
166
+
const state = (window as any)._cmdState;
167
+
if (!state) return null;
168
+
const currentState = state.currentState;
169
+
if (currentState !== 'EXECUTING') {
170
+
return { completed: true, finalState: currentState };
171
+
}
172
+
return null;
173
+
},
174
+
undefined,
175
+
{ timeout: 20000 }
176
+
);
177
+
178
+
const result = await executionResult.jsonValue() as { completed: boolean; finalState: string };
179
+
console.log('Cold-start kagi command completed with final state:', result.finalState);
180
+
181
+
expect(result.completed).toBe(true);
182
+
expect(result.finalState).not.toBe('ERROR');
183
+
184
+
// Verify the extension is now loaded after the lazy load
185
+
const nowLoaded = await sharedBgWindow.evaluate(async () => {
186
+
const result = await (window as any).app.extensions.list();
187
+
if (!result.success) return false;
188
+
return result.data.some(
189
+
(e: { id: string; status: string }) => e.id === 'websearch' && e.status === 'running'
190
+
);
191
+
});
192
+
expect(nowLoaded).toBe(true);
193
+
194
+
} finally {
195
+
await closeCmdPanel(sharedBgWindow, windowId);
196
+
}
197
+
});
198
+
});
199
+
200
+
test.describe('Websearch Cmd Panel Execution @desktop', () => {
201
+
202
+
test('kagi command via cmd panel UI does not hang', async () => {
203
+
// Pre-load the websearch extension so we isolate the proxy/UI issue
204
+
await ensureWebsearchLoaded(sharedBgWindow);
205
+
206
+
// Verify kagi command is registered
207
+
const hasKagi = await sharedBgWindow.evaluate(async () => {
208
+
const result = await (window as any).app.commands.list();
209
+
if (!result.success) return false;
210
+
return result.data.some((c: { name: string }) => c.name === 'kagi');
211
+
});
212
+
expect(hasKagi).toBe(true);
213
+
214
+
// Open cmd panel
215
+
const { cmdWindow, windowId } = await openCmdPanel(sharedBgWindow, sharedApp);
216
+
217
+
try {
218
+
// Type "kagi" to filter to the kagi command
219
+
await cmdWindow.fill('input', 'kagi');
220
+
await cmdWindow.keyboard.press('ArrowDown');
221
+
await waitForCommandResults(cmdWindow, 1, 10000);
222
+
223
+
// Verify the kagi command appears in results
224
+
const kagiVisible = await cmdWindow.evaluate(() => {
225
+
const items = document.querySelectorAll('.result-item, .command-item, [class*="result"]');
226
+
for (const item of items) {
227
+
if (item.textContent?.toLowerCase().includes('kagi')) return true;
228
+
}
229
+
return true; // If results are showing, kagi should be the match
230
+
});
231
+
expect(kagiVisible).toBe(true);
232
+
233
+
// Now type the full command with search query — "kagi test"
234
+
await cmdWindow.fill('input', 'kagi test');
235
+
236
+
// Press Enter to execute the command through the UI proxy flow
237
+
await cmdWindow.keyboard.press('Enter');
238
+
239
+
// Wait for the command to complete (should NOT hang)
240
+
// The cmd panel state machine transitions to EXECUTING on Enter,
241
+
// then to IDLE/OUTPUT_SELECTION/CLOSING on completion.
242
+
// If it stays in EXECUTING for more than 15s, the command hung.
243
+
const executionResult = await cmdWindow.waitForFunction(
244
+
() => {
245
+
const state = (window as any)._cmdState;
246
+
if (!state) return null;
247
+
const currentState = state.currentState;
248
+
// EXECUTING = the command is still running
249
+
// Any other state means it completed (or errored)
250
+
if (currentState !== 'EXECUTING') {
251
+
return { completed: true, finalState: currentState };
252
+
}
253
+
return null; // Keep waiting
254
+
},
255
+
undefined,
256
+
{ timeout: 20000 } // 20s — well under the 30s proxy timeout
257
+
);
258
+
259
+
const result = await executionResult.jsonValue() as { completed: boolean; finalState: string };
260
+
console.log('Command completed with final state:', result.finalState);
261
+
262
+
// The command should have completed, not timed out
263
+
expect(result.completed).toBe(true);
264
+
// It should NOT be in ERROR state (timeout would cause ERROR)
265
+
expect(result.finalState).not.toBe('ERROR');
266
+
267
+
} finally {
268
+
await closeCmdPanel(sharedBgWindow, windowId);
269
+
}
270
+
});
271
+
272
+
test('google command via cmd panel UI does not hang', async () => {
273
+
// Test a second engine to confirm it is not kagi-specific
274
+
await ensureWebsearchLoaded(sharedBgWindow);
275
+
276
+
const { cmdWindow, windowId } = await openCmdPanel(sharedBgWindow, sharedApp);
277
+
278
+
try {
279
+
// Type "google test" and execute
280
+
await cmdWindow.fill('input', 'google test');
281
+
await cmdWindow.keyboard.press('Enter');
282
+
283
+
// Wait for execution to complete
284
+
const executionResult = await cmdWindow.waitForFunction(
285
+
() => {
286
+
const state = (window as any)._cmdState;
287
+
if (!state) return null;
288
+
const currentState = state.currentState;
289
+
if (currentState !== 'EXECUTING') {
290
+
return { completed: true, finalState: currentState };
291
+
}
292
+
return null;
293
+
},
294
+
undefined,
295
+
{ timeout: 20000 }
296
+
);
297
+
298
+
const result = await executionResult.jsonValue() as { completed: boolean; finalState: string };
299
+
console.log('Google command completed with final state:', result.finalState);
300
+
301
+
expect(result.completed).toBe(true);
302
+
expect(result.finalState).not.toBe('ERROR');
303
+
304
+
} finally {
305
+
await closeCmdPanel(sharedBgWindow, windowId);
306
+
}
307
+
});
308
+
309
+
test('direct pubsub kagi execution works (control test)', async () => {
310
+
// This is the control — same command via direct pubsub should work.
311
+
// If the UI test above fails but this passes, the bug is in the proxy flow.
312
+
await ensureWebsearchLoaded(sharedBgWindow);
313
+
314
+
const result = await sharedBgWindow.evaluate(async () => {
315
+
const api = (window as any).app;
316
+
317
+
return new Promise((resolve) => {
318
+
const resultTopic = 'cmd:execute:kagi:result';
319
+
let settled = false;
320
+
321
+
api.subscribe(resultTopic, (result: unknown) => {
322
+
if (settled) return;
323
+
settled = true;
324
+
resolve({ success: true, result });
325
+
}, api.scopes.GLOBAL);
326
+
327
+
api.publish('cmd:execute:kagi', {
328
+
typed: 'kagi test',
329
+
name: 'kagi',
330
+
params: ['test'],
331
+
search: 'test',
332
+
expectResult: true,
333
+
resultTopic,
334
+
}, api.scopes.GLOBAL);
335
+
336
+
setTimeout(() => {
337
+
if (settled) return;
338
+
settled = true;
339
+
resolve({ success: false, result: null });
340
+
}, 15000);
341
+
});
342
+
});
343
+
344
+
const execResult = result as { success: boolean; result: unknown };
345
+
console.log('Direct pubsub result:', JSON.stringify(execResult));
346
+
expect(execResult.success).toBe(true);
347
+
});
348
+
});
+140
tests/desktop/window-url.spec.ts
+140
tests/desktop/window-url.spec.ts
···
1
+
/**
2
+
* Window URL Loading and Reuse Tests
3
+
*
4
+
* Tests that:
5
+
* - Opening an http/https URL creates a window and returns success
6
+
* - Opening the same URL twice reuses the existing window (findWindowByUrl)
7
+
* - Opening two different URLs creates two separate windows
8
+
* - Key-based window reuse still works alongside URL-based reuse
9
+
*
10
+
* Run with:
11
+
* yarn test:electron -- --grep "Window URL"
12
+
*/
13
+
14
+
import { test, expect, DesktopApp, getSharedApp, closeSharedApp } from '../fixtures/desktop-app';
15
+
import { Page } from '@playwright/test';
16
+
import { waitForExtensionsReady } from '../helpers/window-utils';
17
+
18
+
// Shared app instance
19
+
let sharedApp: DesktopApp;
20
+
let sharedBgWindow: Page;
21
+
22
+
test.beforeAll(async () => {
23
+
sharedApp = await getSharedApp();
24
+
sharedBgWindow = await sharedApp.getBackgroundWindow();
25
+
await waitForExtensionsReady(sharedBgWindow);
26
+
});
27
+
28
+
test.afterAll(async () => {
29
+
await closeSharedApp();
30
+
});
31
+
32
+
// ============================================================================
33
+
// Helper: Open a web URL via the window API and return the result
34
+
// ============================================================================
35
+
36
+
async function openUrl(
37
+
bgWindow: Page,
38
+
url: string,
39
+
options: Record<string, unknown> = {}
40
+
): Promise<{ success: boolean; id: number; reused?: boolean }> {
41
+
const result = await bgWindow.evaluate(
42
+
async ({ url, options }: { url: string; options: Record<string, unknown> }) => {
43
+
return await (window as any).app.window.open(url, {
44
+
width: 800,
45
+
height: 600,
46
+
...options,
47
+
});
48
+
},
49
+
{ url, options }
50
+
);
51
+
return result;
52
+
}
53
+
54
+
// ============================================================================
55
+
// Helper: Close a window by ID
56
+
// ============================================================================
57
+
58
+
async function closeWindow(bgWindow: Page, windowId: number): Promise<void> {
59
+
await bgWindow.evaluate(async (id: number) => {
60
+
return await (window as any).app.window.close(id);
61
+
}, windowId);
62
+
}
63
+
64
+
// ============================================================================
65
+
// Window URL Tests
66
+
// ============================================================================
67
+
68
+
test.describe('Window URL Loading @desktop', () => {
69
+
test('opening an https URL creates a window', async () => {
70
+
const url = 'https://example.com/url-create-test';
71
+
const result = await openUrl(sharedBgWindow, url);
72
+
73
+
expect(result.success).toBe(true);
74
+
expect(result.id).toBeTruthy();
75
+
expect(result.reused).toBeFalsy();
76
+
77
+
// Clean up
78
+
await closeWindow(sharedBgWindow, result.id);
79
+
});
80
+
81
+
test('opening the same URL twice reuses the existing window', async () => {
82
+
const url = 'https://example.com/reuse-test';
83
+
84
+
// Open the first window
85
+
const result1 = await openUrl(sharedBgWindow, url);
86
+
expect(result1.success).toBe(true);
87
+
expect(result1.id).toBeTruthy();
88
+
expect(result1.reused).toBeFalsy();
89
+
90
+
// Open the same URL again -- should reuse
91
+
const result2 = await openUrl(sharedBgWindow, url);
92
+
expect(result2.success).toBe(true);
93
+
expect(result2.reused).toBe(true);
94
+
expect(result2.id).toBe(result1.id);
95
+
96
+
// Clean up
97
+
await closeWindow(sharedBgWindow, result1.id);
98
+
});
99
+
100
+
test('opening two different URLs creates two separate windows', async () => {
101
+
const url1 = 'https://example.com/page-one';
102
+
const url2 = 'https://example.org/page-two';
103
+
104
+
// Open first URL
105
+
const result1 = await openUrl(sharedBgWindow, url1);
106
+
expect(result1.success).toBe(true);
107
+
expect(result1.reused).toBeFalsy();
108
+
109
+
// Open second URL -- should create a new window, not reuse
110
+
const result2 = await openUrl(sharedBgWindow, url2);
111
+
expect(result2.success).toBe(true);
112
+
expect(result2.reused).toBeFalsy();
113
+
expect(result2.id).not.toBe(result1.id);
114
+
115
+
// Clean up both windows
116
+
await closeWindow(sharedBgWindow, result1.id);
117
+
await closeWindow(sharedBgWindow, result2.id);
118
+
});
119
+
120
+
test('key-based window reuse still works', async () => {
121
+
const url = 'https://example.com/key-test';
122
+
const key = 'test-key-reuse';
123
+
124
+
// Open a window with a key
125
+
const result1 = await openUrl(sharedBgWindow, url, { key });
126
+
expect(result1.success).toBe(true);
127
+
expect(result1.id).toBeTruthy();
128
+
expect(result1.reused).toBeFalsy();
129
+
130
+
// Open a different URL with the same key -- key-based reuse should take priority
131
+
const url2 = 'https://example.com/key-test-different';
132
+
const result2 = await openUrl(sharedBgWindow, url2, { key });
133
+
expect(result2.success).toBe(true);
134
+
expect(result2.reused).toBe(true);
135
+
expect(result2.id).toBe(result1.id);
136
+
137
+
// Clean up
138
+
await closeWindow(sharedBgWindow, result1.id);
139
+
});
140
+
});