runwork 0.10.2 → 0.10.3

package/dist/dev/__tests__/detach.test.js

@@ -0,0 +1,328 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { pollForSession, runAsDetachedParent, isInternalDetachedChild, stripInternalChildFlag, INTERNAL_DETACHED_CHILD_FLAG, } from '../detach.js';
+import { buildSessionFile, getSessionPaths, writeSessionFile, } from '../session.js';
+function createTmpAppDir() {
+    return fs.mkdtempSync(path.join(os.tmpdir(), 'runwork-detach-test-'));
+}
+function makeSessionFile(overrides = {}) {
+    return buildSessionFile({
+        pid: 11111,
+        sessionId: 'sess_test',
+        appId: 'test-app',
+        previewUrl: 'https://x.example',
+        cliVersion: '0.10.2',
+        mode: 'detached',
+        deps: { bootTime: () => 1_000_000_000_000 },
+        ...overrides,
+    });
+}
+describe('isInternalDetachedChild() / stripInternalChildFlag()', () => {
+    it('detects the internal marker', () => {
+        expect(isInternalDetachedChild(['runwork', 'dev', '--detach', INTERNAL_DETACHED_CHILD_FLAG])).toBe(true);
+        expect(isInternalDetachedChild(['runwork', 'dev', '--detach'])).toBe(false);
+        expect(isInternalDetachedChild(['runwork'])).toBe(false);
+    });
+    it('strips the marker but leaves other args alone', () => {
+        expect(stripInternalChildFlag([
+            'dev', '--detach', INTERNAL_DETACHED_CHILD_FLAG, '--json',
+        ])).toEqual(['dev', '--detach', '--json']);
+        expect(stripInternalChildFlag(['dev', '--detach'])).toEqual(['dev', '--detach']);
+    });
+});
+describe('pollForSession()', () => {
+    let appDir;
+    beforeEach(() => {
+        appDir = createTmpAppDir();
+    });
+    afterEach(() => {
+        if (fs.existsSync(appDir)) {
+            fs.rmSync(appDir, { recursive: true, force: true });
+        }
+    });
+    it('returns "ready" immediately when the file is already present and matches', async () => {
+        const file = makeSessionFile({ pid: 12345 });
+        writeSessionFile(appDir, file);
+        const out = await pollForSession(appDir, 12345, 'test-app', {
+            intervalMs: 10,
+            timeoutMs: 1000,
+        });
+        expect(out.result).toBe('ready');
+        if (out.result === 'ready') {
+            expect(out.file).toEqual(file);
+        }
+    });
+    it('returns "ready" once the file appears mid-poll', async () => {
+        setTimeout(() => {
+            writeSessionFile(appDir, makeSessionFile({ pid: 22222 }));
+        }, 80);
+        const out = await pollForSession(appDir, 22222, 'test-app', {
+            intervalMs: 20,
+            timeoutMs: 1000,
+        });
+        expect(out.result).toBe('ready');
+    });
+    it('keeps polling past an intermediate empty-previewUrl write and resolves on the URL update', async () => {
+        // Simulate the child writing the file early without a URL -- the
+        // poller must NOT accept that as ready, and must wait for the URL
+        // update.
+        writeSessionFile(appDir, makeSessionFile({ pid: 33333, previewUrl: '' }));
+        setTimeout(() => {
+            writeSessionFile(appDir, makeSessionFile({ pid: 33333, previewUrl: 'https://late.example' }));
+        }, 100);
+        const out = await pollForSession(appDir, 33333, 'test-app', {
+            intervalMs: 20,
+            timeoutMs: 1000,
+        });
+        expect(out.result).toBe('ready');
+        if (out.result === 'ready') {
+            expect(out.file.previewUrl).toBe('https://late.example');
+        }
+    });
+    it('returns "wrong-pid" when a file appears with a different pid (race winner)', async () => {
+        writeSessionFile(appDir, makeSessionFile({ pid: 99999 }));
+        const out = await pollForSession(appDir, 12345, 'test-app', {
+            intervalMs: 10,
+            timeoutMs: 500,
+        });
+        expect(out.result).toBe('wrong-pid');
+        if (out.result === 'wrong-pid') {
+            expect(out.file.pid).toBe(99999);
+        }
+    });
+    it('keeps polling past a different-app file (foreign session file in the same dir)', async () => {
+        // Edge case: the file's appId doesn't match the one we expect. We
+        // ignore it (rather than treat as wrong-pid) so this kind of stale
+        // cross-app contamination doesn't accidentally short-circuit our
+        // detach handshake.
+        writeSessionFile(appDir, makeSessionFile({ pid: 99999, appId: 'other-app' }));
+        setTimeout(() => {
+            writeSessionFile(appDir, makeSessionFile({ pid: 12345, appId: 'test-app' }));
+        }, 80);
+        const out = await pollForSession(appDir, 12345, 'test-app', {
+            intervalMs: 20,
+            timeoutMs: 1000,
+        });
+        expect(out.result).toBe('ready');
+        if (out.result === 'ready') {
+            expect(out.file.pid).toBe(12345);
+        }
+    });
+    it('returns "timeout" when the file never appears', async () => {
+        const out = await pollForSession(appDir, 12345, 'test-app', {
+            intervalMs: 20,
+            timeoutMs: 100,
+        });
+        expect(out.result).toBe('timeout');
+    });
+    it('returns "child-exited" mid-poll when isChildAlive flips to false', async () => {
+        let alive = true;
+        setTimeout(() => { alive = false; }, 60);
+        const out = await pollForSession(appDir, 12345, 'test-app', {
+            intervalMs: 20,
+            timeoutMs: 1000,
+            isChildAlive: () => alive,
+        });
+        expect(out.result).toBe('child-exited');
+    });
+    it('catches a child that exited just at the deadline (final probe)', async () => {
+        // The child stays "alive" through the loop (no probe ever sees
+        // false), but exits in the gap between the last sleep and the
+        // deadline check. The trailing isChildAlive probe surfaces this
+        // as child-exited rather than a misleading timeout.
+        let probeCount = 0;
+        const out = await pollForSession(appDir, 12345, 'test-app', {
+            intervalMs: 20,
+            timeoutMs: 60,
+            isChildAlive: () => {
+                probeCount += 1;
+                // Only fail on the very last (post-loop) probe.
+                return probeCount < 100;
+            },
+        });
+        // We can hit either branch depending on probe ordering -- but with
+        // a finite timeout we should never see "ready" or "wrong-pid".
+        expect(['child-exited', 'timeout']).toContain(out.result);
+    });
+});
+describe('runAsDetachedParent()', () => {
+    let appDir;
+    beforeEach(() => {
+        appDir = createTmpAppDir();
+    });
+    afterEach(() => {
+        if (fs.existsSync(appDir)) {
+            fs.rmSync(appDir, { recursive: true, force: true });
+        }
+    });
+    it('orchestrates spawn -> poll -> ready when the mock child writes the file', async () => {
+        const childPid = 54321;
+        const spawn = vi.fn(() => {
+            // Schedule the "child" to write the session file shortly after spawn.
+            setTimeout(() => {
+                writeSessionFile(appDir, makeSessionFile({ pid: childPid, previewUrl: 'https://detached.example' }));
+            }, 50);
+            return {
+                pid: childPid,
+                kill: vi.fn(() => true),
+                isAlive: () => true,
+            };
+        });
+        const out = await runAsDetachedParent({
+            appDir,
+            expectedAppId: 'test-app',
+            childArgs: ['dev', '--detach', INTERNAL_DETACHED_CHILD_FLAG],
+            intervalMs: 20,
+            timeoutMs: 1000,
+            spawn,
+        });
+        expect(spawn).toHaveBeenCalledOnce();
+        expect(out.result).toBe('started');
+        if (out.result === 'started') {
+            expect(out.file.pid).toBe(childPid);
+            expect(out.file.previewUrl).toBe('https://detached.example');
+        }
+    });
+    it('on timeout: kills the child, removes our partial file, returns childLogTail when stderr exists', async () => {
+        const kill = vi.fn(() => true);
+        const spawn = vi.fn(() => {
+            // Pre-create a stderr log with a known tail so we can assert it's
+            // surfaced. The fake child does not write a session file.
+            const paths = getSessionPaths(appDir);
+            fs.mkdirSync(paths.dir, { recursive: true });
+            fs.writeFileSync(paths.stderrLog, 'fatal: sandbox failed to boot\n', 'utf-8');
+            return { pid: 12345, kill, isAlive: () => true };
+        });
+        const out = await runAsDetachedParent({
+            appDir,
+            expectedAppId: 'test-app',
+            childArgs: ['dev', '--detach', INTERNAL_DETACHED_CHILD_FLAG],
+            intervalMs: 20,
+            timeoutMs: 80,
+            spawn,
+        });
+        expect(out.result).toBe('timeout');
+        if (out.result === 'timeout') {
+            expect(out.ourPid).toBe(12345);
+            expect(out.childLogTail).toContain('fatal: sandbox failed to boot');
+        }
+        expect(kill).toHaveBeenCalledWith('SIGTERM');
+    });
+    it('on timeout: leaves another process\'s session file untouched (PID-aware cleanup)', async () => {
+        // Race: our child timed out, but in the meantime another process
+        // wrote its OWN session file with a different PID. We must NOT
+        // remove that file -- it belongs to the winner.
+        const winnerFile = makeSessionFile({ pid: 99999, previewUrl: 'https://winner.example' });
+        writeSessionFile(appDir, winnerFile);
+        const spawn = vi.fn(() => ({
+            pid: 12345,
+            kill: vi.fn(() => true),
+            // Pretend our child is alive (so we don't take the child-exited
+            // path) but write nothing -- triggering timeout. wrong-pid would
+            // also fire here since the file's appId matches; we use a
+            // different appId on the file to isolate the timeout path.
+            isAlive: () => true,
+        }));
+        // Overwrite with a foreign-app file so wrong-pid doesn't fire and
+        // we land in the timeout branch.
+        writeSessionFile(appDir, makeSessionFile({ pid: 99999, appId: 'other-app', previewUrl: 'https://other.example' }));
+        const out = await runAsDetachedParent({
+            appDir,
+            expectedAppId: 'test-app',
+            childArgs: [],
+            intervalMs: 10,
+            timeoutMs: 80,
+            spawn,
+        });
+        expect(out.result).toBe('timeout');
+        // The foreign file is still there.
+        const stillThere = fs.existsSync(getSessionPaths(appDir).file);
+        expect(stillThere).toBe(true);
+    });
+    it('returns "spawn-failed" when the spawn override throws', async () => {
+        const spawn = vi.fn(() => { throw new Error('execvp: ENOENT'); });
+        const out = await runAsDetachedParent({
+            appDir,
+            expectedAppId: 'test-app',
+            childArgs: [],
+            intervalMs: 10,
+            timeoutMs: 100,
+            spawn,
+        });
+        expect(out.result).toBe('spawn-failed');
+    });
+    it('returns "spawn-failed" when the child has no pid', async () => {
+        const spawn = vi.fn(() => ({ pid: 0, kill: vi.fn(() => true), isAlive: () => true }));
+        const out = await runAsDetachedParent({
+            appDir,
+            expectedAppId: 'test-app',
+            childArgs: [],
+            intervalMs: 10,
+            timeoutMs: 100,
+            spawn,
+        });
+        expect(out.result).toBe('spawn-failed');
+    });
+    it('returns "wrong-pid" AND kills the child when another process wins the write race', async () => {
+        // Codex review #2: leaving the loser child running would cause it
+        // to overwrite the winner's session file moments later. Killing
+        // the loser is the correct behavior.
+        const kill = vi.fn(() => true);
+        const spawn = vi.fn(() => {
+            setTimeout(() => {
+                writeSessionFile(appDir, makeSessionFile({ pid: 99999, previewUrl: 'https://winner.example' }));
+            }, 30);
+            return { pid: 12345, kill, isAlive: () => true };
+        });
+        const out = await runAsDetachedParent({
+            appDir,
+            expectedAppId: 'test-app',
+            childArgs: [],
+            intervalMs: 10,
+            timeoutMs: 1000,
+            spawn,
+        });
+        expect(out.result).toBe('wrong-pid');
+        if (out.result === 'wrong-pid') {
+            expect(out.ourPid).toBe(12345);
+            expect(out.file.pid).toBe(99999);
+        }
+        expect(kill).toHaveBeenCalledWith('SIGTERM');
+    });
+    it('returns "child-exited" promptly when the spawned child dies before writing the session file', async () => {
+        // Codex review #1: without an isAlive probe, a fast-failing child
+        // (missing auth, sync conflict, etc.) leaves the parent hanging
+        // for the full 90s timeout instead of surfacing the failure.
+        const paths = getSessionPaths(appDir);
+        fs.mkdirSync(paths.dir, { recursive: true });
+        fs.writeFileSync(paths.stderrLog, 'fatal: not authenticated\n', 'utf-8');
+        let alive = true;
+        const kill = vi.fn(() => true);
+        const spawn = vi.fn(() => {
+            // Simulate the child dying ~50ms after spawn (well before the
+            // 1000ms timeout), without ever writing a session file.
+            setTimeout(() => { alive = false; }, 50);
+            return { pid: 12345, kill, isAlive: () => alive };
+        });
+        const start = Date.now();
+        const out = await runAsDetachedParent({
+            appDir,
+            expectedAppId: 'test-app',
+            childArgs: [],
+            intervalMs: 20,
+            timeoutMs: 1000,
+            spawn,
+        });
+        const elapsed = Date.now() - start;
+        expect(out.result).toBe('child-exited');
+        if (out.result === 'child-exited') {
+            expect(out.ourPid).toBe(12345);
+            expect(out.childLogTail).toContain('fatal: not authenticated');
+        }
+        // The whole point of this fix: we should resolve far below the
+        // timeout, not at 1000ms. Allow a generous bound for CI noise.
+        expect(elapsed).toBeLessThan(500);
+    });
+});

package/dist/dev/__tests__/preview-url-poller.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/dev/__tests__/preview-url-poller.test.js

@@ -0,0 +1,149 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { startPreviewUrlPoller } from '../preview-url-poller.js';
+function makeClient(getDevStatus) {
+    return { getDevStatus };
+}
+describe('startPreviewUrlPoller', () => {
+    beforeEach(() => {
+        vi.useFakeTimers();
+    });
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+    it('does not fire onChange when the URL stays the same', async () => {
+        const onChange = vi.fn();
+        const getDevStatus = vi.fn().mockResolvedValue({
+            previewUrl: 'https://stable.example',
+            sessionId: 's',
+            appId: 'a',
+        });
+        const poller = startPreviewUrlPoller({
+            client: makeClient(getDevStatus),
+            appId: 'a',
+            initialUrl: 'https://stable.example',
+            intervalMs: 1000,
+            onChange,
+        });
+        await vi.advanceTimersByTimeAsync(2500);
+        expect(getDevStatus).toHaveBeenCalled();
+        expect(onChange).not.toHaveBeenCalled();
+        expect(poller.getCurrent()).toBe('https://stable.example');
+        poller.stop();
+    });
+    it('fires onChange with previous URL and updates getCurrent() when the URL rotates', async () => {
+        const onChange = vi.fn();
+        const getDevStatus = vi.fn()
+            .mockResolvedValueOnce({ previewUrl: 'https://old.example', sessionId: 's', appId: 'a' })
+            .mockResolvedValue({ previewUrl: 'https://new.example', sessionId: 's', appId: 'a' });
+        const poller = startPreviewUrlPoller({
+            client: makeClient(getDevStatus),
+            appId: 'a',
+            initialUrl: 'https://old.example',
+            intervalMs: 1000,
+            onChange,
+        });
+        // First tick at t=1000 returns the unchanged URL: no onChange.
+        await vi.advanceTimersByTimeAsync(1500);
+        expect(onChange).not.toHaveBeenCalled();
+        expect(poller.getCurrent()).toBe('https://old.example');
+        // Second tick at t=2000 returns a new URL: onChange fires.
+        await vi.advanceTimersByTimeAsync(1000);
+        expect(onChange).toHaveBeenCalledTimes(1);
+        expect(onChange).toHaveBeenCalledWith('https://new.example', 'https://old.example');
+        expect(poller.getCurrent()).toBe('https://new.example');
+        poller.stop();
+    });
+    it('ignores transient empty URLs from the server (sandbox restart in flight)', async () => {
+        const onChange = vi.fn();
+        // Server briefly reports "" while replacing the sandbox; we should
+        // hold the last known good URL rather than flicker the status line.
+        const getDevStatus = vi.fn().mockResolvedValue({
+            previewUrl: '',
+            sessionId: 's',
+            appId: 'a',
+        });
+        const poller = startPreviewUrlPoller({
+            client: makeClient(getDevStatus),
+            appId: 'a',
+            initialUrl: 'https://stable.example',
+            intervalMs: 1000,
+            onChange,
+        });
+        await vi.advanceTimersByTimeAsync(3000);
+        expect(onChange).not.toHaveBeenCalled();
+        expect(poller.getCurrent()).toBe('https://stable.example');
+        poller.stop();
+    });
+    it('keeps polling after a failed fetch and reports the error', async () => {
+        const onChange = vi.fn();
+        const onError = vi.fn();
+        const getDevStatus = vi.fn()
+            .mockRejectedValueOnce(new Error('network down'))
+            .mockResolvedValue({ previewUrl: 'https://recovered.example', sessionId: 's', appId: 'a' });
+        const poller = startPreviewUrlPoller({
+            client: makeClient(getDevStatus),
+            appId: 'a',
+            initialUrl: 'https://old.example',
+            intervalMs: 1000,
+            onChange,
+            onError,
+        });
+        // First tick rejects.
+        await vi.advanceTimersByTimeAsync(1500);
+        expect(onError).toHaveBeenCalledTimes(1);
+        expect(onChange).not.toHaveBeenCalled();
+        expect(poller.getCurrent()).toBe('https://old.example');
+        // Second tick recovers.
+        await vi.advanceTimersByTimeAsync(1000);
+        expect(onChange).toHaveBeenCalledWith('https://recovered.example', 'https://old.example');
+        expect(poller.getCurrent()).toBe('https://recovered.example');
+        poller.stop();
+    });
+    it('stop() cancels future polls', async () => {
+        const onChange = vi.fn();
+        const getDevStatus = vi.fn().mockResolvedValue({
+            previewUrl: 'https://new.example',
+            sessionId: 's',
+            appId: 'a',
+        });
+        const poller = startPreviewUrlPoller({
+            client: makeClient(getDevStatus),
+            appId: 'a',
+            initialUrl: 'https://old.example',
+            intervalMs: 1000,
+            onChange,
+        });
+        poller.stop();
+        await vi.advanceTimersByTimeAsync(5000);
+        expect(getDevStatus).not.toHaveBeenCalled();
+        expect(onChange).not.toHaveBeenCalled();
+    });
+    it('skips overlapping ticks while a previous fetch is still in flight', async () => {
+        const onChange = vi.fn();
+        let resolveFirst;
+        const getDevStatus = vi.fn().mockImplementation(() => {
+            // First call returns a promise that we control manually; subsequent
+            // calls would resolve immediately, but the in-flight guard should
+            // prevent them from firing at all.
+            if (!resolveFirst) {
+                return new Promise((r) => { resolveFirst = r; });
+            }
+            return Promise.resolve({ previewUrl: 'https://later.example', sessionId: 's', appId: 'a' });
+        });
+        const poller = startPreviewUrlPoller({
+            client: makeClient(getDevStatus),
+            appId: 'a',
+            initialUrl: 'https://initial.example',
+            intervalMs: 1000,
+            onChange,
+        });
+        // Fire several intervals while the first fetch is still pending.
+        await vi.advanceTimersByTimeAsync(4500);
+        expect(getDevStatus).toHaveBeenCalledTimes(1);
+        // Resolve it and advance one more interval -- now the next tick fires.
+        resolveFirst({ previewUrl: 'https://initial.example', sessionId: 's', appId: 'a' });
+        await vi.advanceTimersByTimeAsync(1000);
+        expect(getDevStatus).toHaveBeenCalledTimes(2);
+        poller.stop();
+    });
+});

package/dist/dev/__tests__/session.test.d.ts

@@ -0,0 +1 @@
+export {};