runwork 0.2.0

package/dist/auth/browser.js

@@ -0,0 +1,7 @@
+export async function openBrowserForAuth(_authUrl) {
+    // TODO: implement browser-based auth flow
+}
+export async function startAuthCallbackServer(_port) {
+    // TODO: implement local callback server for OAuth
+    return '';
+}

package/dist/auth/store.d.ts

@@ -0,0 +1,5 @@
+import type { Credentials } from '../types.js';
+export declare function getCredentials(): Credentials | null;
+export declare function saveCredentials(credentials: Credentials): void;
+export declare function clearCredentials(): void;
+export declare function requireAuth(): Credentials;

package/dist/auth/store.js

@@ -0,0 +1,33 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync, unlinkSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+const RUNWORK_DIR = join(homedir(), '.runwork');
+const CREDENTIALS_FILE = join(RUNWORK_DIR, '.credentials');
+export function getCredentials() {
+    if (!existsSync(CREDENTIALS_FILE))
+        return null;
+    try {
+        const raw = readFileSync(CREDENTIALS_FILE, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+export function saveCredentials(credentials) {
+    mkdirSync(RUNWORK_DIR, { recursive: true });
+    writeFileSync(CREDENTIALS_FILE, JSON.stringify(credentials, null, 2), { mode: 0o600 });
+}
+export function clearCredentials() {
+    if (existsSync(CREDENTIALS_FILE)) {
+        unlinkSync(CREDENTIALS_FILE);
+    }
+}
+export function requireAuth() {
+    const creds = getCredentials();
+    if (!creds) {
+        console.error('Not logged in. Run `runwork login` first.');
+        process.exit(1);
+    }
+    return creds;
+}

package/dist/commands/clone.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const cloneCommand: Command;

package/dist/commands/clone.js

@@ -0,0 +1,90 @@
+import { Command } from 'commander';
+import { execFileSync } from 'child_process';
+import { writeFileSync, mkdirSync, existsSync } from 'fs';
+import { join } from 'path';
+import { requireAuth } from '../auth/store.js';
+import { ApiClient } from '../api/client.js';
+import { promptSelect } from '../utils/prompt.js';
+import { generateManifest, saveManifest } from '../template/manifest.js';
+import { extractZip } from '../utils/zip.js';
+import { removeNestedGitDirs } from '../utils/fs.js';
+export const cloneCommand = new Command('clone')
+    .description('Clone a Runwork app to local development')
+    .argument('[appId]', 'App ID to clone (interactive if omitted)')
+    .argument('[directory]', 'Target directory')
+    .action(async (appId, directory) => {
+    const creds = requireAuth();
+    const client = new ApiClient(creds);
+    let app;
+    if (appId) {
+        app = await client.getApp(appId);
+    }
+    else {
+        const apps = await client.listApps();
+        if (apps.length === 0) {
+            console.error('No apps found.');
+            process.exit(1);
+        }
+        const choice = await promptSelect('Select app to clone:', apps.map(a => ({ label: `${a.name} (${a.workspaceName})`, value: a })));
+        app = choice.value;
+    }
+    const slug = app.slug || app.name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+    const dir = directory || slug;
+    const remoteUrl = client.getGitRemoteUrl(app.workspaceId, app.id);
+    console.log(`Cloning "${app.name}"...`);
+    // Step 1: Extract skeleton template as the base layer
+    console.log('Downloading project template...');
+    mkdirSync(dir, { recursive: true });
+    try {
+        const zipData = await client.downloadSkeleton();
+        extractZip(zipData, dir);
+        removeNestedGitDirs(dir);
+    }
+    catch {
+        console.warn('Failed to download template. Cloning git-tracked files only.');
+    }
+    // Generate template manifest BEFORE git overlay (captures pristine template checksums)
+    const manifest = await generateManifest(dir);
+    await saveManifest(dir, manifest);
+    // Step 2: Git clone into the directory (overlays changed files on top of template)
+    // Init git, add remote, fetch, and checkout to overlay on existing template files
+    if (!existsSync(join(dir, '.git'))) {
+        execFileSync('git', ['init'], { cwd: dir, stdio: 'pipe' });
+    }
+    try {
+        execFileSync('git', ['remote', 'set-url', 'runwork', remoteUrl], { cwd: dir, stdio: 'pipe' });
+    }
+    catch {
+        execFileSync('git', ['remote', 'add', 'runwork', remoteUrl], { cwd: dir, stdio: 'pipe' });
+    }
+    try {
+        execFileSync('git', ['fetch', 'runwork', 'main'], { cwd: dir, stdio: 'inherit' });
+        // Reset to remote HEAD - overlays git-tracked files on top of template
+        execFileSync('git', ['reset', '--mixed', 'runwork/main'], { cwd: dir, stdio: 'pipe' });
+        // Checkout git-tracked files (overwrites template files where they differ)
+        execFileSync('git', ['checkout', '.'], { cwd: dir, stdio: 'pipe' });
+    }
+    catch {
+        console.warn('No remote commits yet. Starting with template only.');
+    }
+    // Write .runwork.json config
+    const config = {
+        workspaceId: app.workspaceId,
+        appId: app.id,
+        appName: app.name,
+    };
+    writeFileSync(join(dir, '.runwork.json'), JSON.stringify(config, null, 2));
+    // Fetch SKILL.md (best-effort)
+    try {
+        const { skill } = await client.getAppSkill(app.id);
+        if (skill) {
+            writeFileSync(join(dir, 'SKILL.md'), skill, 'utf-8');
+        }
+    }
+    catch {
+        // App may be new with no registries yet
+    }
+    console.log(`\nApp "${app.name}" cloned to ${dir}/`);
+    console.log(`Remote: ${remoteUrl}`);
+    console.log(`\nNext: cd ${dir} && runwork dev`);
+});

package/dist/commands/deploy.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const deployCommand: Command;

package/dist/commands/deploy.js

@@ -0,0 +1,43 @@
+import { Command } from 'commander';
+import { execFileSync } from 'child_process';
+import { readFileSync, existsSync } from 'fs';
+import { requireAuth } from '../auth/store.js';
+import { ApiClient } from '../api/client.js';
+export const deployCommand = new Command('deploy')
+    .description('Deploy the current app to Runwork')
+    .action(async () => {
+    if (!existsSync('.runwork.json')) {
+        console.error('No .runwork.json found. Run `runwork init` first.');
+        process.exit(1);
+    }
+    const config = JSON.parse(readFileSync('.runwork.json', 'utf-8'));
+    const creds = requireAuth();
+    const client = new ApiClient(creds);
+    // Sync: pull + push (skip if no commits yet)
+    let repoHasCommits = false;
+    try {
+        execFileSync('git', ['rev-parse', 'HEAD'], { stdio: 'pipe' });
+        repoHasCommits = true;
+    }
+    catch {
+        // No commits yet
+    }
+    if (repoHasCommits) {
+        console.log('Syncing...');
+        try {
+            execFileSync('git', ['pull', '--rebase', 'runwork', 'main'], { stdio: 'inherit' });
+        }
+        catch {
+            console.warn('Pull failed. Continuing...');
+        }
+        execFileSync('git', ['push', 'runwork', 'main'], { stdio: 'inherit' });
+    }
+    else {
+        console.error('No commits to deploy. Commit your changes first.');
+        process.exit(1);
+    }
+    // Trigger deploy
+    console.log('Deploying...');
+    const result = await client.triggerDeploy(config.appId);
+    console.log(`Deployed: ${result.deploymentUrl}`);
+});

package/dist/commands/dev.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const devCommand: Command;

package/dist/commands/dev.js

@@ -0,0 +1,188 @@
+import { Command } from 'commander';
+import { execFileSync } from 'child_process';
+import { readFileSync, writeFileSync, existsSync, unlinkSync } from 'fs';
+import { join } from 'path';
+import { requireAuth } from '../auth/store.js';
+import { ApiClient } from '../api/client.js';
+import { watchAndAutoCommit, stopAutoCommit } from '../git/auto-commit.js';
+import { startLogTailer } from '../logs/tailer.js';
+import { populateTypes } from '../types-manager.js';
+import { loadManifest, generateManifest, saveManifest, detectUserEdits } from '../template/manifest.js';
+import { extractZip } from '../utils/zip.js';
+import { removeNestedGitDirs } from '../utils/fs.js';
+async function populateSkill(projectDir, client, appId) {
+    try {
+        const { skill } = await client.getAppSkill(appId);
+        if (skill) {
+            writeFileSync(join(projectDir, 'SKILL.md'), skill, 'utf-8');
+        }
+    }
+    catch {
+        // Best-effort: app may be new with no registries yet
+    }
+}
+function readConfig() {
+    if (!existsSync('.runwork.json')) {
+        console.error('No .runwork.json found. Run `runwork init` first.');
+        process.exit(1);
+    }
+    return JSON.parse(readFileSync('.runwork.json', 'utf-8'));
+}
+function hasCommits() {
+    try {
+        execFileSync('git', ['rev-parse', 'HEAD'], { stdio: 'pipe' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function hasTrackedChanges() {
+    try {
+        // Only check tracked files (modified/deleted/staged) - not untracked (??) files
+        const output = execFileSync('git', ['status', '--porcelain'], { encoding: 'utf-8' });
+        return output.trim().split('\n').some(line => line.length > 0 && !line.startsWith('??'));
+    }
+    catch {
+        return false;
+    }
+}
+export const devCommand = new Command('dev')
+    .description('Start local development server with live sync')
+    .option('--no-logs', 'Disable automatic log tailing')
+    .option('--logs-only-file', 'Write logs to file only, not terminal')
+    .action(async (options) => {
+    const config = readConfig();
+    const creds = requireAuth();
+    const client = new ApiClient(creds);
+    const cwd = process.cwd();
+    // Detect user edits made outside of `runwork dev`
+    const oldManifest = await loadManifest(cwd);
+    if (oldManifest) {
+        const userEdits = await detectUserEdits(cwd, oldManifest);
+        if (userEdits.length > 0) {
+            console.log(`Detected ${userEdits.length} file(s) edited outside dev session:`);
+            for (const file of userEdits) {
+                console.log(`  ${file}`);
+            }
+            try {
+                execFileSync('git', ['add', '--', ...userEdits], { stdio: 'pipe' });
+                execFileSync('git', ['commit', '-m', 'sync: user edits'], { stdio: 'pipe' });
+            }
+            catch {
+                // Nothing to commit or git not initialized yet
+            }
+        }
+    }
+    // Download fresh template to ensure latest version
+    console.log('Updating template...');
+    try {
+        const zipData = await client.downloadSkeleton();
+        extractZip(zipData, cwd);
+        removeNestedGitDirs(cwd);
+        // Generate new manifest from fresh template (before restoring user files)
+        const newManifest = await generateManifest(cwd);
+        await saveManifest(cwd, newManifest);
+        // Restore user-edited files from git on top of fresh template
+        try {
+            execFileSync('git', ['checkout', '--', '.'], { cwd, stdio: 'pipe' });
+        }
+        catch {
+            // May fail if no commits yet
+        }
+    }
+    catch {
+        console.warn('Template update failed. Continuing with current files.');
+    }
+    // Populate type definitions
+    await populateTypes(cwd);
+    // Start dev session first - this triggers DO onStart which may create remote commits
+    console.log('Starting dev session...');
+    const session = await client.startDevSession(config.appId);
+    console.log(`Preview: ${session.previewUrl}`);
+    // Fetch SKILL.md (best-effort, after session so DO registries are available)
+    await populateSkill(cwd, client, config.appId);
+    // Sync AFTER starting session so we pick up any commits the DO created
+    if (hasCommits()) {
+        console.log('Syncing with Runwork...');
+        const dirty = hasTrackedChanges();
+        if (dirty) {
+            execFileSync('git', ['stash', 'push', '-m', 'runwork-dev-sync'], { stdio: 'inherit' });
+        }
+        try {
+            // Fetch first, then remove untracked skeleton files that conflict
+            // with the remote before rebasing. Skeleton files are ephemeral
+            // (re-downloaded each session) so the server's versions take precedence.
+            // User-edited files are already tracked/committed at this point.
+            execFileSync('git', ['fetch', 'runwork', 'main'], { stdio: 'inherit' });
+            try {
+                const remoteFiles = execFileSync('git', ['ls-tree', '-r', '--name-only', 'runwork/main'], { encoding: 'utf-8' }).trim().split('\n');
+                const untrackedOutput = execFileSync('git', ['ls-files', '--others', '--exclude-standard'], { encoding: 'utf-8' }).trim();
+                const untracked = new Set(untrackedOutput.split('\n').filter(Boolean));
+                for (const file of remoteFiles) {
+                    if (untracked.has(file)) {
+                        try {
+                            unlinkSync(join(cwd, file));
+                        }
+                        catch { /* already gone */ }
+                    }
+                }
+            }
+            catch { /* best effort */ }
+            execFileSync('git', ['rebase', 'runwork/main'], { stdio: 'inherit' });
+        }
+        catch {
+            try {
+                execFileSync('git', ['rebase', '--abort'], { stdio: 'pipe' });
+            }
+            catch { /* no rebase in progress */ }
+            console.warn('Pull failed (remote may not have commits yet). Continuing...');
+        }
+        if (dirty) {
+            try {
+                execFileSync('git', ['stash', 'pop'], { stdio: 'inherit' });
+            }
+            catch {
+                console.error('Merge conflicts detected after stash pop. Resolve conflicts and restart.');
+                process.exit(1);
+            }
+        }
+        // Push local changes
+        try {
+            execFileSync('git', ['push', 'runwork', 'main'], { stdio: 'inherit' });
+        }
+        catch {
+            console.warn('Push failed. Continuing with current state...');
+        }
+    }
+    else {
+        console.log('No commits yet. Skipping sync.');
+    }
+    // Declare logTailer before cleanup so cleanup can reference it
+    let logTailer;
+    // Register cleanup before starting watcher to avoid race
+    const cleanup = async () => {
+        console.log('\nStopping...');
+        logTailer?.stop();
+        await stopAutoCommit();
+        process.exit(0);
+    };
+    process.on('SIGINT', cleanup);
+    process.on('SIGTERM', cleanup);
+    // Start file watcher
+    console.log('Watching for file changes...');
+    await watchAndAutoCommit(process.cwd(), client, config.appId);
+    // Start log tailing (unless --no-logs)
+    if (options.logs !== false) {
+        logTailer = startLogTailer({
+            appId: config.appId,
+            client,
+            projectDir: cwd,
+            toTerminal: !options.logsOnlyFile,
+            toFile: true,
+        });
+        console.log('Log tailing active. Logs written to .runwork/logs.txt');
+    }
+    // Keep alive
+    await new Promise(() => { });
+});

package/dist/commands/init.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const initCommand: Command;

package/dist/commands/init.js

@@ -0,0 +1,87 @@
+import { Command } from 'commander';
+import { execFileSync } from 'child_process';
+import { writeFileSync, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { requireAuth } from '../auth/store.js';
+import { ApiClient } from '../api/client.js';
+import { promptSelect, promptInput } from '../utils/prompt.js';
+import { generateManifest, saveManifest } from '../template/manifest.js';
+import { extractZip } from '../utils/zip.js';
+import { removeNestedGitDirs } from '../utils/fs.js';
+export const initCommand = new Command('init')
+    .description('Initialize a new Runwork app')
+    .argument('[name]', 'App name')
+    .action(async (name) => {
+    const creds = requireAuth();
+    const client = new ApiClient(creds);
+    const appName = name || await promptInput('App name');
+    if (!appName) {
+        console.error('App name is required.');
+        process.exit(1);
+    }
+    const workspaces = await client.listWorkspaces();
+    if (workspaces.length === 0) {
+        console.error('No workspaces found. Create one at runwork.ai first.');
+        process.exit(1);
+    }
+    const workspaceChoice = await promptSelect('Select workspace:', workspaces.map(w => ({ label: w.name, value: w })));
+    const workspace = workspaceChoice.value;
+    console.log(`Initializing "${appName}" in workspace "${workspace.name}"...`);
+    const app = await client.initApp(workspace.id, appName);
+    const slug = app.slug || appName.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+    const dir = slug;
+    if (existsSync(dir)) {
+        console.error(`Directory "${dir}" already exists.`);
+        process.exit(1);
+    }
+    mkdirSync(dir, { recursive: true });
+    // Download and extract skeleton template first
+    console.log('Downloading project template...');
+    try {
+        const zipData = await client.downloadSkeleton();
+        extractZip(zipData, dir);
+        removeNestedGitDirs(dir);
+        console.log('Project template extracted.');
+        // Generate template manifest for tracking user edits
+        const manifest = await generateManifest(dir);
+        await saveManifest(dir, manifest);
+    }
+    catch {
+        console.warn('Failed to download skeleton template. Starting with empty project.');
+    }
+    // Write .runwork.json AFTER template extraction so it doesn't get overwritten
+    const config = {
+        workspaceId: workspace.id,
+        appId: app.id,
+        appName: app.name,
+    };
+    writeFileSync(join(dir, '.runwork.json'), JSON.stringify(config, null, 2));
+    // Initialize git
+    if (!existsSync(join(dir, '.git'))) {
+        execFileSync('git', ['init'], { cwd: dir, stdio: 'inherit' });
+    }
+    // Add runwork remote
+    const remoteUrl = client.getGitRemoteUrl(workspace.id, app.id);
+    try {
+        execFileSync('git', ['remote', 'add', 'runwork', remoteUrl], { cwd: dir, stdio: 'pipe' });
+    }
+    catch {
+        execFileSync('git', ['remote', 'set-url', 'runwork', remoteUrl], { cwd: dir, stdio: 'pipe' });
+    }
+    // Create .gitignore if needed
+    if (!existsSync(join(dir, '.gitignore'))) {
+        writeFileSync(join(dir, '.gitignore'), 'node_modules/\n.runwork/\n.dev.vars\n');
+    }
+    // Initial commit: only track .runwork.json and .gitignore (not template files)
+    execFileSync('git', ['add', '--', '.runwork.json', '.gitignore'], { cwd: dir, stdio: 'pipe' });
+    try {
+        execFileSync('git', ['commit', '-m', 'Initialize app'], { cwd: dir, stdio: 'pipe' });
+    }
+    catch {
+        // Nothing to commit is fine
+    }
+    execFileSync('git', ['push', '-u', 'runwork', 'main'], { cwd: dir, stdio: 'inherit' });
+    console.log(`\nApp "${app.name}" initialized in ${dir}/`);
+    console.log(`Remote: ${remoteUrl}`);
+    console.log(`\nNext: cd ${dir} && runwork dev`);
+});

package/dist/commands/login.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const loginCommand: Command;

package/dist/commands/login.js

@@ -0,0 +1,32 @@
+import { Command } from 'commander';
+import { ApiClient } from '../api/client.js';
+import { saveCredentials } from '../auth/store.js';
+import { configureGitCredentials } from '../git/credentials.js';
+export const loginCommand = new Command('login')
+    .description('Authenticate with Runwork platform')
+    .option('--base-url <url>', 'Platform URL', 'https://runwork.ai')
+    .action(async (options) => {
+    const client = new ApiClient({ apiKey: '', email: '', baseUrl: options.baseUrl });
+    console.log('Opening browser for authentication...');
+    const { sessionId, loginUrl } = await client.initiateLogin();
+    // Open browser
+    const open = await import('open');
+    await open.default(loginUrl);
+    console.log(`If browser didn't open, visit: ${loginUrl}`);
+    console.log('Waiting for authentication...');
+    // Poll for up to 5 minutes
+    const maxAttempts = 60;
+    const pollInterval = 5000;
+    for (let i = 0; i < maxAttempts; i++) {
+        await new Promise(resolve => setTimeout(resolve, pollInterval));
+        const result = await client.pollLogin(sessionId);
+        if (result) {
+            saveCredentials(result);
+            await configureGitCredentials(result.baseUrl || options.baseUrl);
+            console.log(`Logged in as ${result.email}`);
+            return;
+        }
+    }
+    console.error('Login timed out. Please try again.');
+    process.exit(1);
+});

package/dist/commands/logout.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const logoutCommand: Command;

package/dist/commands/logout.js

@@ -0,0 +1,13 @@
+import { Command } from 'commander';
+import { clearCredentials, getCredentials } from '../auth/store.js';
+import { removeGitCredentials } from '../git/credentials.js';
+export const logoutCommand = new Command('logout')
+    .description('Remove stored Runwork credentials')
+    .action(async () => {
+    const creds = getCredentials();
+    if (creds) {
+        await removeGitCredentials(creds.baseUrl);
+    }
+    clearCredentials();
+    console.log('Logged out.');
+});

package/dist/commands/logs.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const logsCommand: Command;