runwork 0.15.0 → 0.15.2

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

@@ -1,296 +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 { formatStartedAgo, getAttachLogPaths, getCurrentPreviewUrl, renderLogLine, resolveAttachTarget, startLogTail, startSessionFileWatch, } from '../attach.js';
-import { buildSessionFile, getSessionPaths, writeSessionFile, } from '../session.js';
-function tmpAppDir() {
-    return fs.mkdtempSync(path.join(os.tmpdir(), 'runwork-attach-test-'));
-}
-function makeSessionFile(overrides = {}) {
-    return buildSessionFile({
-        pid: process.pid,
-        sessionId: 'sess_test',
-        appId: 'test-app',
-        previewUrl: 'https://x.example',
-        cliVersion: '0.10.2',
-        mode: 'detached',
-        deps: { bootTime: () => Date.now() - os.uptime() * 1000 },
-        ...overrides,
-    });
-}
-describe('renderLogLine()', () => {
-    it('passes plain non-JSON stdout text through verbatim', () => {
-        expect(renderLogLine('hello world', 'stdout').text).toBe('hello world');
-        expect(renderLogLine('hello world', 'stdout').level).toBe('info');
-    });
-    it('marks plain stderr text as error level', () => {
-        const out = renderLogLine('boom', 'stderr');
-        expect(out.text).toBe('boom'); // identity colors
-        expect(out.level).toBe('error');
-    });
-    it('renders session_started with the URL', () => {
-        const json = JSON.stringify({ event: 'session_started', previewUrl: 'https://x.example' });
-        expect(renderLogLine(json, 'stdout').text).toContain('Dev session started');
-        expect(renderLogLine(json, 'stdout').text).toContain('https://x.example');
-    });
-    it('renders preview_url_changed with prev and next', () => {
-        const json = JSON.stringify({
-            event: 'preview_url_changed',
-            previewUrl: 'https://new',
-            previousUrl: 'https://old',
-        });
-        const r = renderLogLine(json, 'stdout');
-        expect(r.text).toContain('Preview URL changed');
-        expect(r.text).toContain('https://old');
-        expect(r.text).toContain('https://new');
-        expect(r.level).toBe('warn');
-    });
-    it('renders files_synced with a count + target', () => {
-        const json = JSON.stringify({ event: 'files_synced', count: 3, target: 'preview' });
-        expect(renderLogLine(json, 'stdout').text).toContain('Synced 3 file(s)');
-        expect(renderLogLine(json, 'stdout').text).toContain('preview');
-    });
-    it('renders error with phase + message + diagnosis', () => {
-        const json = JSON.stringify({
-            event: 'error',
-            phase: 'sync',
-            error: { message: 'merge conflict', diagnosis: 'rebase failed' },
-        });
-        const r = renderLogLine(json, 'stderr');
-        expect(r.text).toContain('ERROR (sync)');
-        expect(r.text).toContain('merge conflict');
-        expect(r.text).toContain('rebase failed');
-        expect(r.level).toBe('error');
-    });
-    it('falls through to compact JSON for unknown event types', () => {
-        const json = JSON.stringify({ event: 'something_new', foo: 'bar' });
-        const r = renderLogLine(json, 'stdout');
-        expect(r.text).toContain('something_new');
-        expect(r.text).toContain('bar');
-    });
-    it('does not crash on malformed JSON object lines', () => {
-        expect(() => renderLogLine('{', 'stdout')).not.toThrow();
-        expect(renderLogLine('{', 'stdout').text).toBe('{');
-    });
-    it('returns the empty line through unchanged', () => {
-        const r = renderLogLine('', 'stdout');
-        expect(r.text).toBe('');
-    });
-});
-describe('startLogTail()', () => {
-    let appDir;
-    beforeEach(() => {
-        appDir = tmpAppDir();
-        fs.mkdirSync(path.join(appDir, '.runwork'), { recursive: true });
-    });
-    afterEach(() => {
-        if (fs.existsSync(appDir)) {
-            fs.rmSync(appDir, { recursive: true, force: true });
-        }
-    });
-    it('replays the last N lines from existing logs on start', async () => {
-        const { stdout: stdoutPath } = getAttachLogPaths(appDir);
-        const lines = Array.from({ length: 20 }, (_, i) => `line${i}`).join('\n') + '\n';
-        fs.writeFileSync(stdoutPath, lines, 'utf-8');
-        const seen = [];
-        const tail = startLogTail(stdoutPath, getAttachLogPaths(appDir).stderr, {
-            initialLines: 5,
-            intervalMs: 50,
-            onLine: (line, source) => { seen.push({ line, source }); },
-        });
-        expect(seen).toHaveLength(5);
-        expect(seen.map((s) => s.line)).toEqual(['line15', 'line16', 'line17', 'line18', 'line19']);
-        expect(seen.every((s) => s.source === 'stdout')).toBe(true);
-        tail.stop();
-    });
-    it('picks up appended lines on subsequent ticks', async () => {
-        const { stdout: stdoutPath, stderr: stderrPath } = getAttachLogPaths(appDir);
-        fs.writeFileSync(stdoutPath, '', 'utf-8');
-        const seen = [];
-        const tail = startLogTail(stdoutPath, stderrPath, {
-            initialLines: 50,
-            intervalMs: 25,
-            onLine: (line) => { seen.push(line); },
-        });
-        fs.appendFileSync(stdoutPath, 'first\n', 'utf-8');
-        await new Promise((r) => setTimeout(r, 100));
-        expect(seen).toContain('first');
-        fs.appendFileSync(stdoutPath, 'second\nthird\n', 'utf-8');
-        await new Promise((r) => setTimeout(r, 100));
-        expect(seen).toContain('second');
-        expect(seen).toContain('third');
-        tail.stop();
-    });
-    it('fires onTruncated when the file is shrunk (e.g., new dev session opened it)', async () => {
-        const { stdout: stdoutPath, stderr: stderrPath } = getAttachLogPaths(appDir);
-        fs.writeFileSync(stdoutPath, 'one\ntwo\nthree\n', 'utf-8');
-        const onTruncated = vi.fn();
-        const tail = startLogTail(stdoutPath, stderrPath, {
-            initialLines: 50,
-            intervalMs: 25,
-            onLine: () => { },
-            onTruncated,
-        });
-        // Truncate the file.
-        fs.writeFileSync(stdoutPath, '', 'utf-8');
-        await new Promise((r) => setTimeout(r, 100));
-        expect(onTruncated).toHaveBeenCalled();
-        tail.stop();
-    });
-    it('handles missing stdout/stderr paths without throwing', () => {
-        expect(() => {
-            const tail = startLogTail(path.join(appDir, '.runwork', 'does-not-exist-stdout.log'), path.join(appDir, '.runwork', 'does-not-exist-stderr.log'), {
-                initialLines: 50,
-                intervalMs: 25,
-                onLine: () => { },
-            });
-            tail.stop();
-        }).not.toThrow();
-    });
-    it('stop() prevents further reads', async () => {
-        const { stdout: stdoutPath, stderr: stderrPath } = getAttachLogPaths(appDir);
-        fs.writeFileSync(stdoutPath, '', 'utf-8');
-        const seen = [];
-        const tail = startLogTail(stdoutPath, stderrPath, {
-            initialLines: 50,
-            intervalMs: 25,
-            onLine: (line) => { seen.push(line); },
-        });
-        tail.stop();
-        fs.appendFileSync(stdoutPath, 'after-stop\n', 'utf-8');
-        await new Promise((r) => setTimeout(r, 100));
-        expect(seen).not.toContain('after-stop');
-    });
-});
-describe('startSessionFileWatch()', () => {
-    let appDir;
-    beforeEach(() => {
-        appDir = tmpAppDir();
-    });
-    afterEach(() => {
-        if (fs.existsSync(appDir)) {
-            fs.rmSync(appDir, { recursive: true, force: true });
-        }
-    });
-    it('fires onUrlChanged when previewUrl rotates', async () => {
-        const initial = makeSessionFile({ previewUrl: 'https://old.example' });
-        writeSessionFile(appDir, initial);
-        const onUrlChanged = vi.fn();
-        const watch = startSessionFileWatch(appDir, initial, {
-            expectedAppId: 'test-app',
-            intervalMs: 25,
-            onUrlChanged,
-        });
-        // Mutate the file in place to simulate the URL poller updating it.
-        const updated = { ...initial, previewUrl: 'https://new.example' };
-        writeSessionFile(appDir, updated);
-        await new Promise((r) => setTimeout(r, 100));
-        expect(onUrlChanged).toHaveBeenCalledWith('https://new.example', 'https://old.example');
-        watch.stop();
-    });
-    it('fires onSessionGone when the file is removed', async () => {
-        const initial = makeSessionFile();
-        writeSessionFile(appDir, initial);
-        const onSessionGone = vi.fn();
-        const watch = startSessionFileWatch(appDir, initial, {
-            expectedAppId: 'test-app',
-            intervalMs: 25,
-            onSessionGone,
-        });
-        fs.rmSync(getSessionPaths(appDir).file);
-        await new Promise((r) => setTimeout(r, 100));
-        expect(onSessionGone).toHaveBeenCalled();
-        watch.stop();
-    });
-    it('fires onSessionGone when the PID changes (different session took over)', async () => {
-        const initial = makeSessionFile({ pid: 11111 });
-        writeSessionFile(appDir, initial);
-        const onSessionGone = vi.fn();
-        const onUrlChanged = vi.fn();
-        const watch = startSessionFileWatch(appDir, initial, {
-            expectedAppId: 'test-app',
-            intervalMs: 25,
-            onSessionGone,
-            onUrlChanged,
-        });
-        // A different process wrote a new file (e.g., user did `dev --restart`).
-        writeSessionFile(appDir, makeSessionFile({ pid: 22222 }));
-        await new Promise((r) => setTimeout(r, 100));
-        expect(onSessionGone).toHaveBeenCalled();
-        expect(onUrlChanged).not.toHaveBeenCalled();
-        watch.stop();
-    });
-});
-describe('formatStartedAgo()', () => {
-    const now = 1_700_000_000_000;
-    it('formats sub-minute durations in seconds', () => {
-        expect(formatStartedAgo(now - 5_000, now)).toBe('5s ago');
-        expect(formatStartedAgo(now - 59_000, now)).toBe('59s ago');
-    });
-    it('formats sub-hour durations in minutes', () => {
-        expect(formatStartedAgo(now - 60_000, now)).toBe('1m ago');
-        expect(formatStartedAgo(now - 30 * 60_000, now)).toBe('30m ago');
-    });
-    it('formats longer durations in hours', () => {
-        expect(formatStartedAgo(now - 60 * 60_000, now)).toBe('1h ago');
-        expect(formatStartedAgo(now - 5 * 60 * 60_000, now)).toBe('5h ago');
-    });
-    it('clamps negative deltas to 0', () => {
-        expect(formatStartedAgo(now + 10_000, now)).toBe('0s ago');
-    });
-});
-describe('resolveAttachTarget()', () => {
-    let appDir;
-    beforeEach(() => {
-        appDir = tmpAppDir();
-    });
-    afterEach(() => {
-        if (fs.existsSync(appDir)) {
-            fs.rmSync(appDir, { recursive: true, force: true });
-        }
-    });
-    it('returns "no-session" when no file exists', () => {
-        expect(resolveAttachTarget(appDir, 'test-app')).toEqual({ result: 'no-session' });
-    });
-    it('returns "stale-cleaned" and removes the file when state is stale', () => {
-        // Pid that almost certainly is not running; bootTime check will pass
-        // because process is alive in current test boot, but pid liveness
-        // will fail.
-        writeSessionFile(appDir, makeSessionFile({ pid: 2_147_483_640 }));
-        const out = resolveAttachTarget(appDir, 'test-app');
-        expect(out.result).toBe('stale-cleaned');
-        expect(fs.existsSync(getSessionPaths(appDir).file)).toBe(false);
-    });
-    it('returns "attached" with the file when state is alive', () => {
-        const file = makeSessionFile({ pid: process.pid });
-        writeSessionFile(appDir, file);
-        const out = resolveAttachTarget(appDir, 'test-app');
-        expect(out.result).toBe('attached');
-        if (out.result === 'attached') {
-            expect(out.file.pid).toBe(process.pid);
-        }
-    });
-});
-describe('getCurrentPreviewUrl()', () => {
-    let appDir;
-    beforeEach(() => {
-        appDir = tmpAppDir();
-    });
-    afterEach(() => {
-        if (fs.existsSync(appDir)) {
-            fs.rmSync(appDir, { recursive: true, force: true });
-        }
-    });
-    it('returns the file URL when one exists', () => {
-        writeSessionFile(appDir, makeSessionFile({ previewUrl: 'https://current' }));
-        expect(getCurrentPreviewUrl(appDir, 'https://fallback')).toBe('https://current');
-    });
-    it('returns the fallback when no file exists', () => {
-        expect(getCurrentPreviewUrl(appDir, 'https://fallback')).toBe('https://fallback');
-    });
-    it('returns the fallback when file URL is empty', () => {
-        writeSessionFile(appDir, makeSessionFile({ previewUrl: '' }));
-        expect(getCurrentPreviewUrl(appDir, 'https://fallback')).toBe('https://fallback');
-    });
-});

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

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