runwork 0.15.0 → 0.15.2

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

@@ -1,404 +0,0 @@
-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 { buildChildArgs, pollForSession, runAsDetachedParent, isInternalDetachedChild, looksLikeBunStandaloneArtifact, 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('looksLikeBunStandaloneArtifact()', () => {
-    it('detects Bun-on-Windows virtual-FS paths (forward slashes)', () => {
-        expect(looksLikeBunStandaloneArtifact('B:/~BUN/root/runwork-windows-x64.exe')).toBe(true);
-        expect(looksLikeBunStandaloneArtifact('C:/~BUN/root/foo.exe')).toBe(true);
-    });
-    it('detects Bun-on-Windows virtual-FS paths (backslashes)', () => {
-        expect(looksLikeBunStandaloneArtifact('B:\\~BUN\\root\\runwork.exe')).toBe(true);
-    });
-    it('detects bunfs prefix on POSIX (defensive)', () => {
-        expect(looksLikeBunStandaloneArtifact('/$bunfs/root/runwork')).toBe(true);
-    });
-    it('does not flag normal paths or arguments', () => {
-        expect(looksLikeBunStandaloneArtifact('dev')).toBe(false);
-        expect(looksLikeBunStandaloneArtifact('--detach')).toBe(false);
-        expect(looksLikeBunStandaloneArtifact('/usr/local/bin/runwork')).toBe(false);
-        expect(looksLikeBunStandaloneArtifact('C:/Users/Oytun/.runwork/bin/runwork.exe')).toBe(false);
-        expect(looksLikeBunStandaloneArtifact('node')).toBe(false);
-    });
-});
-describe('buildChildArgs()', () => {
-    it('Node script invocation: forwards script path + user args, appends marker', () => {
-        // node /path/to/dist/index.js dev --detach
-        const argv = ['node', '/path/to/dist/index.js', 'dev', '--detach'];
-        expect(buildChildArgs(argv)).toEqual([
-            '/path/to/dist/index.js', 'dev', '--detach', INTERNAL_DETACHED_CHILD_FLAG,
-        ]);
-    });
-    it('Bun standalone macOS/Linux: forwards user args directly', () => {
-        // /usr/local/bin/runwork dev --detach
-        const argv = ['/usr/local/bin/runwork', 'dev', '--detach'];
-        expect(buildChildArgs(argv)).toEqual([
-            'dev', '--detach', INTERNAL_DETACHED_CHILD_FLAG,
-        ]);
-    });
-    it('Bun standalone Windows: drops the virtual-FS argv[1] before forwarding', () => {
-        // The exact failure from the field. Bun-on-Windows injects argv[1]
-        // = "B:/~BUN/root/runwork-windows-x64.exe". We must NOT forward it
-        // -- the child Bun runtime will inject its own.
-        const argv = [
-            'C:\\Users\\Oytun\\.runwork\\bin\\runwork.exe',
-            'B:/~BUN/root/runwork-windows-x64.exe',
-            'dev',
-            '--detach',
-        ];
-        expect(buildChildArgs(argv)).toEqual([
-            'dev', '--detach', INTERNAL_DETACHED_CHILD_FLAG,
-        ]);
-    });
-    it('strips an existing internal-child flag and re-adds exactly one', () => {
-        const argv = [
-            '/usr/local/bin/runwork',
-            'dev',
-            '--detach',
-            INTERNAL_DETACHED_CHILD_FLAG,
-            INTERNAL_DETACHED_CHILD_FLAG,
-        ];
-        const out = buildChildArgs(argv);
-        expect(out.filter((a) => a === INTERNAL_DETACHED_CHILD_FLAG)).toHaveLength(1);
-    });
-    it('preserves the order of user args and only mutates argv[0..1]', () => {
-        const argv = [
-            'C:\\bin\\runwork.exe',
-            'B:/~BUN/root/runwork-windows-x64.exe',
-            'dev',
-            '--restart',
-            '--detach',
-            '--json',
-        ];
-        expect(buildChildArgs(argv)).toEqual([
-            'dev', '--restart', '--detach', '--json', INTERNAL_DETACHED_CHILD_FLAG,
-        ]);
-    });
-    it('handles an empty argv tail (just the binary)', () => {
-        expect(buildChildArgs(['runwork'])).toEqual([INTERNAL_DETACHED_CHILD_FLAG]);
-    });
-});
-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

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

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

@@ -1,149 +0,0 @@
-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

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