runwork 0.2.0

package/dist/template/manifest.js

@@ -0,0 +1,102 @@
+import { createHash } from 'crypto';
+import { execFileSync } from 'child_process';
+import { readFileSync, writeFileSync, existsSync, readdirSync, mkdirSync } from 'fs';
+import { join, relative } from 'path';
+const SKIP_DIRS = new Set(['.git', 'node_modules', '.runwork']);
+const SKIP_FILES = new Set(['.dev.vars', '.env']);
+function sha256(data) {
+    return 'sha256:' + createHash('sha256').update(data).digest('hex');
+}
+function walkDir(dir, base) {
+    const results = [];
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (SKIP_DIRS.has(entry.name))
+            continue;
+        if (SKIP_FILES.has(entry.name))
+            continue;
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            results.push(...walkDir(fullPath, base));
+        }
+        else if (entry.isFile()) {
+            results.push(relative(base, fullPath));
+        }
+    }
+    return results;
+}
+export async function generateManifest(dir) {
+    const files = {};
+    const allFiles = walkDir(dir, dir);
+    for (const relPath of allFiles) {
+        const content = readFileSync(join(dir, relPath));
+        files[relPath] = sha256(content);
+    }
+    return { version: 1, files };
+}
+export async function saveManifest(dir, manifest) {
+    const manifestDir = join(dir, '.runwork');
+    if (!existsSync(manifestDir)) {
+        mkdirSync(manifestDir, { recursive: true });
+    }
+    writeFileSync(join(manifestDir, 'template-manifest.json'), JSON.stringify(manifest, null, 2));
+}
+export async function loadManifest(dir) {
+    const manifestPath = join(dir, '.runwork', 'template-manifest.json');
+    if (!existsSync(manifestPath))
+        return null;
+    try {
+        return JSON.parse(readFileSync(manifestPath, 'utf-8'));
+    }
+    catch {
+        return 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 async function detectUserEdits(dir, manifest) {
+    const edits = [];
+    // 1. Uncommitted changes to tracked files
+    try {
+        const modified = execFileSync('git', ['diff', '--name-only', 'HEAD'], { cwd: dir, encoding: 'utf-8' }).trim();
+        const staged = execFileSync('git', ['diff', '--cached', '--name-only'], { cwd: dir, encoding: 'utf-8' }).trim();
+        for (const file of [...modified.split('\n'), ...staged.split('\n')]) {
+            if (file && !edits.includes(file))
+                edits.push(file);
+        }
+    }
+    catch {
+        // No git repo or no commits yet
+    }
+    // 2. Untracked files that aren't template files
+    try {
+        const untracked = execFileSync('git', ['ls-files', '--others', '--exclude-standard'], { cwd: dir, encoding: 'utf-8' }).trim();
+        for (const relPath of untracked.split('\n')) {
+            if (!relPath)
+                continue;
+            // Skip files in ignored directories
+            if (relPath.startsWith('node_modules/') || relPath.startsWith('.runwork/'))
+                continue;
+            // If it's a pristine template file, skip it
+            const expectedHash = manifest.files[relPath];
+            if (expectedHash) {
+                const content = readFileSync(join(dir, relPath));
+                if (sha256(content) === expectedHash)
+                    continue;
+            }
+            if (!edits.includes(relPath))
+                edits.push(relPath);
+        }
+    }
+    catch {
+        // No git repo
+    }
+    return edits;
+}

package/dist/types-manager.d.ts

@@ -0,0 +1 @@
+export declare function populateTypes(projectDir: string): Promise<void>;

package/dist/types-manager.js

@@ -0,0 +1,35 @@
+import { existsSync, mkdirSync, readdirSync, copyFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { BUNDLED_TYPES } from './generated/bundled-types.js';
+const TYPES_DIR = '.runwork/types';
+export async function populateTypes(projectDir) {
+    const typesDir = join(projectDir, TYPES_DIR);
+    mkdirSync(typesDir, { recursive: true });
+    // Tier 1: Copy from node_modules/@runworkai/framework/dist/
+    const frameworkDist = join(projectDir, 'node_modules/@runworkai/framework/dist');
+    if (existsSync(frameworkDist)) {
+        copyDtsFiles(frameworkDist, typesDir);
+        console.log('Types populated from node_modules/@runworkai/framework');
+        return;
+    }
+    // Tier 2: Download from platform (TODO - stub for now)
+    // Will be implemented when platform has a types download endpoint
+    // Tier 3: Write from embedded bundled types
+    const typeEntries = Object.entries(BUNDLED_TYPES);
+    if (typeEntries.length > 0) {
+        for (const [filename, content] of typeEntries) {
+            writeFileSync(join(typesDir, filename), content);
+        }
+        console.log('Types populated from bundled types');
+        return;
+    }
+    console.warn('No type definitions found. Install @runworkai/framework or reinstall the CLI.');
+}
+function copyDtsFiles(srcDir, destDir) {
+    const files = readdirSync(srcDir);
+    for (const file of files) {
+        if (file.endsWith('.d.ts')) {
+            copyFileSync(join(srcDir, file), join(destDir, file));
+        }
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,27 @@
+export interface RunworkConfig {
+    workspaceId: string;
+    appId: string;
+    appName: string;
+}
+export interface Credentials {
+    apiKey: string;
+    email: string;
+    baseUrl: string;
+}
+export interface DevSession {
+    sessionId: string;
+    previewUrl: string;
+    appId: string;
+}
+export interface AppInfo {
+    id: string;
+    name: string;
+    slug: string;
+    workspaceId: string;
+    workspaceName: string;
+    gitRemoteUrl: string;
+}
+export interface WorkspaceInfo {
+    id: string;
+    name: string;
+}

package/dist/types.js

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

package/dist/utils/__tests__/prompt.test.d.ts

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

package/dist/utils/__tests__/prompt.test.js

@@ -0,0 +1,103 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+const mockQuestion = vi.fn();
+const mockClose = vi.fn();
+vi.mock('readline', () => ({
+    createInterface: () => ({
+        question: mockQuestion,
+        close: mockClose,
+    }),
+}));
+const { promptSelect, promptInput } = await import('../prompt.js');
+describe('utils/prompt', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('promptSelect()', () => {
+        it('throws on empty choices array', async () => {
+            await expect(promptSelect('Pick one', [])).rejects.toThrow('No choices available');
+        });
+        it('auto-selects when only one choice', async () => {
+            const logSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+            const result = await promptSelect('Pick one', [
+                { label: 'Only Option', value: 42 },
+            ]);
+            expect(result).toEqual({ label: 'Only Option', value: 42 });
+            expect(logSpy).toHaveBeenCalledWith('Pick one: Only Option');
+            logSpy.mockRestore();
+        });
+        it('auto-selects preserves all properties on the choice object', async () => {
+            const logSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+            const choice = { label: 'Test', id: 'abc', extra: true };
+            const result = await promptSelect('Select', [choice]);
+            expect(result).toBe(choice);
+            logSpy.mockRestore();
+        });
+        it('returns correct choice by index when multiple choices', async () => {
+            const logSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+            // promptSelect calls promptInput internally, which uses readline
+            // Mock the question callback to simulate user selecting "2"
+            mockQuestion.mockImplementation((_prompt, cb) => {
+                cb('2');
+            });
+            const choices = [
+                { label: 'First', id: 1 },
+                { label: 'Second', id: 2 },
+                { label: 'Third', id: 3 },
+            ];
+            const result = await promptSelect('Choose', choices);
+            expect(result).toEqual({ label: 'Second', id: 2 });
+            logSpy.mockRestore();
+        });
+        it('exits process on invalid selection', async () => {
+            const logSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+            const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+            const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => {
+                throw new Error('process.exit');
+            }));
+            mockQuestion.mockImplementation((_prompt, cb) => {
+                cb('99');
+            });
+            const choices = [
+                { label: 'First', id: 1 },
+                { label: 'Second', id: 2 },
+            ];
+            await expect(promptSelect('Choose', choices)).rejects.toThrow('process.exit');
+            expect(exitSpy).toHaveBeenCalledWith(1);
+            logSpy.mockRestore();
+            errorSpy.mockRestore();
+            exitSpy.mockRestore();
+        });
+    });
+    describe('promptInput()', () => {
+        it('returns user input trimmed', async () => {
+            mockQuestion.mockImplementation((_prompt, cb) => {
+                cb('  user input  ');
+            });
+            const result = await promptInput('Enter value');
+            expect(result).toBe('user input');
+            expect(mockClose).toHaveBeenCalled();
+        });
+        it('returns default value when input is empty', async () => {
+            mockQuestion.mockImplementation((_prompt, cb) => {
+                cb('');
+            });
+            const result = await promptInput('Enter value', 'default-val');
+            expect(result).toBe('default-val');
+        });
+        it('includes default value hint in prompt', async () => {
+            mockQuestion.mockImplementation((_prompt, cb) => {
+                cb('answer');
+            });
+            await promptInput('Name', 'default');
+            const promptText = mockQuestion.mock.calls[0][0];
+            expect(promptText).toContain('[default]');
+        });
+        it('returns empty string when no input and no default', async () => {
+            mockQuestion.mockImplementation((_prompt, cb) => {
+                cb('  ');
+            });
+            const result = await promptInput('Enter');
+            expect(result).toBe('');
+        });
+    });
+});

package/dist/utils/fs.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Remove .git directories nested at depth >= 2 under the given root.
+ * Replaces `find <dir> -mindepth 2 -name .git -type d`.
+ */
+export declare function removeNestedGitDirs(rootDir: string): void;

package/dist/utils/fs.js

@@ -0,0 +1,23 @@
+import { readdirSync, rmSync } from 'fs';
+import { join, relative } from 'path';
+/**
+ * Remove .git directories nested at depth >= 2 under the given root.
+ * Replaces `find <dir> -mindepth 2 -name .git -type d`.
+ */
+export function removeNestedGitDirs(rootDir) {
+    const entries = readdirSync(rootDir, { recursive: true, withFileTypes: true });
+    for (const entry of entries) {
+        if (entry.name !== '.git' || !entry.isDirectory())
+            continue;
+        const parentPath = 'parentPath' in entry
+            ? entry.parentPath
+            : entry.path;
+        const fullPath = join(parentPath, entry.name);
+        const rel = relative(rootDir, fullPath);
+        const depth = rel.split('/').length;
+        // Only remove .git dirs at depth >= 2 (not the root .git)
+        if (depth >= 2) {
+            rmSync(fullPath, { recursive: true, force: true });
+        }
+    }
+}

package/dist/utils/prompt.d.ts

@@ -0,0 +1,4 @@
+export declare function promptSelect<T extends {
+    label: string;
+}>(message: string, choices: T[]): Promise<T>;
+export declare function promptInput(message: string, defaultValue?: string): Promise<string>;

package/dist/utils/prompt.js

@@ -0,0 +1,34 @@
+import { createInterface } from 'readline';
+export async function promptSelect(message, choices) {
+    if (choices.length === 0) {
+        throw new Error('No choices available');
+    }
+    if (choices.length === 1) {
+        console.log(`${message}: ${choices[0].label}`);
+        return choices[0];
+    }
+    console.log(message);
+    for (let i = 0; i < choices.length; i++) {
+        console.log(`  ${i + 1}. ${choices[i].label}`);
+    }
+    const answer = await promptInput(`Select (1-${choices.length})`, '1');
+    const index = parseInt(answer, 10) - 1;
+    if (isNaN(index) || index < 0 || index >= choices.length) {
+        console.error('Invalid selection.');
+        process.exit(1);
+    }
+    return choices[index];
+}
+export async function promptInput(message, defaultValue) {
+    const rl = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    const suffix = defaultValue ? ` [${defaultValue}]` : '';
+    return new Promise((resolve) => {
+        rl.question(`${message}${suffix}: `, (answer) => {
+            rl.close();
+            resolve(answer.trim() || defaultValue || '');
+        });
+    });
+}

package/dist/utils/zip.d.ts

@@ -0,0 +1 @@
+export declare function extractZip(zipData: ArrayBuffer, targetDir: string): void;

package/dist/utils/zip.js

@@ -0,0 +1,17 @@
+import { mkdirSync, writeFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { unzipSync } from 'fflate';
+export function extractZip(zipData, targetDir) {
+    const files = unzipSync(new Uint8Array(zipData));
+    for (const [path, data] of Object.entries(files)) {
+        const fullPath = join(targetDir, path);
+        // Directory entries end with /
+        if (path.endsWith('/')) {
+            mkdirSync(fullPath, { recursive: true });
+            continue;
+        }
+        // Ensure parent directory exists
+        mkdirSync(dirname(fullPath), { recursive: true });
+        writeFileSync(fullPath, data);
+    }
+}

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "runwork",
+  "version": "0.2.0",
+  "description": "CLI for Runwork: develop, preview, and deploy Runwork apps from your local machine.",
+  "license": "MIT",
+  "author": "Runwork <info@runwork.ai> (https://www.runwork.ai)",
+  "homepage": "https://www.runwork.ai",
+  "keywords": [
+    "runwork",
+    "runworkai",
+    "cli",
+    "developer-tools",
+    "local-development",
+    "deploy",
+    "preview",
+    "full-stack",
+    "typescript",
+    "ai",
+    "ai-agents",
+    "vibe",
+    "vibe-coding",
+    "edge",
+    "serverless"
+  ],
+  "type": "module",
+  "bin": {
+    "runwork": "./bin/runwork.js"
+  },
+  "scripts": {
+    "prebuild": "mkdir -p bundled-types && cp ../framework/dist/*.d.ts bundled-types/ 2>/dev/null || true && bun run scripts/embed-types.ts",
+    "build": "bun run prebuild && tsc",
+    "build:binary": "bun run prebuild && bun build src/index.ts --compile --outfile dist/runwork",
+    "build:binaries": "bun run scripts/build-binaries.ts",
+    "dev": "tsc --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "prepublishOnly": "bun run prebuild && tsc",
+    "release": "npm publish && npm dist-tag add runwork@$(node -p \"require('./package.json').version\") next",
+    "release:binaries": "bun run scripts/release-binaries.ts",
+    "release:binaries:upload": "bun run scripts/release-binaries.ts --skip-build",
+    "release:full": "bun run release && bun run scripts/release-binaries.ts"
+  },
+  "dependencies": {
+    "chokidar": "^4.0.0",
+    "commander": "^13.0.0",
+    "fflate": "^0.8.2",
+    "open": "^10.0.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.7.0",
+    "@types/node": "^22.0.0",
+    "vitest": "^3.2.0"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "dist/**/*.json",
+    "bin/",
+    "bundled-types/",
+    "LICENSE",
+    "README.md"
+  ]
+}