Beautiful, AI-native markdown IDE and LLM wiki
TypeScript 2nd-brainagent-skillsclaudecodexcompany-braindocsknowledge-knowledge-baseknowledge-managementllmllm-wikillm-wiki-karpathymarkdownmarkdown-editormdmdxnotespkmsecond-brainskills
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.mdnew file mode 100644index 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.tsindex 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.tsindex 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>): Proconst 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>): ProstallMs,snapshot,probeError,- probePendingAtGiveUp,+ probePending,),giveUpReason('stall', snapshot),);@@ -540,7 +542,7 @@ export async function waitForReadySignal<T>(options: ReadySignalOptions<T>): ProstallMs,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;