runwork 0.2.0

package/dist/git/__tests__/credentials.test.js

@@ -0,0 +1,128 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+vi.mock('child_process');
+vi.mock('../../auth/store.js', () => ({
+    getCredentials: vi.fn(),
+}));
+const mockExecFileSync = (await import('child_process')).execFileSync;
+const { getCredentials: mockGetCredentials } = await import('../../auth/store.js');
+const { configureGitCredentials, removeGitCredentials, handleGitCredentialRequest, } = await import('../credentials.js');
+describe('git/credentials', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('configureGitCredentials()', () => {
+        it('calls git config with correct args', async () => {
+            await configureGitCredentials('https://runwork.ai/api/git/ws/app');
+            expect(mockExecFileSync).toHaveBeenCalledWith('git', [
+                'config',
+                '--global',
+                'credential.https://runwork.ai.helper',
+                '!runwork git-credential-helper',
+            ]);
+        });
+        it('extracts origin from full URL', async () => {
+            await configureGitCredentials('https://custom.runwork.dev/api/git/ws-1/app-1');
+            expect(mockExecFileSync).toHaveBeenCalledWith('git', [
+                'config',
+                '--global',
+                'credential.https://custom.runwork.dev.helper',
+                '!runwork git-credential-helper',
+            ]);
+        });
+        it('handles URL with port', async () => {
+            await configureGitCredentials('https://localhost:8787/api/git/ws/app');
+            expect(mockExecFileSync).toHaveBeenCalledWith('git', [
+                'config',
+                '--global',
+                'credential.https://localhost:8787.helper',
+                '!runwork git-credential-helper',
+            ]);
+        });
+    });
+    describe('removeGitCredentials()', () => {
+        it('calls git config --unset', async () => {
+            await removeGitCredentials('https://runwork.ai');
+            expect(mockExecFileSync).toHaveBeenCalledWith('git', [
+                'config',
+                '--global',
+                '--unset',
+                'credential.https://runwork.ai.helper',
+            ]);
+        });
+        it('ignores errors silently', async () => {
+            mockExecFileSync.mockImplementation(() => {
+                throw new Error('config key not found');
+            });
+            // Should not throw
+            await expect(removeGitCredentials('https://runwork.ai')).resolves.toBeUndefined();
+        });
+    });
+    describe('handleGitCredentialRequest()', () => {
+        it('ignores non-get actions (store)', async () => {
+            const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+            await handleGitCredentialRequest('store');
+            expect(writeSpy).not.toHaveBeenCalled();
+            writeSpy.mockRestore();
+        });
+        it('ignores non-get actions (erase)', async () => {
+            const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+            await handleGitCredentialRequest('erase');
+            expect(writeSpy).not.toHaveBeenCalled();
+            writeSpy.mockRestore();
+        });
+        it('exits with code 1 when no credentials stored', async () => {
+            vi.mocked(mockGetCredentials).mockReturnValue(null);
+            // Mock stdin to provide input then end
+            const mockStdin = {
+                setEncoding: vi.fn(),
+                on: vi.fn((event, cb) => {
+                    if (event === 'data')
+                        cb('protocol=https\nhost=runwork.ai\n');
+                    if (event === 'end')
+                        cb();
+                }),
+                readableEnded: false,
+            };
+            const originalStdin = process.stdin;
+            Object.defineProperty(process, 'stdin', { value: mockStdin, writable: true });
+            const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => {
+                throw new Error('process.exit');
+            }));
+            await expect(handleGitCredentialRequest('get')).rejects.toThrow('process.exit');
+            expect(exitSpy).toHaveBeenCalledWith(1);
+            exitSpy.mockRestore();
+            Object.defineProperty(process, 'stdin', { value: originalStdin, writable: true });
+        });
+        it('outputs correct credential format when credentials exist', async () => {
+            vi.mocked(mockGetCredentials).mockReturnValue({
+                apiKey: 'my-api-key',
+                email: 'test@example.com',
+                baseUrl: 'https://runwork.ai',
+            });
+            const mockStdin = {
+                setEncoding: vi.fn(),
+                on: vi.fn((event, cb) => {
+                    if (event === 'data')
+                        cb('protocol=https\nhost=runwork.ai\n');
+                    if (event === 'end')
+                        cb();
+                }),
+                readableEnded: false,
+            };
+            const originalStdin = process.stdin;
+            Object.defineProperty(process, 'stdin', { value: mockStdin, writable: true });
+            const writes = [];
+            const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation((data) => {
+                writes.push(data.toString());
+                return true;
+            });
+            await handleGitCredentialRequest('get');
+            expect(writes).toContain('protocol=https\n');
+            expect(writes).toContain('host=runwork.ai\n');
+            expect(writes).toContain('username=runwork\n');
+            expect(writes).toContain('password=my-api-key\n');
+            writeSpy.mockRestore();
+            Object.defineProperty(process, 'stdin', { value: originalStdin, writable: true });
+        });
+    });
+});

package/dist/git/auto-commit.d.ts

@@ -0,0 +1,3 @@
+import type { ApiClient } from '../api/client.js';
+export declare function watchAndAutoCommit(directory: string, client: ApiClient, appId: string): Promise<void>;
+export declare function stopAutoCommit(): Promise<void>;

package/dist/git/auto-commit.js

@@ -0,0 +1,209 @@
+import { execFileSync } from 'child_process';
+import { readFileSync } from 'fs';
+import { watch } from 'chokidar';
+import { basename, join, relative } from 'path';
+let watcher = null;
+let fastSyncTimer = null;
+let gitTimer = null;
+let gitPushing = false;
+let gitPendingAfterPush = false;
+// Files awaiting fast sync: path -> 'changed' | 'deleted'
+const pendingFastSync = new Map();
+// Track files the user actually touched during this session (for git)
+const changedFiles = new Set();
+const SKIP_DIRS = new Set(['node_modules', '.git', '.runwork']);
+const SKIP_FILES = new Set(['.dev.vars']);
+const SKIP_EXTENSIONS = new Set(['.log']);
+// Binary extensions to skip in fast sync (git handles them fine)
+const BINARY_EXTENSIONS = new Set([
+    '.png', '.jpg', '.jpeg', '.gif', '.ico', '.webp', '.avif', '.svg',
+    '.woff', '.woff2', '.ttf', '.eot', '.otf',
+    '.mp3', '.mp4', '.webm', '.ogg', '.wav',
+    '.zip', '.tar', '.gz', '.br',
+    '.pdf', '.wasm',
+]);
+function isIgnored(filePath) {
+    const name = basename(filePath);
+    if (SKIP_DIRS.has(name))
+        return true;
+    if (SKIP_FILES.has(name))
+        return true;
+    const ext = name.lastIndexOf('.') >= 0 ? name.slice(name.lastIndexOf('.')) : '';
+    if (SKIP_EXTENSIONS.has(ext))
+        return true;
+    return false;
+}
+export async function watchAndAutoCommit(directory, client, appId) {
+    watcher = watch(directory, {
+        ignored: isIgnored,
+        persistent: true,
+        ignoreInitial: true,
+        awaitWriteFinish: {
+            stabilityThreshold: 300,
+            pollInterval: 100,
+        },
+    });
+    const onFileChange = (filePath) => {
+        const rel = relative(directory, filePath);
+        if (changedFiles.size === 0) {
+            console.log(`Changed: ${rel}`);
+        }
+        else {
+            console.log(`Changed: ${rel} (+${changedFiles.size} pending)`);
+        }
+        changedFiles.add(rel);
+        pendingFastSync.set(rel, 'changed');
+        scheduleFastSync(directory, client, appId);
+        scheduleGitCommit();
+    };
+    const onFileUnlink = (filePath) => {
+        const rel = relative(directory, filePath);
+        console.log(`Deleted: ${rel}`);
+        changedFiles.add(rel);
+        pendingFastSync.set(rel, 'deleted');
+        scheduleFastSync(directory, client, appId);
+        scheduleGitCommit();
+    };
+    watcher.on('add', onFileChange);
+    watcher.on('change', onFileChange);
+    watcher.on('unlink', onFileUnlink);
+}
+// ========================================
+// FAST SYNC PATH (200ms debounce)
+// ========================================
+function scheduleFastSync(directory, client, appId) {
+    if (fastSyncTimer)
+        clearTimeout(fastSyncTimer);
+    fastSyncTimer = setTimeout(() => {
+        executeFastSync(directory, client, appId);
+    }, 200);
+}
+async function executeFastSync(directory, client, appId) {
+    if (pendingFastSync.size === 0)
+        return;
+    // Snapshot and clear
+    const snapshot = new Map(pendingFastSync);
+    pendingFastSync.clear();
+    const files = [];
+    const deletedFiles = [];
+    for (const [filePath, action] of snapshot) {
+        if (action === 'deleted') {
+            deletedFiles.push(filePath);
+        }
+        else {
+            // Skip binary files in fast sync — git path handles them
+            const ext = filePath.lastIndexOf('.') >= 0 ? filePath.slice(filePath.lastIndexOf('.')) : '';
+            if (BINARY_EXTENSIONS.has(ext.toLowerCase()))
+                continue;
+            try {
+                const contents = readFileSync(join(directory, filePath), 'utf-8');
+                files.push({ filePath, fileContents: contents });
+            }
+            catch {
+                // File may have been deleted between detection and read
+            }
+        }
+    }
+    if (files.length === 0 && deletedFiles.length === 0)
+        return;
+    const total = files.length + deletedFiles.length;
+    try {
+        await client.syncFiles(appId, files, deletedFiles.length > 0 ? deletedFiles : undefined);
+        console.log(`  Synced ${total} file(s) to preview.`);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.warn(`  Fast sync failed (git will handle it): ${message}`);
+    }
+}
+// ========================================
+// GIT PATH (2s debounce)
+// ========================================
+function scheduleGitCommit() {
+    if (gitPushing) {
+        gitPendingAfterPush = true;
+        return;
+    }
+    if (gitTimer)
+        clearTimeout(gitTimer);
+    gitTimer = setTimeout(() => {
+        commitAndPush();
+    }, 2000);
+}
+function commitAndPush() {
+    try {
+        if (changedFiles.size === 0)
+            return;
+        gitPushing = true;
+        // Stage only files the user actually touched + already-tracked modified files
+        execFileSync('git', ['add', '-u'], { stdio: 'pipe' });
+        // Also stage specific files the user created/modified this session
+        const filesToAdd = Array.from(changedFiles);
+        changedFiles.clear();
+        if (filesToAdd.length > 0) {
+            const BATCH_SIZE = 50;
+            for (let i = 0; i < filesToAdd.length; i += BATCH_SIZE) {
+                const batch = filesToAdd.slice(i, i + BATCH_SIZE);
+                try {
+                    execFileSync('git', ['add', '--', ...batch], { stdio: 'pipe' });
+                }
+                catch {
+                    // Some files may have been deleted between detection and staging
+                }
+            }
+        }
+        // Check if anything was actually staged
+        const staged = execFileSync('git', ['diff', '--cached', '--name-only'], { encoding: 'utf-8' });
+        if (!staged.trim())
+            return;
+        const stagedFiles = staged.trim().split('\n').filter(Boolean);
+        // Commit
+        const timestamp = new Date().toISOString().replace('T', ' ').slice(0, 19);
+        execFileSync('git', ['commit', '-m', `dev: updated ${timestamp}`], { stdio: 'pipe' });
+        // Pull --rebase to integrate any remote changes, then push
+        try {
+            execFileSync('git', ['pull', '--rebase', 'runwork', 'main'], { stdio: 'pipe' });
+        }
+        catch {
+            try {
+                execFileSync('git', ['rebase', '--abort'], { stdio: 'pipe' });
+            }
+            catch { /* no rebase in progress */ }
+            console.warn('Auto-sync: rebase failed, skipping push. Run `git pull --rebase runwork main` manually.');
+            return;
+        }
+        try {
+            execFileSync('git', ['rev-parse', '--abbrev-ref', '@{u}'], { stdio: 'pipe' });
+            execFileSync('git', ['push', 'runwork', 'main'], { stdio: 'pipe' });
+        }
+        catch {
+            execFileSync('git', ['push', '-u', 'runwork', 'main'], { stdio: 'pipe' });
+        }
+        console.log(`  Pushed ${stagedFiles.length} file(s) to git.`);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.warn(`Auto-sync failed: ${message}`);
+    }
+    finally {
+        gitPushing = false;
+        if (gitPendingAfterPush) {
+            gitPendingAfterPush = false;
+            scheduleGitCommit();
+        }
+    }
+}
+export async function stopAutoCommit() {
+    if (fastSyncTimer) {
+        clearTimeout(fastSyncTimer);
+        fastSyncTimer = null;
+    }
+    if (gitTimer) {
+        clearTimeout(gitTimer);
+        gitTimer = null;
+    }
+    if (watcher) {
+        await watcher.close();
+        watcher = null;
+    }
+}

package/dist/git/credentials.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Configure git to use the runwork credential helper for our remote.
+ * Called by `runwork login` and `runwork init`.
+ */
+export declare function configureGitCredentials(remoteUrl: string): Promise<void>;
+/**
+ * Remove the git credential helper configuration for our remote.
+ */
+export declare function removeGitCredentials(baseUrl: string): Promise<void>;
+/**
+ * Git credential helper protocol handler.
+ * Git calls: runwork git-credential-helper get
+ * We read stdin for host/protocol, write username/password to stdout.
+ */
+export declare function handleGitCredentialRequest(action: string): Promise<void>;

package/dist/git/credentials.js

@@ -0,0 +1,65 @@
+import { execFileSync } from 'child_process';
+import { getCredentials } from '../auth/store.js';
+/**
+ * Configure git to use the runwork credential helper for our remote.
+ * Called by `runwork login` and `runwork init`.
+ */
+export async function configureGitCredentials(remoteUrl) {
+    const origin = new URL(remoteUrl).origin;
+    execFileSync('git', [
+        'config', '--global',
+        `credential.${origin}.helper`,
+        '!runwork git-credential-helper',
+    ]);
+}
+/**
+ * Remove the git credential helper configuration for our remote.
+ */
+export async function removeGitCredentials(baseUrl) {
+    const origin = new URL(baseUrl).origin;
+    try {
+        execFileSync('git', [
+            'config', '--global', '--unset',
+            `credential.${origin}.helper`,
+        ]);
+    }
+    catch {
+        // Ignore errors if the config key doesn't exist
+    }
+}
+/**
+ * Git credential helper protocol handler.
+ * Git calls: runwork git-credential-helper get
+ * We read stdin for host/protocol, write username/password to stdout.
+ */
+export async function handleGitCredentialRequest(action) {
+    if (action !== 'get') {
+        return; // Only 'get' needs handling. 'store' and 'erase' are no-ops.
+    }
+    const input = await readStdin();
+    const lines = input.trim().split('\n');
+    const params = {};
+    for (const line of lines) {
+        const [key, value] = line.split('=', 2);
+        if (key && value)
+            params[key] = value;
+    }
+    const creds = getCredentials();
+    if (!creds) {
+        process.exit(1);
+    }
+    process.stdout.write(`protocol=${params.protocol || 'https'}\n`);
+    process.stdout.write(`host=${params.host}\n`);
+    process.stdout.write(`username=runwork\n`);
+    process.stdout.write(`password=${creds.apiKey}\n`);
+}
+function readStdin() {
+    return new Promise((resolve) => {
+        let data = '';
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('data', (chunk) => { data += chunk; });
+        process.stdin.on('end', () => resolve(data));
+        if (process.stdin.readableEnded)
+            resolve(data);
+    });
+}

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,31 @@
+import { Command } from 'commander';
+import { loginCommand } from './commands/login.js';
+import { initCommand } from './commands/init.js';
+import { cloneCommand } from './commands/clone.js';
+import { devCommand } from './commands/dev.js';
+import { deployCommand } from './commands/deploy.js';
+import { logsCommand } from './commands/logs.js';
+import { logoutCommand } from './commands/logout.js';
+import { handleGitCredentialRequest } from './git/credentials.js';
+import { VERSION } from './generated/version.js';
+const program = new Command();
+program
+    .name('runwork')
+    .description('Runwork CLI - local development for Runwork apps')
+    .version(VERSION);
+program.addCommand(loginCommand);
+program.addCommand(initCommand);
+program.addCommand(cloneCommand);
+program.addCommand(devCommand);
+program.addCommand(deployCommand);
+program.addCommand(logsCommand);
+program.addCommand(logoutCommand);
+const credentialHelper = program
+    .command('git-credential-helper', { hidden: true })
+    .argument('<action>', 'Credential action (get/store/erase)')
+    .description('Git credential helper (called by git, not directly)')
+    .action(async (action) => {
+    await handleGitCredentialRequest(action);
+});
+credentialHelper.helpOption(false);
+program.parse();

package/dist/logs/tailer.d.ts

@@ -0,0 +1,13 @@
+import type { ApiClient } from '../api/client.js';
+interface TailerOptions {
+    appId: string;
+    client: ApiClient;
+    projectDir: string;
+    toTerminal: boolean;
+    toFile: boolean;
+    intervalMs?: number;
+}
+export declare function startLogTailer(options: TailerOptions): {
+    stop: () => void;
+};
+export {};

package/dist/logs/tailer.js

@@ -0,0 +1,135 @@
+import { appendFileSync, mkdirSync, writeFileSync } from 'fs';
+import { join, dirname } from 'path';
+const LOG_FILE = '.runwork/logs.txt';
+function formatTime() {
+    const now = new Date();
+    return [
+        String(now.getHours()).padStart(2, '0'),
+        String(now.getMinutes()).padStart(2, '0'),
+        String(now.getSeconds()).padStart(2, '0'),
+    ].join(':');
+}
+function formatLogLine(tag, line) {
+    return `[${formatTime()}] [${tag}] ${line}`;
+}
+export function startLogTailer(options) {
+    const { appId, client, projectDir, toTerminal, toFile, intervalMs = 5000, } = options;
+    const logFilePath = join(projectDir, LOG_FILE);
+    // Ensure .runwork/ directory exists and truncate log file with header
+    if (toFile) {
+        mkdirSync(dirname(logFilePath), { recursive: true });
+        writeFileSync(logFilePath, `# Runwork dev logs - started ${new Date().toISOString()}\n\n`, 'utf-8');
+    }
+    let lastStdoutLength = 0;
+    let lastStderrLength = 0;
+    let lastEventTimestamp;
+    let seenEventIds = new Set();
+    let stopped = false;
+    let timer;
+    function writeLine(line) {
+        if (toTerminal) {
+            console.log(line);
+        }
+        if (toFile) {
+            try {
+                appendFileSync(logFilePath, line + '\n', 'utf-8');
+            }
+            catch {
+                // Silently ignore file write errors
+            }
+        }
+    }
+    async function poll() {
+        if (stopped)
+            return;
+        try {
+            // Poll preview logs (stdout/stderr)
+            const logs = await client.getPreviewLogs(appId);
+            // Reset detection: if buffer shrank (sandbox restart), reset cursor
+            if (logs.stdout && logs.stdout.length < lastStdoutLength) {
+                lastStdoutLength = 0;
+            }
+            if (logs.stderr && logs.stderr.length < lastStderrLength) {
+                lastStderrLength = 0;
+            }
+            if (logs.stdout && logs.stdout.length > lastStdoutLength) {
+                const newContent = logs.stdout.slice(lastStdoutLength);
+                const lines = newContent.split('\n').filter(Boolean);
+                for (const line of lines) {
+                    writeLine(formatLogLine('RUNTIME', line));
+                }
+                lastStdoutLength = logs.stdout.length;
+            }
+            if (logs.stderr && logs.stderr.length > lastStderrLength) {
+                const newContent = logs.stderr.slice(lastStderrLength);
+                const lines = newContent.split('\n').filter(Boolean);
+                for (const line of lines) {
+                    writeLine(formatLogLine('ERROR', line));
+                }
+                lastStderrLength = logs.stderr.length;
+            }
+        }
+        catch {
+            // Silently ignore - sandbox may not be ready yet
+        }
+        try {
+            // Poll app events
+            const eventOptions = { limit: 20 };
+            // We don't use `before` for pagination here; instead we filter by timestamp
+            const result = await client.getAppEvents(appId, eventOptions);
+            if (result.events && result.events.length > 0) {
+                // Events are returned newest-first; process in chronological order
+                const sorted = [...result.events].sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+                for (const event of sorted) {
+                    // Skip events we've already seen (by ID, or by timestamp for older events)
+                    if (seenEventIds.has(event.id)) {
+                        continue;
+                    }
+                    if (lastEventTimestamp && event.timestamp < lastEventTimestamp) {
+                        continue;
+                    }
+                    let detail = event.summary || event.content || event.type;
+                    // Include structured metadata when available
+                    if (event.metadata) {
+                        const meta = event.metadata;
+                        if (meta.statusCode) {
+                            detail += ` (status: ${meta.statusCode})`;
+                        }
+                        if (meta.error) {
+                            detail += ` - ${meta.error}`;
+                        }
+                        if (meta.path) {
+                            detail += ` [${meta.path}]`;
+                        }
+                    }
+                    writeLine(formatLogLine('EVENT', `${event.type}: ${detail}`));
+                    seenEventIds.add(event.id);
+                }
+                // Update cursor to the latest event timestamp and prune old IDs
+                const latest = sorted[sorted.length - 1];
+                if (latest && (!lastEventTimestamp || latest.timestamp > lastEventTimestamp)) {
+                    // Clear IDs from previous timestamps since we won't see them again
+                    seenEventIds = new Set(sorted.filter(e => e.timestamp === latest.timestamp).map(e => e.id));
+                    lastEventTimestamp = latest.timestamp;
+                }
+            }
+        }
+        catch {
+            // Silently ignore - events endpoint may not be available
+        }
+        if (!stopped) {
+            timer = setTimeout(poll, intervalMs);
+        }
+    }
+    // Initial poll after a short delay to let sandbox start
+    timer = setTimeout(poll, 2000);
+    return {
+        stop() {
+            stopped = true;
+            if (timer) {
+                clearTimeout(timer);
+                timer = undefined;
+            }
+        },
+    };
+}

package/dist/template/manifest.d.ts

@@ -0,0 +1,17 @@
+export interface TemplateManifest {
+    version: 1;
+    files: Record<string, string>;
+}
+export declare function generateManifest(dir: string): Promise<TemplateManifest>;
+export declare function saveManifest(dir: string, manifest: TemplateManifest): Promise<void>;
+export declare function loadManifest(dir: string): Promise<TemplateManifest | null>;
+/**
+ * Detect files the user edited outside of `runwork dev`.
+ *
+ * Two sources of edits:
+ * 1. Git-tracked files with uncommitted changes (git diff + git diff --cached)
+ * 2. Untracked files that aren't in the template manifest (user-created files)
+ *
+ * Already-committed files are NOT flagged -- git already knows about them.
+ */
+export declare function detectUserEdits(dir: string, manifest: TemplateManifest): Promise<string[]>;