You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@maka.apache.org by wy...@apache.org on 2026/09/01 15:10:06 UTC
(maka) branch feat/maka-browser-recovery-dialogs updated: fix(desktop): keep recovery decisions conservative
This is an automated email from the ASF dual-hosted git repository.
M4n5ter pushed a commit to branch feat/maka-browser-recovery-dialogs
in repository https://gitbox.apache.org/repos/asf/maka.git
The following commit(s) were added to refs/heads/feat/maka-browser-recovery-dialogs by this push:
new 3258a39fdb fix(desktop): keep recovery decisions conservative
3258a39fdb is described below
commit 3258a39fdbe101a57d492bc467f167c4b3ca5504
Author: Wang <m4...@gmail.com>
AuthorDate: Tue Sep 1 23:09:53 2026 +0800
fix(desktop): keep recovery decisions conservative
Generated-by: OpenAI Codex
---
.../src/main/__tests__/browser-message-box.test.ts | 227 ++++++++++++++++++---
.../__tests__/main-renderer-process-gone.test.ts | 11 +-
.../main/__tests__/main-startup-lifetime.test.ts | 22 ++
.../__tests__/runtime-host-desktop-manager.test.ts | 48 ++++-
apps/desktop/src/main/browser-message-box.ts | 47 +++--
.../desktop/src/main/main-renderer-process-gone.ts | 23 +--
apps/desktop/src/main/runtime-host-boot.ts | 4 +-
.../src/main/runtime-host-desktop-manager.ts | 22 +-
packages/runtime-host/src/client/connection.ts | 5 +-
packages/runtime-host/src/protocol/host-status.ts | 8 +
packages/runtime-host/src/protocol/operations.ts | 1 +
11 files changed, 316 insertions(+), 102 deletions(-)
diff --git a/apps/desktop/src/main/__tests__/browser-message-box.test.ts b/apps/desktop/src/main/__tests__/browser-message-box.test.ts
index facf758b0c..1cd801818c 100644
--- a/apps/desktop/src/main/__tests__/browser-message-box.test.ts
+++ b/apps/desktop/src/main/__tests__/browser-message-box.test.ts
@@ -18,9 +18,15 @@
*/
import assert from 'node:assert/strict';
+import { EventEmitter } from 'node:events';
import { test } from 'node:test';
-import type { BrowserWindow, MessageBoxReturnValue } from 'electron';
+import type {
+ BrowserWindow,
+ BrowserWindowConstructorOptions,
+ MessageBoxReturnValue,
+} from 'electron';
import {
+ type BrowserMessageBoxRuntime,
buildBrowserMessageBoxHtml,
centeredBounds,
isBrowserMessageBoxPresentationActive,
@@ -36,38 +42,46 @@ test('falls back natively and never attaches to an inaccessible parent', async (
isVisible: () => parentState.visible,
isMinimized: () => parentState.minimized,
isDestroyed: () => parentState.destroyed,
+ getBounds: () => ({ x: 100, y: 100, width: 900, height: 700 }),
} as BrowserWindow;
const nativeParents: Array<BrowserWindow | undefined> = [];
- const showNative = async (
- _options: typeof options,
- actualParent: BrowserWindow | undefined,
- ): Promise<MessageBoxReturnValue> => {
- nativeParents.push(actualParent);
- return nativeResult;
+ const runtimeBase = {
+ shouldUseDarkColors: false,
+ resolveWorkArea: () => ({ x: 0, y: 0, width: 1_200, height: 800 }),
+ showNative: async (
+ _options: typeof options,
+ actualParent: BrowserWindow | undefined,
+ ): Promise<MessageBoxReturnValue> => {
+ nativeParents.push(actualParent);
+ return nativeResult;
+ },
+ onBrowserError: () => assert.fail('native presentation must not report a browser error'),
};
assert.equal(
- await showBrowserMessageBoxWithRuntime(options, parent, {
+ await showBrowserMessageBoxWithRuntime(options, parent, { locale: 'en' }, {
+ ...runtimeBase,
ready: false,
- showBrowser: async () => assert.fail('pre-ready presentation must stay native'),
- showNative,
- onBrowserError: () => assert.fail('native presentation must not report a browser error'),
+ createWindow: () => assert.fail('pre-ready presentation must stay native'),
}),
nativeResult,
);
parentState.visible = true;
const failure = new Error('renderer failed');
+ const failedWindow = fakeBrowserWindow({ loadError: failure });
let reported: unknown;
assert.equal(
- await showBrowserMessageBoxWithRuntime(options, parent, {
+ await showBrowserMessageBoxWithRuntime(options, parent, { locale: 'en' }, {
+ ...runtimeBase,
ready: true,
- showBrowser: async (_nextOptions, actualParent) => {
- assert.equal(actualParent, parent);
+ createWindow: (windowOptions) => {
+ assert.equal(windowOptions.parent, parent);
+ assert.equal(windowOptions.modal, true);
parentState.minimized = true;
- throw failure;
+ failedWindow.options = windowOptions;
+ return failedWindow.window;
},
- showNative,
onBrowserError: (error) => {
reported = error;
},
@@ -76,35 +90,101 @@ test('falls back natively and never attaches to an inaccessible parent', async (
);
assert.equal(reported, failure);
assert.deepEqual(nativeParents, [undefined, undefined]);
+ assert.equal(failedWindow.destroyed(), true);
});
-test('presents a ready dialog without an inaccessible modal parent', async () => {
- const result = { response: 0, checkboxChecked: false };
+test('drives the BrowserWindow lifecycle through a safe response URL', async () => {
const parent = {
isVisible: () => true,
isMinimized: () => true,
isDestroyed: () => false,
} as BrowserWindow;
+ const presented = fakeBrowserWindow();
+ let createdOptions: BrowserWindowConstructorOptions | undefined;
- let finishPresentation!: (value: MessageBoxReturnValue) => void;
- const presentation = showBrowserMessageBoxWithRuntime({ message: 'Recover Maka' }, parent, {
+ const presentation = showBrowserMessageBoxWithRuntime(
+ { message: 'Recover Maka', buttons: ['Recover', 'Cancel'], cancelId: 1 },
+ parent,
+ { locale: 'en', dark: true },
+ {
ready: true,
- showBrowser: async (_options, actualParent) => {
+ shouldUseDarkColors: false,
+ createWindow: (options) => {
+ createdOptions = options;
+ return presented.window;
+ },
+ resolveWorkArea: (actualParent) => {
assert.equal(actualParent, undefined);
- return new Promise<MessageBoxReturnValue>((resolve) => {
- finishPresentation = resolve;
- });
+ return { x: 0, y: 0, width: 1_200, height: 800 };
},
showNative: async () => assert.fail('successful browser presentation must not fall back'),
onBrowserError: () => assert.fail('successful browser presentation must not report error'),
- });
- await Promise.resolve();
+ },
+ );
+ await new Promise<void>((resolve) => setImmediate(resolve));
+
assert.equal(isBrowserMessageBoxPresentationActive(), true);
- finishPresentation(result);
- assert.equal(await presentation, result);
+ assert.equal(createdOptions?.parent, undefined);
+ assert.equal(createdOptions?.modal, undefined);
+ assert.equal(presented.shown(), true);
+ assert.equal(presented.focused(), true);
+ assert.match(presented.loadedUrl(), /^data:text\/html/u);
+ assert.equal(presented.deniesWindowOpen(), true);
+
+ let prevented = false;
+ presented.webContents.emit(
+ 'will-navigate',
+ {
+ preventDefault: () => {
+ prevented = true;
+ },
+ },
+ 'maka-dialog://response/0',
+ );
+ assert.deepEqual(await presentation, { response: 0, checkboxChecked: false });
+ assert.equal(prevented, true);
+ assert.equal(presented.destroyed(), true);
assert.equal(isBrowserMessageBoxPresentationActive(), false);
});
+test('maps close to cancel and falls back after each BrowserWindow presentation failure', async () => {
+ const closed = fakeBrowserWindow();
+ const closeResult = showBrowserMessageBoxWithRuntime(
+ { message: 'Recover Maka', buttons: ['Recover', 'Cancel'], cancelId: 1 },
+ undefined,
+ { locale: 'en' },
+ runtimeForWindow(closed),
+ );
+ closed.window.emit('closed');
+ assert.deepEqual(await closeResult, { response: 1, checkboxChecked: false });
+ assert.equal(closed.destroyed(), true);
+
+ for (const scenario of ['unresponsive', 'renderer-gone', 'timeout'] as const) {
+ const presented = fakeBrowserWindow({ pendingLoad: scenario === 'timeout' });
+ const errors: unknown[] = [];
+ const nativeResult = { response: 0, checkboxChecked: false };
+ const result = showBrowserMessageBoxWithRuntime(
+ { message: 'Recover Maka' },
+ undefined,
+ { locale: 'en' },
+ runtimeForWindow(presented, {
+ presentationTimeoutMs: scenario === 'timeout' ? 1 : undefined,
+ onBrowserError: (error) => errors.push(error),
+ nativeResult,
+ }),
+ );
+ if (scenario === 'unresponsive') presented.window.emit('unresponsive');
+ if (scenario === 'renderer-gone') {
+ presented.webContents.emit('render-process-gone', {}, { reason: 'crashed' });
+ }
+
+ assert.equal(await result, nativeResult);
+ assert.equal(errors.length, 1, scenario);
+ assert.equal(presented.destroyed(), true, scenario);
+ assert.equal(isBrowserMessageBoxPresentationActive(), false, scenario);
+ }
+});
+
test('accepts only an in-range response URL produced by the dialog', () => {
assert.equal(parseBrowserMessageBoxResponse('maka-dialog://response/1', 3), 1);
for (const value of [
@@ -155,7 +235,9 @@ test('renders escaped content with Maka dialog tokens and safe action ordering',
assert.match(html, /data-theme="dark"/u);
assert.match(html, /data-maka-theme="nord"/u);
- assert.match(html, /--shadow-med:/u);
+ assert.match(html, /--surface-overlay:/u);
+ assert.match(html, /--accent-solid:/u);
+ assert.match(html, /--space-4:/u);
assert.match(html, /color: var\(--maka-brand\)/u);
assert.doesNotMatch(html, /--control-overlay-hover:/u);
assert.match(html, /<img src=x onerror=alert\(1\)>/u);
@@ -213,3 +295,90 @@ test('uses the resolved locale instead of guessing from user-controlled text', (
assert.doesNotMatch(html, /globalThis\.pwned/u);
assert.match(html, /data-response="0" autofocus/u);
});
+
+interface FakeBrowserWindow {
+ readonly window: BrowserWindow;
+ readonly webContents: EventEmitter;
+ options?: BrowserWindowConstructorOptions;
+ loadedUrl(): string;
+ shown(): boolean;
+ focused(): boolean;
+ destroyed(): boolean;
+ deniesWindowOpen(): boolean;
+}
+
+function fakeBrowserWindow(input: {
+ readonly loadError?: Error;
+ readonly pendingLoad?: boolean;
+} = {}): FakeBrowserWindow {
+ let loadedUrl = '';
+ let shown = false;
+ let focused = false;
+ let destroyed = false;
+ let deniesWindowOpen = false;
+ const webContents = Object.assign(new EventEmitter(), {
+ setWindowOpenHandler(handler: () => { action: string }) {
+ deniesWindowOpen = handler().action === 'deny';
+ },
+ async executeJavaScript(script: string): Promise<number | undefined> {
+ return script.includes('scrollHeight') ? 340 : undefined;
+ },
+ });
+ const window = Object.assign(new EventEmitter(), {
+ webContents,
+ setMenuBarVisibility() {},
+ loadURL(url: string): Promise<void> {
+ loadedUrl = url;
+ if (input.loadError) return Promise.reject(input.loadError);
+ if (input.pendingLoad) return new Promise<void>(() => undefined);
+ return Promise.resolve();
+ },
+ isDestroyed: () => destroyed,
+ destroy: () => {
+ destroyed = true;
+ },
+ setBounds() {},
+ show: () => {
+ shown = true;
+ },
+ focus: () => {
+ focused = true;
+ },
+ }) as unknown as BrowserWindow;
+ return {
+ window,
+ webContents,
+ loadedUrl: () => loadedUrl,
+ shown: () => shown,
+ focused: () => focused,
+ destroyed: () => destroyed,
+ deniesWindowOpen: () => deniesWindowOpen,
+ };
+}
+
+function runtimeForWindow(
+ presented: FakeBrowserWindow,
+ options: {
+ readonly presentationTimeoutMs?: number;
+ readonly onBrowserError?: (error: unknown) => void;
+ readonly nativeResult?: MessageBoxReturnValue;
+ } = {},
+): BrowserMessageBoxRuntime {
+ return {
+ ready: true,
+ shouldUseDarkColors: false,
+ createWindow: (windowOptions) => {
+ presented.options = windowOptions;
+ return presented.window;
+ },
+ resolveWorkArea: () => ({ x: 0, y: 0, width: 1_200, height: 800 }),
+ showNative: async () =>
+ options.nativeResult ?? assert.fail('successful browser presentation must not fall back'),
+ onBrowserError:
+ options.onBrowserError ??
+ (() => assert.fail('successful browser presentation must not report an error')),
+ ...(options.presentationTimeoutMs === undefined
+ ? {}
+ : { presentationTimeoutMs: options.presentationTimeoutMs }),
+ };
+}
diff --git a/apps/desktop/src/main/__tests__/main-renderer-process-gone.test.ts b/apps/desktop/src/main/__tests__/main-renderer-process-gone.test.ts
index 07b988cb97..b576edf72d 100644
--- a/apps/desktop/src/main/__tests__/main-renderer-process-gone.test.ts
+++ b/apps/desktop/src/main/__tests__/main-renderer-process-gone.test.ts
@@ -63,11 +63,10 @@ test('ignores clean exits and app shutdown', () => {
}
});
-test('reports reload success only after the main document loads and the Renderer paints', async () => {
+test('reports reload success only after the Renderer commits its first paint', async () => {
const source = reloadSource();
const readiness = rendererReadiness();
let observed = false;
- let settled = false;
const result = reloadMainRendererProcess({
source,
shutdownSignal: new AbortController().signal,
@@ -76,15 +75,9 @@ test('reports reload success only after the main document loads and the Renderer
observed = true;
},
});
- void result.then(() => {
- settled = true;
- });
assert.equal(source.reloadCalls, 1);
source.emit('did-fail-load', {}, -3, 'subframe failed', 'https://example.test/frame', false, 1, 2);
- source.emit('did-finish-load');
- await Promise.resolve();
- assert.equal(settled, false);
readiness.notify();
assert.equal(await result, true);
assert.equal(observed, true);
@@ -116,7 +109,6 @@ test('keeps recovery active when a Renderer reload fails, exits, or stops respon
fail(source);
assert.equal(await result, false);
assert.equal(observed, false);
- assert.equal(source.listenerCount('did-finish-load'), 0);
assert.equal(source.listenerCount('unresponsive'), 0);
assert.equal(readiness.subscribed(), false);
}
@@ -134,7 +126,6 @@ test('bounds a Renderer reload that emits no terminal event', async () => {
});
assert.equal(await result, false);
- assert.equal(source.listenerCount('did-finish-load'), 0);
assert.equal(source.listenerCount('did-fail-load'), 0);
assert.equal(source.listenerCount('unresponsive'), 0);
assert.equal(source.listenerCount('render-process-gone'), 0);
diff --git a/apps/desktop/src/main/__tests__/main-startup-lifetime.test.ts b/apps/desktop/src/main/__tests__/main-startup-lifetime.test.ts
index 0a26fff7d8..67f57f4b6d 100644
--- a/apps/desktop/src/main/__tests__/main-startup-lifetime.test.ts
+++ b/apps/desktop/src/main/__tests__/main-startup-lifetime.test.ts
@@ -26,6 +26,10 @@ const mainSource = readFileSync(
fileURLToPath(new URL('../../../src/main/main.ts', import.meta.url)),
'utf8',
);
+const bootSource = readFileSync(
+ fileURLToPath(new URL('../../../src/main/runtime-host-boot.ts', import.meta.url)),
+ 'utf8',
+);
test('retains process lifetime before a standalone startup dialog can close', () => {
const retentionPolicy = mainSource.search(
@@ -37,3 +41,21 @@ test('retains process lifetime before a standalone startup dialog can close', ()
assert.notEqual(singleInstanceDecision, -1);
assert.ok(retentionPolicy < singleInstanceDecision);
});
+
+test('resolves persisted locale before first post-settings recovery prompt', () => {
+ const rendererRecoveryStart = bootSource.indexOf('onRendererProcessGone: async');
+ const rendererRecovery = bootSource.slice(
+ rendererRecoveryStart,
+ bootSource.indexOf('resolveBrowserDialogParent =', rendererRecoveryStart),
+ );
+ const hostRecoveryStart = bootSource.indexOf('prompt: async (input)');
+ const hostRecovery = bootSource.slice(
+ hostRecoveryStart,
+ bootSource.indexOf('}).catch((error: unknown)', hostRecoveryStart),
+ );
+
+ assert.match(rendererRecovery, /const locale = await desktopLocale\.resolve\(\)/u);
+ assert.match(hostRecovery, /const locale = await desktopLocale\.resolve\(\)/u);
+ assert.doesNotMatch(rendererRecovery, /desktopLocale\.current\(\)/u);
+ assert.doesNotMatch(hostRecovery, /desktopLocale\.current\(\)/u);
+});
diff --git a/apps/desktop/src/main/__tests__/runtime-host-desktop-manager.test.ts b/apps/desktop/src/main/__tests__/runtime-host-desktop-manager.test.ts
index 3e8583bb26..67930fa9ea 100644
--- a/apps/desktop/src/main/__tests__/runtime-host-desktop-manager.test.ts
+++ b/apps/desktop/src/main/__tests__/runtime-host-desktop-manager.test.ts
@@ -1273,9 +1273,10 @@ test('waits passively for a Host that cannot be taken over', async () => {
});
test('silently replaces an idle non-restartable Local Host and retries', async () => {
- const observed = upgradeRequired(false);
+ const observed = upgradeRequired(true);
const conflict = {
...observed,
+ restartable: false as const,
registration: { ...observed.registration, lifecycleMode: 'service' as const },
};
const replacement = candidateHarness();
@@ -1349,7 +1350,7 @@ test('prompts before replacing a non-restartable Local Host with observed connec
await owner.close();
});
-test('prompts only after a non-restartable Local Host reports active tasks', async () => {
+test('prompts if a non-restartable Local Host omits its activity snapshot', async () => {
const observed = upgradeRequired(false);
const conflict = {
...observed,
@@ -1359,6 +1360,47 @@ test('prompts only after a non-restartable Local Host reports active tasks', asy
const policies: string[] = [];
let starts = 0;
let prompts = 0;
+ const owner = await startRuntimeHostDesktopManager(
+ {} as DesktopRuntimeHostCandidateStartInput,
+ {
+ startCandidate: async () => {
+ starts += 1;
+ return starts === 1 ? conflict : ready(replacement.candidate);
+ },
+ upgradePrompts: {
+ restartable: async () => assert.fail('non-restartable conflict used restart prompt'),
+ nonRestartable: async (_conflict, action) => {
+ prompts += 1;
+ assert.equal(action, 'replace_may_interrupt_work');
+ return 'replace';
+ },
+ },
+ resolveLocalHostReplacement: async () => ({
+ replace: async (policy) => {
+ policies.push(policy);
+ return 'replaced';
+ },
+ }),
+ },
+ );
+
+ assert.equal(prompts, 1);
+ assert.equal(starts, 2);
+ assert.deepEqual(policies, ['interrupt_active_work']);
+ await owner.close();
+});
+
+test('prompts if an observed-idle Host becomes active before replacement', async () => {
+ const observed = upgradeRequired(true);
+ const conflict = {
+ ...observed,
+ restartable: false as const,
+ registration: { ...observed.registration, lifecycleMode: 'service' as const },
+ };
+ const replacement = candidateHarness();
+ const policies: string[] = [];
+ let starts = 0;
+ let prompts = 0;
const owner = await startRuntimeHostDesktopManager(
{} as DesktopRuntimeHostCandidateStartInput,
{
@@ -1414,7 +1456,7 @@ test('does not authorize active-work interruption when replacement is cancelled'
}),
RuntimeHostUpgradeCancelledError,
);
- assert.deepEqual(policies, ['refuse_active_work']);
+ assert.deepEqual(policies, []);
});
test('lets the user cancel startup when an incompatible Host owns the root', async () => {
diff --git a/apps/desktop/src/main/browser-message-box.ts b/apps/desktop/src/main/browser-message-box.ts
index 486d2514f0..10391a3ac8 100644
--- a/apps/desktop/src/main/browser-message-box.ts
+++ b/apps/desktop/src/main/browser-message-box.ts
@@ -25,6 +25,7 @@ import { isThemePalette, type ThemePalette } from '@maka/core/settings';
import type { UiLocale } from '@maka/core/ui-locale';
import type {
BrowserWindow,
+ BrowserWindowConstructorOptions,
MessageBoxOptions,
MessageBoxReturnValue,
Rectangle,
@@ -47,6 +48,19 @@ export interface BrowserMessageBoxAppearance {
readonly dark?: boolean;
}
+export interface BrowserMessageBoxRuntime {
+ readonly ready: boolean;
+ readonly shouldUseDarkColors: boolean;
+ readonly createWindow: (options: BrowserWindowConstructorOptions) => BrowserWindow;
+ readonly resolveWorkArea: (parent: BrowserWindow | undefined) => Rectangle;
+ readonly showNative: (
+ options: MessageBoxOptions,
+ parent: BrowserWindow | undefined,
+ ) => Promise<MessageBoxReturnValue>;
+ readonly onBrowserError: (error: unknown) => void;
+ readonly presentationTimeoutMs?: number;
+}
+
/** Whether closing a temporary dialog must not be interpreted as app shutdown. */
export function isBrowserMessageBoxPresentationActive(): boolean {
return activeBrowserMessageBoxPresentations > 0;
@@ -68,10 +82,11 @@ export async function showBrowserMessageBox(
// Keep the presentation helpers importable under plain `node --test`.
// Electron itself is only required when a dialog is actually presented.
const electron = await import('electron');
- return showBrowserMessageBoxWithRuntime(options, parent, {
+ return showBrowserMessageBoxWithRuntime(options, parent, appearance, {
ready: electron.app.isReady(),
- showBrowser: (nextOptions, nextParent) =>
- presentBrowserMessageBox(electron, nextOptions, nextParent, appearance),
+ shouldUseDarkColors: electron.nativeTheme.shouldUseDarkColors,
+ createWindow: (windowOptions) => new electron.BrowserWindow(windowOptions),
+ resolveWorkArea: (nextParent) => resolveWorkArea(electron, nextParent),
showNative: (nextOptions, nextParent) =>
showNativeMessageBox(electron, nextOptions, nextParent),
onBrowserError: (error) => {
@@ -83,18 +98,8 @@ export async function showBrowserMessageBox(
export async function showBrowserMessageBoxWithRuntime(
options: MessageBoxOptions,
parent: BrowserWindow | undefined,
- runtime: {
- readonly ready: boolean;
- readonly showBrowser: (
- options: MessageBoxOptions,
- parent: BrowserWindow | undefined,
- ) => Promise<MessageBoxReturnValue>;
- readonly showNative: (
- options: MessageBoxOptions,
- parent: BrowserWindow | undefined,
- ) => Promise<MessageBoxReturnValue>;
- readonly onBrowserError: (error: unknown) => void;
- },
+ appearance: BrowserMessageBoxAppearance,
+ runtime: BrowserMessageBoxRuntime,
): Promise<MessageBoxReturnValue> {
activeBrowserMessageBoxPresentations += 1;
try {
@@ -104,7 +109,7 @@ export async function showBrowserMessageBoxWithRuntime(
: undefined;
if (!runtime.ready) return await runtime.showNative(options, visibleParent());
try {
- return await runtime.showBrowser(options, visibleParent());
+ return await presentBrowserMessageBox(runtime, options, visibleParent(), appearance);
} catch (error) {
runtime.onBrowserError(error);
return await runtime.showNative(options, visibleParent());
@@ -125,23 +130,23 @@ async function showNativeMessageBox(
}
async function presentBrowserMessageBox(
- electron: typeof import('electron'),
+ runtime: BrowserMessageBoxRuntime,
options: MessageBoxOptions,
parent: BrowserWindow | undefined,
appearance: BrowserMessageBoxAppearance,
): Promise<MessageBoxReturnValue> {
const presentation = normalizeBrowserMessageBoxPresentation(options, {
...appearance,
- dark: appearance.dark ?? electron.nativeTheme.shouldUseDarkColors,
+ dark: appearance.dark ?? runtime.shouldUseDarkColors,
});
- const workArea = resolveWorkArea(electron, parent);
+ const workArea = runtime.resolveWorkArea(parent);
const width = Math.max(320, Math.min(DIALOG_WIDTH, workArea.width - WORK_AREA_MARGIN * 2));
const initialHeight = Math.max(
MIN_HEIGHT,
Math.min(INITIAL_HEIGHT, workArea.height - WORK_AREA_MARGIN * 2),
);
const initialBounds = centeredBounds(parent?.getBounds(), workArea, width, initialHeight);
- const win = new electron.BrowserWindow({
+ const win = runtime.createWindow({
...initialBounds,
title: presentation.title,
show: false,
@@ -190,7 +195,7 @@ async function presentBrowserMessageBox(
};
presentationTimeout = setTimeout(
() => fail(new Error('Dialog renderer did not become interactive in time')),
- DIALOG_PRESENTATION_TIMEOUT_MS,
+ runtime.presentationTimeoutMs ?? DIALOG_PRESENTATION_TIMEOUT_MS,
);
win.on('closed', () => finish(presentation.cancelId));
diff --git a/apps/desktop/src/main/main-renderer-process-gone.ts b/apps/desktop/src/main/main-renderer-process-gone.ts
index c42ca2326e..ae84ae216d 100644
--- a/apps/desktop/src/main/main-renderer-process-gone.ts
+++ b/apps/desktop/src/main/main-renderer-process-gone.ts
@@ -27,7 +27,6 @@ interface RenderProcessGoneSource {
}
interface MainRendererReloadSource {
- once(event: 'did-finish-load', listener: () => void): void;
once(event: 'unresponsive', listener: () => void): void;
once(
event: 'render-process-gone',
@@ -46,7 +45,6 @@ interface MainRendererReloadSource {
frameRoutingId: number,
) => void,
): void;
- off(event: 'did-finish-load', listener: () => void): void;
off(event: 'unresponsive', listener: () => void): void;
off(
event: 'render-process-gone',
@@ -81,9 +79,9 @@ export function observeMainRendererProcessGone(deps: {
}
/**
- * Waits for a crashed main Renderer to finish loading before recovery is
- * reported as successful. The ordinary one-shot crash observer is re-armed
- * synchronously by `onLoaded`, leaving no successful-load gap unobserved.
+ * Waits for a crashed main Renderer to report its first committed paint before
+ * recovery is successful. The ordinary one-shot crash observer is re-armed
+ * synchronously by `onReady`, leaving no successful-recovery gap unobserved.
*/
export function reloadMainRendererProcess(deps: {
readonly source: MainRendererReloadSource;
@@ -97,14 +95,11 @@ export function reloadMainRendererProcess(deps: {
}
return new Promise<boolean>((resolve) => {
let settled = false;
- let documentLoaded = false;
- let rendererReady = false;
let timeout: ReturnType<typeof setTimeout> | undefined;
let unsubscribeRendererReady = (): void => {};
const cleanup = (): void => {
if (timeout) clearTimeout(timeout);
unsubscribeRendererReady();
- deps.source.off('did-finish-load', onDocumentLoaded);
deps.source.off('did-fail-load', onFailed);
deps.source.off('unresponsive', onUnresponsive);
deps.source.off('render-process-gone', onGone);
@@ -117,8 +112,7 @@ export function reloadMainRendererProcess(deps: {
cleanup();
resolve(loaded);
};
- const finishWhenReady = (): void => {
- if (!documentLoaded || !rendererReady) return;
+ const onRendererReady = (): void => {
try {
deps.onReady();
settle(true);
@@ -126,14 +120,6 @@ export function reloadMainRendererProcess(deps: {
settle(false);
}
};
- const onDocumentLoaded = (): void => {
- documentLoaded = true;
- finishWhenReady();
- };
- const onRendererReady = (): void => {
- rendererReady = true;
- finishWhenReady();
- };
const onFailed = (
_event: Event,
_errorCode: number,
@@ -149,7 +135,6 @@ export function reloadMainRendererProcess(deps: {
const onAborted = (): void => settle(false);
unsubscribeRendererReady = deps.subscribeRendererReady(onRendererReady);
- deps.source.once('did-finish-load', onDocumentLoaded);
deps.source.on('did-fail-load', onFailed);
deps.source.once('unresponsive', onUnresponsive);
deps.source.once('render-process-gone', onGone);
diff --git a/apps/desktop/src/main/runtime-host-boot.ts b/apps/desktop/src/main/runtime-host-boot.ts
index 405fbc092e..ccc3935200 100644
--- a/apps/desktop/src/main/runtime-host-boot.ts
+++ b/apps/desktop/src/main/runtime-host-boot.ts
@@ -464,7 +464,7 @@ const mainWindowController = createMainWindowController({
details: `Exit code: ${details.exitCode}`,
});
for (;;) {
- const locale = desktopLocale.current();
+ const locale = await desktopLocale.resolve();
const decision = await showMainRendererProcessGoneDialog({
locale,
copyDiagnostics: () =>
@@ -1171,7 +1171,7 @@ runtimeHostManager = await startDesktopRuntimeHostWithRecovery({
repairError: input.repairError,
activeTasks: input.activeTasks,
});
- const locale = desktopLocale.current();
+ const locale = await desktopLocale.resolve();
return showRuntimeHostStartupRecoveryDialog(input, {
locale,
showMessageBox: (options) => showDesktopMessageBox(options, { locale }),
diff --git a/apps/desktop/src/main/runtime-host-desktop-manager.ts b/apps/desktop/src/main/runtime-host-desktop-manager.ts
index 69f0a22ba1..25b517e1dc 100644
--- a/apps/desktop/src/main/runtime-host-desktop-manager.ts
+++ b/apps/desktop/src/main/runtime-host-desktop-manager.ts
@@ -36,7 +36,7 @@ import {
type RuntimeHostRetirementMode,
type RuntimeHostSshInteraction,
} from '@maka/runtime-host/client';
-import type { HostActivitySnapshot, HostRegistration } from '@maka/runtime-host/protocol';
+import { isHostActivityIdle, type HostRegistration } from '@maka/runtime-host/protocol';
import type { DesktopTargetSessionRef } from '../shared/runtime-host-identity.js';
import {
startDesktopRuntimeHostCandidate,
@@ -151,14 +151,6 @@ export type RuntimeHostNonRestartableAction =
| 'wait'
| 'cancel_only';
-function isObservedRuntimeHostIdle(activity: HostActivitySnapshot): boolean {
- return (
- activity.connections === 0 &&
- activity.activeOperations === 0 &&
- activity.residencies.length === 0
- );
-}
-
export interface RuntimeHostLocalReplacement {
replace(activeWorkPolicy: RuntimeHostRetirementMode): Promise<'replaced' | 'active_tasks'>;
}
@@ -925,7 +917,7 @@ class RuntimeHostDesktopManagerImpl implements RuntimeHostDesktopManager {
if (result.kind === 'upgrade_required' && result.restartable) {
const activity = result.handshake?.activity;
const decision =
- activity && isObservedRuntimeHostIdle(activity)
+ activity && isHostActivityIdle(activity)
? 'restart'
: await this.#resolveRestartable(result);
if (decision === 'cancel') {
@@ -947,11 +939,11 @@ class RuntimeHostDesktopManagerImpl implements RuntimeHostDesktopManager {
? undefined
: await this.resolveLocalHostReplacement?.(result.registration, signal);
const activity = result.handshake?.activity;
- if (replacement && (!activity || isObservedRuntimeHostIdle(activity))) {
- // The managed-service operator can check active work even when an
- // older Host cannot include an activity snapshot in its handshake.
- // A present snapshot remains authoritative for connections as well
- // as operations/residencies; interruption still requires consent.
+ if (replacement && activity && isHostActivityIdle(activity)) {
+ // Only a complete, observed snapshot can authorize silent
+ // replacement. The replacement transaction closes races with new
+ // operations; an absent snapshot requires explicit consent because
+ // it cannot prove that other clients are disconnected.
const attempt = await replacement.replace('refuse_active_work');
if (attempt === 'replaced') {
takeoverHostEpoch = undefined;
diff --git a/packages/runtime-host/src/client/connection.ts b/packages/runtime-host/src/client/connection.ts
index 109cb47b99..3183d11c4b 100644
--- a/packages/runtime-host/src/client/connection.ts
+++ b/packages/runtime-host/src/client/connection.ts
@@ -42,6 +42,7 @@ import {
type ConfigurationChangedFrame,
type HostOperationErrorCode,
type HostIncompatible,
+ isHostActivityIdle,
type HostRegistration,
type HostStatusResult,
HOST_OPERATION_SPECS,
@@ -1281,9 +1282,7 @@ export async function connectResolvedRuntimeHost(
return registration.lifecycleMode === 'ephemeral' &&
result.handshake.state === 'ready' &&
result.handshake.activity !== undefined &&
- result.handshake.activity.connections === 0 &&
- result.handshake.activity.activeOperations === 0 &&
- result.handshake.activity.residencies.length === 0
+ isHostActivityIdle(result.handshake.activity)
? {
kind: 'upgrade_required',
registration,
diff --git a/packages/runtime-host/src/protocol/host-status.ts b/packages/runtime-host/src/protocol/host-status.ts
index 4aac3a9603..75f22c3679 100644
--- a/packages/runtime-host/src/protocol/host-status.ts
+++ b/packages/runtime-host/src/protocol/host-status.ts
@@ -39,6 +39,14 @@ export interface HostActivitySnapshot {
readonly residencies: readonly { readonly label: string; readonly count: number }[];
}
+export function isHostActivityIdle(activity: HostActivitySnapshot): boolean {
+ return (
+ activity.connections === 0 &&
+ activity.activeOperations === 0 &&
+ activity.residencies.length === 0
+ );
+}
+
export interface HostUpgradePrepareInput {
readonly expectedHostEpoch: string;
readonly allowInterruptActiveTasks: boolean;
diff --git a/packages/runtime-host/src/protocol/operations.ts b/packages/runtime-host/src/protocol/operations.ts
index 1f6f900805..0ef2056877 100644
--- a/packages/runtime-host/src/protocol/operations.ts
+++ b/packages/runtime-host/src/protocol/operations.ts
@@ -76,6 +76,7 @@ export type {
HostUpgradePrepareInput,
HostUpgradePrepareResult,
} from './host-status.js';
+export { isHostActivityIdle } from './host-status.js';
export type {
HostOperationError,
HostOperationErrorCode,
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@maka.apache.org
For additional commands, e-mail: commits-help@maka.apache.org