runwork 0.10.2 → 0.10.4

package/dist/commands/info.d.ts

@@ -1,4 +1,5 @@
 import { Command } from 'commander';
+import { type SessionMode, type SessionStaleReason } from '../dev/session.js';
 import type { WorkspaceAllData } from '../types.js';
 interface BlueprintEntity {
     entityName: string;
@@ -75,6 +76,30 @@ interface MergedFileStorage {
     enabled: boolean;
     sources: string[];
 }
+/**
+ * Local dev-session view: what the on-disk session file (if any) says
+ * about a session managed by THIS machine. Independent of the server's
+ * preview status, which can disagree (e.g. the server reports the
+ * sandbox is up because someone else's session is running it).
+ */
+interface LocalDevSession {
+    /** No session file present in this app dir. */
+    state: 'none';
+}
+interface LocalDevSessionAlive {
+    state: 'alive';
+    pid: number;
+    sessionId: string;
+    previewUrl: string;
+    mode: SessionMode;
+    startedAt: number;
+}
+interface LocalDevSessionStale {
+    state: 'stale';
+    reason: SessionStaleReason;
+    pid?: number;
+}
+type LocalDevState = LocalDevSession | LocalDevSessionAlive | LocalDevSessionStale;
 interface InfoOutput {
     app: {
         id: string;
@@ -89,6 +114,12 @@ interface InfoOutput {
         url: string | null;
         active: boolean;
     };
+    /**
+     * Local dev session state from `.runwork/dev-session.json`. May
+     * disagree with `preview` if the server reports a sandbox running but
+     * this machine is not the one driving it (or vice versa).
+     */
+    localDevSession: LocalDevState;
     production: {
         url: null;
         deployed: boolean;

package/dist/commands/info.js

@@ -9,6 +9,24 @@ import { VERSION } from '../generated/version.js';
 import { requireAuth } from '../auth/store.js';
 import { ApiClient } from '../api/client.js';
 import { resolveWorkspace } from '../workspace/resolve.js';
+import { getSessionState } from '../dev/session.js';
+function readLocalDevSession(appDir, appId) {
+    if (!appId)
+        return { state: 'none' };
+    const s = getSessionState(appDir, appId);
+    if (s.state === 'none')
+        return { state: 'none' };
+    if (s.state === 'stale')
+        return { state: 'stale', reason: s.reason, pid: s.file?.pid };
+    return {
+        state: 'alive',
+        pid: s.file.pid,
+        sessionId: s.file.sessionId,
+        previewUrl: s.file.previewUrl,
+        mode: s.file.mode,
+        startedAt: s.file.startedAt,
+    };
+}
 function tryReadConfig() {
     if (!existsSync('.runwork.json'))
         return null;
@@ -222,6 +240,23 @@ function printHumanOutput(data) {
             console.log(`  ${dim(pad('Preview:'))}${dim('(not running)')}`);
         }
         console.log(`  ${dim(pad('Production:'))}${dim('(not available)')}`);
+        // Local dev session view: what's running on THIS machine, from the
+        // session file. This may disagree with the server's "preview"
+        // status above; that's diagnostic, not a bug.
+        const local = data.localDevSession;
+        if (local.state === 'alive') {
+            const startedSec = Math.round((Date.now() - local.startedAt) / 1000);
+            const ago = startedSec < 60 ? `${startedSec}s ago`
+                : startedSec < 3600 ? `${Math.floor(startedSec / 60)}m ago`
+                    : `${Math.floor(startedSec / 3600)}h ago`;
+            console.log(`  ${dim(pad('Dev session:'))}${green('running')} ${dim(`(PID ${local.pid}, ${local.mode}, started ${ago})`)}`);
+        }
+        else if (local.state === 'stale') {
+            console.log(`  ${dim(pad('Dev session:'))}${yellow('stale')} ${dim(`(reason: ${local.reason}; run \`runwork dev stop\` to clean up)`)}`);
+        }
+        else {
+            console.log(`  ${dim(pad('Dev session:'))}${dim('(none on this machine)')}`);
+        }
     }
     console.log('');
     // Integrations
@@ -374,6 +409,7 @@ export const infoCommand = new Command('info')
         process.stderr.write('Warning: failed to fetch workspace registries\n');
     }
     const registries = buildRegistries(blueprint, serverData, appId ?? '');
+    const localDevSession = readLocalDevSession(process.cwd(), appId);
     const output = {
         app: appId ? {
             id: appId,
@@ -385,6 +421,7 @@ export const infoCommand = new Command('info')
             name: workspaceName,
         },
         preview,
+        localDevSession,
         production: { url: null, deployed: false },
         integrations,
         registries,

package/dist/commands/init.js

@@ -1,5 +1,5 @@
 import { Command } from 'commander';
-import { execFileSync } from 'child_process';
+import { execFileSync } from '../utils/subprocess.js';
 import { writeFileSync, existsSync, mkdirSync } from 'fs';
 import { join, resolve } from 'path';
 import { homedir } from 'os';

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

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

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

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

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