Skip to content

Beautiful, AI-native markdown IDE and LLM wiki

Fix Open file in unpackaged desktop (PRD-8949) (#5402)

Andrew Mikofalvyc2a8871f2a3a
diff --git a/.changeset/unpackaged-open-file.md b/.changeset/unpackaged-open-file.md
new file mode 100644
index 000000000..af0c98d50
--- /dev/null
+++ b/.changeset/unpackaged-open-file.md
@@ -0,0 +1,5 @@
+---
+"@inkeep/open-knowledge-desktop": patch
+---
+
+Opening a standalone Markdown file now works in unpackaged desktop builds.
diff --git a/packages/desktop/src/main/index.ts b/packages/desktop/src/main/index.ts
index d3d7ea907..012d69779 100644
--- a/packages/desktop/src/main/index.ts
+++ b/packages/desktop/src/main/index.ts
@@ -552,6 +552,7 @@ import {
setWindowInstanceLabel,
type UtilityProcessLike,
WindowManager,
+ type WindowManagerDeps,
} from './window-manager.ts';
import { WINDOW_MIN_SIZE } from './window-min-size.ts';
import { resolveRestoredPlacement, sortWindowsByFocusSequence } from './window-placement.ts';
@@ -1303,7 +1304,136 @@ function ensureWindowManager() {
'dist',
'cli.mjs',
)
- : null;
+ : join(__dirname, '../../../cli/dist/cli.mjs');
+
+ const spawnCliServer: NonNullable<WindowManagerDeps['spawnSingleFileServer']> = async ({
+ contentDir,
+ reactShellDistDir,
+ singleFile,
+ projectDir,
+ }) => {
+ const projectRoot = projectDir ?? contentDir;
+ const lockDir = getLocalDir(projectRoot);
+ if (!existsSync(lockDir)) {
+ try {
+ mkdirSync(lockDir, { recursive: true });
+ } catch (err) {
+ throw Object.assign(
+ new Error(
+ `spawnCliServer: failed to create lock dir at ${lockDir}: ${
+ err instanceof Error ? err.message : String(err)
+ }`,
+ ),
+ {
+ kind: 'spawn-error' as const,
+ code: (err as NodeJS.ErrnoException).code,
+ cause: err,
+ },
+ );
+ }
+ }
+ const spawnErrorLogPath = join(lockDir, SPAWN_ERROR_LOG);
+ let spawnErrorLogFd: number;
+ try {
+ spawnErrorLogFd = openSpawnErrorLog(spawnErrorLogPath, process.pid);
+ } catch (err) {
+ throw Object.assign(
+ new Error(
+ `spawnCliServer: failed to open spawn-error log fd at ${spawnErrorLogPath}: ${
+ err instanceof Error ? err.message : String(err)
+ }`,
+ ),
+ {
+ kind: 'spawn-error' as const,
+ code: (err as NodeJS.ErrnoException).code,
+ cause: err,
+ },
+ );
+ }
+ const spawnArgs = resolveDetachedSpawnArgs({
+ platform: process.platform,
+ isPackaged: app.isPackaged,
+ parentExecPath: process.execPath,
+ bundleCliMjsPath,
+ reactShellDistDir,
+ contentDir,
+ spawnErrorLogFd,
+ env: buildUtilityForkEnv(process.env, {
+ startupTraceparent: injectTraceparent(),
+ otlpEndpoint: process.env.OTEL_EXPORTER_OTLP_ENDPOINT,
+ }),
+ ...(singleFile !== undefined ? { singleFile, projectDir } : {}),
+ terminalAuthAvailable: isTerminalAvailable(),
+ });
+ let childRef: ReturnType<typeof spawn>;
+ startupWaterfall.mark('serverSpawned');
+ try {
+ childRef = spawn(spawnArgs.file, spawnArgs.args, {
+ ...spawnArgs.opts,
+ windowsHide: true,
+ });
+ } catch (spawnErr) {
+ try {
+ closeSync(spawnErrorLogFd);
+ } catch {}
+ throw Object.assign(
+ new Error(
+ `spawnCliServer: child_process.spawn threw synchronously: ${
+ spawnErr instanceof Error ? spawnErr.message : String(spawnErr)
+ }`,
+ ),
+ {
+ kind: 'spawn-error' as const,
+ code: (spawnErr as NodeJS.ErrnoException).code,
+ cause: spawnErr,
+ },
+ );
+ }
+ try {
+ await new Promise<void>((resolveSpawn, rejectSpawn) => {
+ const onSpawn = (): void => {
+ childRef.removeListener('error', onError);
+ resolveSpawn();
+ };
+ const onError = (err: Error): void => {
+ childRef.removeListener('spawn', onSpawn);
+ rejectSpawn(
+ Object.assign(
+ new Error(`spawnCliServer: child_process.spawn emitted 'error': ${err.message}`),
+ {
+ kind: 'spawn-error' as const,
+ code: (err as NodeJS.ErrnoException).code,
+ cause: err,
+ },
+ ),
+ );
+ };
+ childRef.once('spawn', onSpawn);
+ childRef.once('error', onError);
+ });
+ } finally {
+ try {
+ closeSync(spawnErrorLogFd);
+ } catch {}
+ }
+ let exitRecord: { code: number | null; signal: string | null } | null = null;
+ childRef.on('exit', (code, signal) => {
+ exitRecord = { code, signal };
+ });
+ attachServerExitObserver(childRef, {
+ lockDir,
+ recordExit: (info) => getServerExitRecorder().recordExit(info),
+ logger: getLogger('server-exit'),
+ });
+ childRef.unref();
+ const pid = childRef.pid;
+ if (pid === undefined) {
+ throw new Error(
+ 'spawnCliServer: child_process.spawn did not return a pid after spawn-event resolution.',
+ );
+ }
+ return { pid, readExit: () => exitRecord };
+ };
wm = new WindowManager({
createWindow: (opts) => {
@@ -1377,140 +1507,8 @@ function ensureWindowManager() {
},
terminalAuthAvailable: isTerminalAvailable(),
utilityEntryPath,
- ...(bundleCliMjsPath !== null
- ? {
- spawnDetachedServer: async ({
- contentDir,
- reactShellDistDir,
- singleFile,
- projectDir,
- }) => {
- const projectRoot = projectDir ?? contentDir;
- const lockDir = getLocalDir(projectRoot);
- if (!existsSync(lockDir)) {
- try {
- mkdirSync(lockDir, { recursive: true });
- } catch (err) {
- throw Object.assign(
- new Error(
- `spawnDetachedServer: failed to create lock dir at ${lockDir}: ${
- err instanceof Error ? err.message : String(err)
- }`,
- ),
- {
- kind: 'spawn-error' as const,
- code: (err as NodeJS.ErrnoException).code,
- cause: err,
- },
- );
- }
- }
- const spawnErrorLogPath = join(lockDir, SPAWN_ERROR_LOG);
- let spawnErrorLogFd: number;
- try {
- spawnErrorLogFd = openSpawnErrorLog(spawnErrorLogPath, process.pid);
- } catch (err) {
- throw Object.assign(
- new Error(
- `spawnDetachedServer: failed to open spawn-error log fd at ${spawnErrorLogPath}: ${
- err instanceof Error ? err.message : String(err)
- }`,
- ),
- {
- kind: 'spawn-error' as const,
- code: (err as NodeJS.ErrnoException).code,
- cause: err,
- },
- );
- }
- const spawnArgs = resolveDetachedSpawnArgs({
- platform: process.platform,
- isPackaged: app.isPackaged,
- parentExecPath: process.execPath,
- bundleCliMjsPath,
- reactShellDistDir,
- contentDir,
- spawnErrorLogFd,
- env: buildUtilityForkEnv(process.env, {
- startupTraceparent: injectTraceparent(),
- otlpEndpoint: process.env.OTEL_EXPORTER_OTLP_ENDPOINT,
- }),
- ...(singleFile !== undefined ? { singleFile, projectDir } : {}),
- terminalAuthAvailable: isTerminalAvailable(),
- });
- let childRef: ReturnType<typeof spawn>;
- startupWaterfall.mark('serverSpawned');
- try {
- childRef = spawn(spawnArgs.file, spawnArgs.args, {
- ...spawnArgs.opts,
- windowsHide: true,
- });
- } catch (spawnErr) {
- try {
- closeSync(spawnErrorLogFd);
- } catch {}
- throw Object.assign(
- new Error(
- `spawnDetachedServer: child_process.spawn threw synchronously: ${
- spawnErr instanceof Error ? spawnErr.message : String(spawnErr)
- }`,
- ),
- {
- kind: 'spawn-error' as const,
- code: (spawnErr as NodeJS.ErrnoException).code,
- cause: spawnErr,
- },
- );
- }
- try {
- await new Promise<void>((resolveSpawn, rejectSpawn) => {
- const onSpawn = (): void => {
- childRef.removeListener('error', onError);
- resolveSpawn();
- };
- const onError = (err: Error): void => {
- childRef.removeListener('spawn', onSpawn);
- rejectSpawn(
- Object.assign(
- new Error(
- `spawnDetachedServer: child_process.spawn emitted 'error': ${err.message}`,
- ),
- {
- kind: 'spawn-error' as const,
- code: (err as NodeJS.ErrnoException).code,
- cause: err,
- },
- ),
- );
- };
- childRef.once('spawn', onSpawn);
- childRef.once('error', onError);
- });
- } finally {
- try {
- closeSync(spawnErrorLogFd);
- } catch {}
- }
- let exitRecord: { code: number | null; signal: string | null } | null = null;
- childRef.on('exit', (code, signal) => {
- exitRecord = { code, signal };
- });
- attachServerExitObserver(childRef, {
- lockDir,
- recordExit: (info) => getServerExitRecorder().recordExit(info),
- logger: getLogger('server-exit'),
- });
- childRef.unref();
- const pid = childRef.pid;
- if (pid === undefined) {
- throw new Error(
- 'spawnDetachedServer: child_process.spawn did not return a pid after spawn-event resolution.',
- );
- }
- return { pid, readExit: () => exitRecord };
- },
- }
- : {}),
+ spawnSingleFileServer: spawnCliServer,
+ ...(app.isPackaged ? { spawnDetachedServer: spawnCliServer } : {}),
createEphemeralProjectDir,
removeDir: (dir: string) => fsPromises.rm(dir, { recursive: true, force: true }),
rendererEntryPath,
diff --git a/packages/desktop/src/main/window-manager.ts b/packages/desktop/src/main/window-manager.ts
index 2b377adab..7ebad7559 100644
--- a/packages/desktop/src/main/window-manager.ts
+++ b/packages/desktop/src/main/window-manager.ts
@@ -320,6 +320,16 @@ interface CreateProjectWindowOpts {
freshlyCreated?: boolean;
}
+type SpawnCliServer = (opts: {
+ contentDir: string;
+ reactShellDistDir: string;
+ singleFile?: string;
+ projectDir?: string;
+}) => Promise<{
+ pid: number;
+ readExit?: () => { code: number | null; signal: string | null } | null;
+}>;
+
export interface WindowManagerDeps {
createWindow(opts: {
additionalArguments: string[];
@@ -333,15 +343,8 @@ export interface WindowManagerDeps {
opts: { windowLifecycleBound?: boolean; serviceName: string },
): UtilityProcessLike;
utilityEntryPath: string;
- spawnDetachedServer?(opts: {
- contentDir: string;
- reactShellDistDir: string;
- singleFile?: string;
- projectDir?: string;
- }): Promise<{
- pid: number;
- readExit?: () => { code: number | null; signal: string | null } | null;
- }>;
+ spawnDetachedServer?: SpawnCliServer;
+ spawnSingleFileServer?: SpawnCliServer;
createEphemeralProjectDir?(contentDir: string): string;
removeDir?(dir: string): Promise<void>;
spawnLockPollDeadlineMs?: number;
@@ -1770,10 +1773,10 @@ export class WindowManager {
opts: { canonicalFilePath: string; contentDir: string; docName: string },
canonicalKey: string,
): Promise<ProjectContext> {
- const { createEphemeralProjectDir, spawnDetachedServer, removeDir } = this.deps;
- if (!createEphemeralProjectDir || !spawnDetachedServer || !removeDir) {
+ const { createEphemeralProjectDir, spawnSingleFileServer, removeDir } = this.deps;
+ if (!createEphemeralProjectDir || !spawnSingleFileServer || !removeDir) {
throw new Error(
- 'createEphemeralWindow requires createEphemeralProjectDir + spawnDetachedServer + removeDir deps to be wired',
+ 'createEphemeralWindow requires createEphemeralProjectDir + spawnSingleFileServer + removeDir deps to be wired',
);
}
@@ -1783,9 +1786,9 @@ export class WindowManager {
const lockDir = getLocalDir(tempProjectDir);
const reactShellDistDir = dirname(this.deps.rendererEntryPath);
- let handle: Awaited<ReturnType<NonNullable<WindowManagerDeps['spawnDetachedServer']>>>;
+ let handle: Awaited<ReturnType<SpawnCliServer>>;
try {
- handle = await spawnDetachedServer({
+ handle = await spawnSingleFileServer({
contentDir: opts.contentDir,
reactShellDistDir,
singleFile: opts.canonicalFilePath,
diff --git a/packages/desktop/tests/main/window-manager-ephemeral.test.ts b/packages/desktop/tests/main/window-manager-ephemeral.test.ts
index 2fe5d780c..a3d3baa2d 100644
--- a/packages/desktop/tests/main/window-manager-ephemeral.test.ts
+++ b/packages/desktop/tests/main/window-manager-ephemeral.test.ts
@@ -148,7 +148,7 @@ function buildEphemeralEnv(): EphemeralEnv {
removedDirs.push(dir);
effectLog.push(`rm:${dir}`);
},
- spawnDetachedServer: async (opts) => {
+ spawnSingleFileServer: async (opts) => {
spawnCalls.push(opts);
const pid = ++pidCounter;
if (env.publishLock && opts.projectDir !== undefined) {
@@ -354,7 +354,7 @@ describe('createEphemeralWindow', () => {
recordingKill(pid, signal);
if (signal === 'SIGTERM') exitRecord = { code: null, signal: 'SIGTERM' };
};
- env.deps.spawnDetachedServer = async () => ({ pid: 42001, readExit: () => exitRecord });
+ env.deps.spawnSingleFileServer = async () => ({ pid: 42001, readExit: () => exitRecord });
const wm = new WindowManager(env.deps);
const err = await wm
@@ -372,7 +372,7 @@ describe('createEphemeralWindow', () => {
});
test('a spawn failure removes the temp dir before rethrowing (no leak)', async () => {
- env.deps.spawnDetachedServer = async () => {
+ env.deps.spawnSingleFileServer = async () => {
throw Object.assign(new Error('spawn boom'), { kind: 'spawn-error' });
};
const wm = new WindowManager(env.deps);
@@ -500,6 +500,23 @@ describe('createEphemeralWindow', () => {
).rejects.toThrow(/requires createEphemeralProjectDir/);
});
+ test('opens a single file through its own spawner when a project spawner exists', async () => {
+ const projectSpawn = vi.fn(async () => {
+ throw new Error('project server spawner must not handle a single file');
+ });
+ env.deps.spawnDetachedServer = projectSpawn;
+ const wm = new WindowManager(env.deps);
+
+ const ctx = await wm.createEphemeralWindow({
+ canonicalFilePath: FILE,
+ contentDir: PARENT,
+ docName: 'todo',
+ });
+
+ expect(ctx.ephemeral?.pid).toBe(42001);
+ expect(env.spawnCalls).toHaveLength(1);
+ });
+
test('re-open after the ephemeral server dies spawns a FRESH live session, not the dead one', async () => {
const wm = new WindowManager(env.deps);
const first = await wm.createEphemeralWindow({
@@ -817,7 +834,7 @@ describe('ephemeral keepalive lifecycle', () => {
expect(ka.handles[0]?.closed).toBe(false);
env.killServer(first.ephemeral?.pid as number);
- env.deps.spawnDetachedServer = async () => {
+ env.deps.spawnSingleFileServer = async () => {
throw Object.assign(new Error('spawn boom'), { kind: 'spawn-error' });
};
await expect(
@@ -1030,7 +1047,7 @@ describe('restartEphemeralServer', () => {
});
const identity = identityOf(wm, first.window);
env.killServer(first.ephemeral?.pid as number);
- env.deps.spawnDetachedServer = async () => {
+ env.deps.spawnSingleFileServer = async () => {
throw Object.assign(new Error('spawn boom'), { kind: 'spawn-error' });
};
diff --git a/packages/desktop/tests/main/window-manager-safety-net.test.ts b/packages/desktop/tests/main/window-manager-safety-net.test.ts
index 9a81bc3a9..7ce39d92f 100644
--- a/packages/desktop/tests/main/window-manager-safety-net.test.ts
+++ b/packages/desktop/tests/main/window-manager-safety-net.test.ts
@@ -141,7 +141,7 @@ function withEphemeralDeps(env: TestEnv): void {
env.deps.removeDir = async () => {};
env.deps.isProcessAlive = () => true;
env.deps.readServerLock = (lockDir) => ephemeralLocks.get(lockDir) ?? null;
- env.deps.spawnDetachedServer = async (opts) => {
+ env.deps.spawnSingleFileServer = async (opts) => {
const spawnedPid = ++pid;
if (opts.projectDir !== undefined) {
ephemeralLocks.set(getLocalDir(opts.projectDir), {
diff --git a/packages/desktop/tests/main/window-manager.test.ts b/packages/desktop/tests/main/window-manager.test.ts
index 6af88be6e..4cf9df799 100644
--- a/packages/desktop/tests/main/window-manager.test.ts
+++ b/packages/desktop/tests/main/window-manager.test.ts
@@ -316,6 +316,20 @@ describe('WindowManager', () => {
await secondPromise;
});
+ test('single-file spawning does not switch project opens away from the utility', async () => {
+ const singleFileSpawn = vi.fn(async () => ({ pid: 88001 }));
+ env.deps.spawnSingleFileServer = singleFileSpawn;
+ const wm = new WindowManager(env.deps);
+
+ const pending = wm.createProjectWindow({ projectPath: '/tmp/single-file-capable-project' });
+ expect(env.utilities).toHaveLength(1);
+ expect(singleFileSpawn).not.toHaveBeenCalled();
+ env.utilities[0]?.fire({ type: 'ready', port: 52012, apiOrigin: 'http://localhost:52012' });
+
+ const ctx = await pending;
+ expect(ctx.utility).toBe(env.utilities[0]);
+ });
+
test('createProjectWindow binds the utility server to numeric IPv4 loopback, never a hostname', async () => {
const wm = new WindowManager(env.deps);
const promise = wm.createProjectWindow({ projectPath: '/tmp/loopback-bind' });
diff --git a/packages/desktop/tests/smoke/_helpers/platform-gate.ts b/packages/desktop/tests/smoke/_helpers/platform-gate.ts
index c37a6cd85..aa2419d36 100644
--- a/packages/desktop/tests/smoke/_helpers/platform-gate.ts
+++ b/packages/desktop/tests/smoke/_helpers/platform-gate.ts
@@ -61,6 +61,7 @@ export const SPEC_PLATFORM_GATES = {
'terminal-tabs.e2e.ts': ['!PTY_PLATFORM_SUPPORTED', '!WINDOWS'],
'terminal-window.e2e.ts': ['!PTY_PLATFORM_SUPPORTED'],
'theme-sync.e2e.ts': ['!DARWIN'],
+ 'unpackaged-open-file.e2e.ts': ['!PLATFORM_SUPPORTED'],
'uninstall-ipc-bridge.e2e.ts': ['!DARWIN'],
'uninstall-result.e2e.ts': ['!DARWIN', '!DARWIN'],
'uninstall-notice.e2e.ts': ['!DARWIN'],
diff --git a/packages/desktop/tests/smoke/_helpers/stale-build-guard.test.ts b/packages/desktop/tests/smoke/_helpers/stale-build-guard.test.ts
index 67aa8e591..096c47e43 100644
--- a/packages/desktop/tests/smoke/_helpers/stale-build-guard.test.ts
+++ b/packages/desktop/tests/smoke/_helpers/stale-build-guard.test.ts
@@ -186,6 +186,10 @@ describe('the real CHECKS list, not an injected one', () => {
});
const cli = verdict.missing.find((m) => m.name.includes('CLI'));
expect(cli?.out).toMatch(/cli[/\\]dist[/\\]index\.mjs$/);
+ const cliExecutable = verdict.missing.find(
+ (m) => m.name === '@inkeep/open-knowledge CLI executable',
+ );
+ expect(cliExecutable?.out).toMatch(/cli[/\\]dist[/\\]cli\.mjs$/);
expect(verdict.missing.map((m) => m.name)).toEqual([
'main dispatcher',
'uninstall result window',
@@ -194,6 +198,7 @@ describe('the real CHECKS list, not an injected one', () => {
'renderer',
'utility server entry',
'@inkeep/open-knowledge CLI',
+ '@inkeep/open-knowledge CLI executable',
]);
});
});
diff --git a/packages/desktop/tests/smoke/_helpers/stale-build-guard.ts b/packages/desktop/tests/smoke/_helpers/stale-build-guard.ts
index 18259a5db..670796e1c 100644
--- a/packages/desktop/tests/smoke/_helpers/stale-build-guard.ts
+++ b/packages/desktop/tests/smoke/_helpers/stale-build-guard.ts
@@ -66,6 +66,11 @@ const CHECKS: BuildArtifactCheck[] = [
out: resolve(DESKTOP_PKG, '..', 'cli', 'dist', 'index.mjs'),
srcs: [],
},
+ {
+ name: '@inkeep/open-knowledge CLI executable',
+ out: resolve(DESKTOP_PKG, '..', 'cli', 'dist', 'cli.mjs'),
+ srcs: [resolve(DESKTOP_PKG, '..', 'cli', 'src', 'cli.ts')],
+ },
];
export interface GuardDeps {
diff --git a/packages/desktop/tests/smoke/unpackaged-open-file.e2e.ts b/packages/desktop/tests/smoke/unpackaged-open-file.e2e.ts
new file mode 100644
index 000000000..8279aad43
--- /dev/null
+++ b/packages/desktop/tests/smoke/unpackaged-open-file.e2e.ts
@@ -0,0 +1,122 @@
+import { mkdirSync, mkdtempSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { _electron as electron } from '@playwright/test';
+import { desktopLaunchOptions, resolveDesktopTarget } from './_helpers/launch-desktop';
+import { readBootLogLines } from './_helpers/launch-readiness';
+import {
+ homeEnv,
+ PLATFORM_SKIP_REASON,
+ PLATFORM_SUPPORTED,
+ SMOKE_ENABLED,
+ userDataDirFor,
+} from './_helpers/platform-gate';
+import { expect, test } from './_helpers/smoke-test';
+
+const TARGET = resolveDesktopTarget();
+
+function launchOptions(tmpHome: string) {
+ return desktopLaunchOptions({
+ target: TARGET,
+ args: [`--user-data-dir=${userDataDirFor(tmpHome)}`],
+ env: {
+ ...homeEnv(tmpHome),
+ TMPDIR: tmpHome,
+ TMP: tmpHome,
+ TEMP: tmpHome,
+ OK_DESKTOP_E2E_SMOKE: '1',
+ },
+ });
+}
+
+test.describe('unpackaged single-file open', () => {
+ test.skip(!SMOKE_ENABLED, 'Set OK_DESKTOP_E2E_SMOKE=1 to run Electron smoke tests.');
+ test.skip(!PLATFORM_SUPPORTED, PLATFORM_SKIP_REASON);
+ test.skip(TARGET.mode !== 'unpackaged', 'This regression is specific to unpackaged Electron.');
+ test.skip(!TARGET.exists, TARGET.missingReason);
+
+ test('opens a standalone Markdown file in an editor window', async ({ captureStderrFor }) => {
+ const tmpHome = mkdtempSync(join(tmpdir(), 'ok-unpackaged-open-file-'));
+ const notesDir = join(tmpHome, 'notes');
+ mkdirSync(notesDir);
+ const filePath = join(notesDir, 'standalone.md');
+ writeFileSync(filePath, '# Ephemeral file opened\n\nA standalone note.\n');
+
+ const app = await electron.launch(launchOptions(tmpHome));
+ captureStderrFor(app, { home: tmpHome, cleanupDirs: [tmpHome] });
+
+ const navigator = await app.firstWindow();
+ await expect(navigator.getByTestId('nav-open-file')).toBeVisible();
+
+ await app.evaluate(({ app: electronApp }, file) => {
+ electronApp.emit('open-file', { preventDefault() {} }, file);
+ }, filePath);
+
+ await expect
+ .poll(
+ async () => {
+ for (const page of app.windows()) {
+ const singleFile = await page
+ .evaluate(() => window.okDesktop?.config?.singleFile)
+ .catch(() => false);
+ if (singleFile) return true;
+ }
+ return false;
+ },
+ { timeout: 45_000, message: 'the standalone file never opened in an editor window' },
+ )
+ .toBe(true);
+
+ const editor = app.windows().find((window) => window !== navigator);
+ if (editor === undefined) throw new Error('the single-file editor window vanished');
+ await expect(editor.getByRole('heading', { name: 'Ephemeral file opened' })).toBeVisible();
+ await app.evaluate(({ app: electronApp }) => {
+ setImmediate(() => electronApp.quit());
+ });
+ });
+
+ test('keeps normal project opens on the utility process', async ({ captureStderrFor }) => {
+ const tmpHome = mkdtempSync(join(tmpdir(), 'ok-unpackaged-project-server-'));
+ const projectDir = join(tmpHome, 'project');
+ mkdirSync(join(projectDir, '.ok'), { recursive: true });
+ writeFileSync(join(projectDir, '.ok', 'config.yml'), "content:\n dir: '.'\n");
+ writeFileSync(join(projectDir, 'note.md'), '# Project note\n');
+
+ const app = await electron.launch(launchOptions(tmpHome));
+ captureStderrFor(app, { home: tmpHome, cleanupDirs: [tmpHome] });
+ const navigator = await app.firstWindow();
+ await expect(navigator.getByTestId('nav-open')).toBeVisible();
+ await navigator.evaluate(async (path) => {
+ await window.okDesktop?.project.open({ path, target: 'new-window', entryPoint: 'recents' });
+ }, projectDir);
+
+ await expect
+ .poll(
+ async () => {
+ for (const page of app.windows()) {
+ const mode = await page
+ .evaluate(() => window.okDesktop?.config?.mode)
+ .catch(() => null);
+ if (mode === 'editor') return true;
+ }
+ return false;
+ },
+ { timeout: 45_000, message: 'project editor did not appear after opening the folder' },
+ )
+ .toBe(true);
+
+ await expect
+ .poll(
+ () =>
+ readBootLogLines(tmpHome).some((line) =>
+ line.includes('"event":"desktop-project-server-forked"'),
+ ),
+ { timeout: 30_000, message: 'unpackaged project never logged a utility fork' },
+ )
+ .toBe(true);
+
+ await app.evaluate(({ app: electronApp }) => {
+ setImmediate(() => electronApp.quit());
+ });
+ });
+});