Skip to content

Beautiful, AI-native markdown IDE and LLM wiki

PRD-8613: keep window probes from blocking readiness (#4821)

mike-inkeeped488ef59280
diff --git a/.changeset/prd-8613-fair-window-probes.md b/.changeset/prd-8613-fair-window-probes.md
new file mode 100644
index 000000000..b0b5767be
--- /dev/null
+++ b/.changeset/prd-8613-fair-window-probes.md
@@ -0,0 +1,6 @@
+---
+"@inkeep/open-knowledge": patch
+"@inkeep/open-knowledge-desktop": patch
+---
+
+Keep desktop smoke window discovery polling when another Electron page is slow to answer. Each page now has at most one mode probe in flight, so a newly ready editor is found without waiting behind an older stuck page.
diff --git a/packages/desktop/tests/smoke/_helpers/launch-readiness.test.ts b/packages/desktop/tests/smoke/_helpers/launch-readiness.test.ts
index f83a7997f..97a83c2eb 100644
--- a/packages/desktop/tests/smoke/_helpers/launch-readiness.test.ts
+++ b/packages/desktop/tests/smoke/_helpers/launch-readiness.test.ts
@@ -343,6 +343,167 @@ describe('waitForWindowByMode', () => {
});
expect(found).toBe(editor);
});
+
+ it('finds a ready page without waiting for an older pending page', async () => {
+ const pending = Promise.withResolvers<string | undefined>();
+ const navigator = { evaluate: () => pending.promise };
+ const editor = { evaluate: async () => 'editor' };
+ try {
+ await expect(
+ waitForWindowByMode({ windows: () => [navigator, editor] }, 'editor', {
+ home: '/unused',
+ capMs: 100,
+ stallMs: 600_000,
+ pollMs: 10,
+ }),
+ ).resolves.toBe(editor);
+ } finally {
+ pending.resolve('navigator');
+ }
+ });
+
+ it('finds a ready page that arrives while an older page is still pending', async () => {
+ const pending = Promise.withResolvers<string | undefined>();
+ const started = Promise.withResolvers<void>();
+ const navigator = {
+ evaluate: () => {
+ started.resolve();
+ return pending.promise;
+ },
+ };
+ const editor = { evaluate: async () => 'editor' };
+ let pages = [navigator];
+ const waiting = waitForWindowByMode({ windows: () => pages }, 'editor', {
+ home: '/unused',
+ capMs: 100,
+ stallMs: 600_000,
+ pollMs: 10,
+ });
+ await started.promise;
+ pages = [navigator, editor];
+ try {
+ await expect(waiting).resolves.toBe(editor);
+ } finally {
+ pending.resolve('navigator');
+ }
+ });
+
+ it('keeps at most one evaluation in flight per page and requests only on the poll cadence', async () => {
+ const pending = Promise.withResolvers<string | undefined>();
+ let pendingCalls = 0;
+ let pendingInFlight = 0;
+ let maxPendingInFlight = 0;
+ let navigatorCalls = 0;
+ const held = {
+ evaluate: () => {
+ pendingCalls += 1;
+ pendingInFlight += 1;
+ maxPendingInFlight = Math.max(maxPendingInFlight, pendingInFlight);
+ return pending.promise.finally(() => {
+ pendingInFlight -= 1;
+ });
+ },
+ };
+ const navigator = {
+ evaluate: async () => {
+ navigatorCalls += 1;
+ return 'navigator';
+ },
+ };
+ const waiting = waitForWindowByMode({ windows: () => [held, navigator] }, 'editor', {
+ home: '/unused',
+ capMs: 120,
+ stallMs: 600_000,
+ pollMs: 10,
+ });
+ try {
+ await expect(waiting).rejects.toThrow(/did not arrive/);
+ } finally {
+ pending.resolve('navigator');
+ }
+ expect(pendingCalls).toBe(1);
+ expect(maxPendingInFlight).toBe(1);
+ expect(navigatorCalls).toBeGreaterThan(1);
+ expect(navigatorCalls).toBeLessThanOrEqual(15);
+ });
+
+ it('handles a page rejection that arrives after the cap', () => {
+ const scriptDir = mkdtempSync(join(tmpdir(), 'ok-window-readiness-strict-'));
+ const script = join(scriptDir, 'late-rejection.mjs');
+ const home = seedHome();
+ try {
+ writeFileSync(
+ script,
+ [
+ 'const { waitForWindowByMode } = await import(process.argv[2]);',
+ 'let fail = (error) => { throw error; };',
+ 'const pending = new Promise((_resolve, reject) => { fail = reject; });',
+ 'const page = { evaluate: () => pending };',
+ "setTimeout(() => fail(new Error('renderer detached after the cap')), 250);",
+ "const error = await waitForWindowByMode({ windows: () => [page] }, 'editor', {",
+ ' home: process.argv[3],',
+ ' capMs: 60,',
+ ' stallMs: 600_000,',
+ ' pollMs: 10,',
+ '}).catch((e) => e);',
+ "if (!(error instanceof Error)) { console.error('the wait did not give up'); process.exit(2); }",
+ 'await new Promise((resolve) => setTimeout(resolve, 600));',
+ "console.log('survived');",
+ ].join('\n'),
+ 'utf8',
+ );
+ const run = spawnSync(
+ process.execPath,
+ [
+ '--unhandled-rejections=strict',
+ script,
+ new URL('./launch-readiness.ts', import.meta.url).href,
+ home,
+ ],
+ { encoding: 'utf8', timeout: 20_000 },
+ );
+ expect({
+ status: run.status,
+ stdout: run.stdout.trim(),
+ stderr: run.stderr.trim(),
+ }).toEqual({ status: 0, stdout: 'survived', stderr: '' });
+ } finally {
+ rmSync(scriptDir, { recursive: true, force: true });
+ rmSync(home, { recursive: true, force: true });
+ }
+ });
+
+ it('surfaces errors only when no settled page read cleanly', async () => {
+ const first = {
+ evaluate: async (): Promise<string | undefined> => {
+ throw new Error('first target closed');
+ },
+ };
+ const second = {
+ evaluate: async (): Promise<string | undefined> => {
+ throw new Error('second target closed');
+ },
+ };
+ const error = await waitForWindowByMode({ windows: () => [first, second] }, 'editor', {
+ home: '/unused',
+ capMs: 80,
+ stallMs: 600_000,
+ pollMs: 10,
+ }).catch((caught: unknown) => caught);
+ expect(error).toBeInstanceOf(Error);
+ expect((error as Error).message).toContain('second target closed');
+
+ const navigator = { evaluate: async () => 'navigator' };
+ const cleanError = await waitForWindowByMode({ windows: () => [first, navigator] }, 'editor', {
+ home: '/unused',
+ capMs: 80,
+ stallMs: 600_000,
+ pollMs: 10,
+ }).catch((caught: unknown) => caught);
+ expect(cleanError).toBeInstanceOf(Error);
+ expect((cleanError as Error).message).toContain('Probe errors: none on any poll.');
+ expect((cleanError as Error).message).not.toContain('first target closed');
+ });
});
describe('launchDesktopApp', () => {
@@ -1357,7 +1518,7 @@ describe('the cap bounds the wait itself, not only the gaps between polls', () =
}).toEqual({ status: 0, stdout: 'survived', stderr: '' });
});
- it('records a give-up when the first window never answers, instead of no record at all', async () => {
+ it('records a give-up when no editor exists and one window never answers', async () => {
let releaseStuck: () => void = () => {};
const stuck = {
evaluate: () =>
@@ -1365,8 +1526,8 @@ describe('the cap bounds the wait itself, not only the gaps between polls', () =
releaseStuck = () => resolve('navigator');
}),
};
- const ready = { evaluate: async () => 'editor' };
- const app = { windows: () => [stuck, ready] };
+ const navigator = { evaluate: async () => 'navigator' };
+ const app = { windows: () => [stuck, navigator] };
rememberLaunchHome(app, narratingHome());
let released = false;
const release = setTimeout(() => {
@@ -1378,7 +1539,7 @@ describe('the cap bounds the wait itself, not only the gaps between polls', () =
stallMs: 600_000,
pollMs: 10,
}).then(
- (page) => ({ resolvedWith: page === ready ? 'ready-page' : 'stuck-page' }),
+ (page) => ({ resolvedWith: page }),
(error: unknown) => ({ rejectedWith: (error as Error).message }),
);
clearTimeout(release);
@@ -1386,6 +1547,9 @@ describe('the cap bounds the wait itself, not only the gaps between polls', () =
expect(released).toBe(false);
expect(outcome).not.toHaveProperty('resolvedWith');
expect(outcome).toMatchObject({ rejectedWith: expect.stringMatching(/did not arrive/) });
+ expect(outcome).toMatchObject({
+ rejectedWith: expect.stringContaining('The last probe had not answered when the cap fired.'),
+ });
expect(tryFirstWaitFor(app)).toMatchObject({ gaveUp: true, reason: 'cap', capMs: 80 });
});
diff --git a/packages/desktop/tests/smoke/_helpers/launch-readiness.ts b/packages/desktop/tests/smoke/_helpers/launch-readiness.ts
index db413915f..1fc0fbed9 100644
--- a/packages/desktop/tests/smoke/_helpers/launch-readiness.ts
+++ b/packages/desktop/tests/smoke/_helpers/launch-readiness.ts
@@ -351,6 +351,7 @@ export interface ReadySignalOptions<T> {
sleep?: (ms: number) => Promise<void>;
readLog?: (home: string) => BootLogSnapshot;
startDeadline?: (ms: number) => ReadyDeadline;
+ isProbePending?: () => boolean;
}
export interface ReadyDeadline {
@@ -513,6 +514,7 @@ export async function waitForReadySignal<T>(options: ReadySignalOptions<T>): Pro
const probeError: ProbeErrorSummary | undefined =
lastProbeError === undefined ? undefined : { last: lastProbeError, threwPolls, totalPolls };
const elapsed = now() - startedAt;
+ const probePending = probePendingAtGiveUp || options.isProbePending?.() === true;
const stallArmed =
explicitLiveness !== undefined
? explicitLiveness === 'boot'
@@ -526,7 +528,7 @@ export async function waitForReadySignal<T>(options: ReadySignalOptions<T>): Pro
stallMs,
snapshot,
probeError,
- probePendingAtGiveUp,
+ probePending,
),
giveUpReason('stall', snapshot),
);
@@ -540,7 +542,7 @@ export async function waitForReadySignal<T>(options: ReadySignalOptions<T>): Pro
stallMs,
snapshot,
probeError,
- probePendingAtGiveUp,
+ probePending,
),
giveUpReason('cap', snapshot),
);
@@ -562,6 +564,15 @@ interface ModeProbeApp<TPage> {
windows(): TPage[];
}
+type ModeProbeResult =
+ | { kind: 'mode'; value: string | undefined }
+ | { kind: 'error'; error: Error };
+
+interface ModeProbeState {
+ pending: boolean;
+ result: ModeProbeResult | undefined;
+}
+
const HOME_BY_APP = new WeakMap<object, string>();
const BOOT_LOG_BY_APP = new WeakMap<object, string[]>();
@@ -664,6 +675,8 @@ export async function waitForWindowByMode<TPage extends ModeProbePage>(
const what = `${mode} window`;
const capMs = options.capMs ?? BOOT_LOG_CAP_MS;
const startedAt = Date.now();
+ const probeStates = new WeakMap<TPage, ModeProbeState>();
+ let pendingProbeCount = 0;
let succeeded = false;
let reason: ReadyWaitGiveUpReason = 'none';
try {
@@ -674,16 +687,57 @@ export async function waitForWindowByMode<TPage extends ModeProbePage>(
...(options.stallMs !== undefined ? { stallMs: options.stallMs } : {}),
capMs,
...(options.pollMs !== undefined ? { pollMs: options.pollMs } : {}),
+ isProbePending: () => pendingProbeCount > 0,
probe: async () => {
+ const pages = app.windows();
+ for (const page of pages) {
+ let state = probeStates.get(page);
+ if (state === undefined) {
+ state = { pending: false, result: undefined };
+ probeStates.set(page, state);
+ }
+ if (state.pending || state.result !== undefined) continue;
+ state.pending = true;
+ pendingProbeCount += 1;
+ try {
+ void evaluateWindowMode(page).then(
+ (value) => {
+ state.pending = false;
+ pendingProbeCount -= 1;
+ state.result = { kind: 'mode', value };
+ },
+ (error: unknown) => {
+ state.pending = false;
+ pendingProbeCount -= 1;
+ state.result = {
+ kind: 'error',
+ error: error instanceof Error ? error : new Error(String(error)),
+ };
+ },
+ );
+ } catch (error) {
+ state.pending = false;
+ pendingProbeCount -= 1;
+ state.result = {
+ kind: 'error',
+ error: error instanceof Error ? error : new Error(String(error)),
+ };
+ }
+ }
+
+ await Promise.resolve();
let lastError: Error | undefined;
let readCleanly = false;
- for (const page of app.windows()) {
- try {
- const found = await evaluateWindowMode(page);
+ for (const page of pages) {
+ const state = probeStates.get(page);
+ const result = state?.result;
+ if (state === undefined || result === undefined) continue;
+ state.result = undefined;
+ if (result.kind === 'mode') {
readCleanly = true;
- if (found === mode) return page;
- } catch (error) {
- lastError = error instanceof Error ? error : new Error(String(error));
+ if (result.value === mode) return page;
+ } else {
+ lastError = result.error;
}
}
if (!readCleanly && lastError !== undefined) throw lastError;