runway-cli 0.8.0

package/dist/services/buildService.js

@@ -0,0 +1,180 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildService = exports.BuildService = void 0;
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const logger_1 = require("../utils/logger");
+class BuildService {
+    async build(options) {
+        const startTime = Date.now();
+        const { projectPath, projectType, projectName, packageManager, envFile } = options;
+        // Static projects don't need building
+        if (projectType === 'static') {
+            logger_1.logger.info('Static project - no build required');
+            return {
+                success: true,
+                outputDir: projectPath,
+                duration: Date.now() - startTime,
+            };
+        }
+        // Check if build script exists (especially important for Node.js)
+        const pkgPath = path_1.default.join(projectPath, 'package.json');
+        if (fs_1.default.existsSync(pkgPath)) {
+            const pkg = JSON.parse(fs_1.default.readFileSync(pkgPath, 'utf-8'));
+            if (!pkg.scripts?.build) {
+                // Node.js projects often don't have a build script
+                if (projectType === 'node') {
+                    logger_1.logger.info('Node.js project - no build script found, skipping build');
+                    return {
+                        success: true,
+                        outputDir: projectPath,
+                        duration: Date.now() - startTime,
+                    };
+                }
+                // For React/Next, a build script is required
+                return {
+                    success: false,
+                    outputDir: projectPath,
+                    duration: Date.now() - startTime,
+                    error: 'Missing "build" script in package.json',
+                };
+            }
+        }
+        // Load environment variables from file if provided
+        const env = { ...process.env };
+        if (envFile && fs_1.default.existsSync(envFile)) {
+            const envContent = fs_1.default.readFileSync(envFile, 'utf-8');
+            for (const line of envContent.split('\n')) {
+                const trimmed = line.trim();
+                if (trimmed && !trimmed.startsWith('#')) {
+                    const [key, ...valueParts] = trimmed.split('=');
+                    if (key) {
+                        env[key] = valueParts.join('=');
+                    }
+                }
+            }
+        }
+        // Check if dependencies need to be installed
+        const nodeModulesPath = path_1.default.join(projectPath, 'node_modules');
+        if (!fs_1.default.existsSync(nodeModulesPath)) {
+            logger_1.logger.info('Installing dependencies...');
+            const installArgs = packageManager === 'yarn' ? [] : ['install'];
+            try {
+                await this.runCommand(packageManager, installArgs, projectPath, env);
+                logger_1.logger.success('Dependencies installed');
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    outputDir: projectPath,
+                    duration: Date.now() - startTime,
+                    error: `Failed to install dependencies: ${error instanceof Error ? error.message : String(error)}`,
+                };
+            }
+        }
+        // Determine build command based on project type
+        const buildArgs = this.getBuildArgs(projectType, projectName, packageManager);
+        const outputDir = this.getOutputDir(projectPath, projectType);
+        logger_1.logger.info(`Building ${projectType} project...`);
+        logger_1.logger.dim(`Command: ${packageManager} ${buildArgs.join(' ')}`);
+        try {
+            await this.runCommand(packageManager, buildArgs, projectPath, env);
+            // Verify build output exists
+            if (!fs_1.default.existsSync(outputDir)) {
+                return {
+                    success: false,
+                    outputDir,
+                    duration: Date.now() - startTime,
+                    error: `Build output directory not found: ${outputDir}`,
+                };
+            }
+            return {
+                success: true,
+                outputDir,
+                duration: Date.now() - startTime,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                outputDir,
+                duration: Date.now() - startTime,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    getBuildArgs(projectType, projectName, packageManager) {
+        const safeName = projectName.toLowerCase().replace(/[^a-z0-9]/g, '-');
+        const basePath = `/app/${safeName}`;
+        const baseArgs = ['run', 'build'];
+        if (projectType === 'react') {
+            // Pass base path for Vite or CRA
+            if (packageManager === 'npm') {
+                return [...baseArgs, '--', `--base=${basePath}`];
+            }
+            else {
+                return [...baseArgs, `--base=${basePath}`];
+            }
+        }
+        // For Next.js and Node.js, just run the build script
+        return baseArgs;
+    }
+    getOutputDir(projectPath, projectType) {
+        switch (projectType) {
+            case 'react':
+                // Check for Vite vs CRA
+                if (fs_1.default.existsSync(path_1.default.join(projectPath, 'vite.config.ts')) ||
+                    fs_1.default.existsSync(path_1.default.join(projectPath, 'vite.config.js'))) {
+                    return path_1.default.join(projectPath, 'dist');
+                }
+                return path_1.default.join(projectPath, 'build');
+            case 'next':
+                return path_1.default.join(projectPath, '.next');
+            case 'node':
+                // For Node.js, the project root is the "output"
+                return projectPath;
+            case 'static':
+                // For static sites, the project root is the "output"
+                return projectPath;
+        }
+    }
+    runCommand(command, args, cwd, env) {
+        return new Promise((resolve, reject) => {
+            const proc = (0, child_process_1.spawn)(command, args, {
+                cwd,
+                env,
+                stdio: 'pipe',
+                shell: true,
+            });
+            let stdout = '';
+            let stderr = '';
+            proc.stdout?.on('data', (data) => {
+                stdout += data.toString();
+                // Print build output in real-time
+                process.stdout.write(data);
+            });
+            proc.stderr?.on('data', (data) => {
+                stderr += data.toString();
+                process.stderr.write(data);
+            });
+            proc.on('close', (code) => {
+                if (code === 0) {
+                    resolve();
+                }
+                else {
+                    reject(new Error(`Build failed with exit code ${code}\n${stderr}`));
+                }
+            });
+            proc.on('error', (error) => {
+                reject(error);
+            });
+        });
+    }
+}
+exports.BuildService = BuildService;
+exports.buildService = new BuildService();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"buildService.js","sourceRoot":"","sources":["../../src/services/buildService.ts"],"names":[],"mappings":"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","sourcesContent":["import { spawn } from 'child_process';\nimport path from 'path';\nimport fs from 'fs';\nimport { ProjectType, PackageManager } from '../types';\nimport { logger } from '../utils/logger';\n\nexport interface BuildOptions {\n  projectPath: string;\n  projectType: ProjectType;\n  projectName: string;\n  packageManager: PackageManager;\n  envFile?: string;\n}\n\nexport interface BuildResult {\n  success: boolean;\n  outputDir: string;\n  duration: number;\n  error?: string;\n}\n\nexport class BuildService {\n  async build(options: BuildOptions): Promise<BuildResult> {\n    const startTime = Date.now();\n    const { projectPath, projectType, projectName, packageManager, envFile } = options;\n\n    // Static projects don't need building\n    if (projectType === 'static') {\n      logger.info('Static project - no build required');\n      return {\n        success: true,\n        outputDir: projectPath,\n        duration: Date.now() - startTime,\n      };\n    }\n\n    // Check if build script exists (especially important for Node.js)\n    const pkgPath = path.join(projectPath, 'package.json');\n    if (fs.existsSync(pkgPath)) {\n      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));\n      if (!pkg.scripts?.build) {\n        // Node.js projects often don't have a build script\n        if (projectType === 'node') {\n          logger.info('Node.js project - no build script found, skipping build');\n          return {\n            success: true,\n            outputDir: projectPath,\n            duration: Date.now() - startTime,\n          };\n        }\n        // For React/Next, a build script is required\n        return {\n          success: false,\n          outputDir: projectPath,\n          duration: Date.now() - startTime,\n          error: 'Missing \"build\" script in package.json',\n        };\n      }\n    }\n\n    // Load environment variables from file if provided\n    const env: Record<string, string> = { ...process.env as Record<string, string> };\n\n    if (envFile && fs.existsSync(envFile)) {\n      const envContent = fs.readFileSync(envFile, 'utf-8');\n      for (const line of envContent.split('\\n')) {\n        const trimmed = line.trim();\n        if (trimmed && !trimmed.startsWith('#')) {\n          const [key, ...valueParts] = trimmed.split('=');\n          if (key) {\n            env[key] = valueParts.join('=');\n          }\n        }\n      }\n    }\n\n    // Check if dependencies need to be installed\n    const nodeModulesPath = path.join(projectPath, 'node_modules');\n    if (!fs.existsSync(nodeModulesPath)) {\n      logger.info('Installing dependencies...');\n      const installArgs = packageManager === 'yarn' ? [] : ['install'];\n      try {\n        await this.runCommand(packageManager, installArgs, projectPath, env);\n        logger.success('Dependencies installed');\n      } catch (error) {\n        return {\n          success: false,\n          outputDir: projectPath,\n          duration: Date.now() - startTime,\n          error: `Failed to install dependencies: ${error instanceof Error ? error.message : String(error)}`,\n        };\n      }\n    }\n\n    // Determine build command based on project type\n    const buildArgs = this.getBuildArgs(projectType, projectName, packageManager);\n    const outputDir = this.getOutputDir(projectPath, projectType);\n\n    logger.info(`Building ${projectType} project...`);\n    logger.dim(`Command: ${packageManager} ${buildArgs.join(' ')}`);\n\n    try {\n      await this.runCommand(packageManager, buildArgs, projectPath, env);\n\n      // Verify build output exists\n      if (!fs.existsSync(outputDir)) {\n        return {\n          success: false,\n          outputDir,\n          duration: Date.now() - startTime,\n          error: `Build output directory not found: ${outputDir}`,\n        };\n      }\n\n      return {\n        success: true,\n        outputDir,\n        duration: Date.now() - startTime,\n      };\n    } catch (error) {\n      return {\n        success: false,\n        outputDir,\n        duration: Date.now() - startTime,\n        error: error instanceof Error ? error.message : String(error),\n      };\n    }\n  }\n\n  private getBuildArgs(projectType: ProjectType, projectName: string, packageManager: PackageManager): string[] {\n    const safeName = projectName.toLowerCase().replace(/[^a-z0-9]/g, '-');\n    const basePath = `/app/${safeName}`;\n\n    const baseArgs = ['run', 'build'];\n\n    if (projectType === 'react') {\n      // Pass base path for Vite or CRA\n      if (packageManager === 'npm') {\n        return [...baseArgs, '--', `--base=${basePath}`];\n      } else {\n        return [...baseArgs, `--base=${basePath}`];\n      }\n    }\n\n    // For Next.js and Node.js, just run the build script\n    return baseArgs;\n  }\n\n  private getOutputDir(projectPath: string, projectType: ProjectType): string {\n    switch (projectType) {\n      case 'react':\n        // Check for Vite vs CRA\n        if (fs.existsSync(path.join(projectPath, 'vite.config.ts')) ||\n            fs.existsSync(path.join(projectPath, 'vite.config.js'))) {\n          return path.join(projectPath, 'dist');\n        }\n        return path.join(projectPath, 'build');\n\n      case 'next':\n        return path.join(projectPath, '.next');\n\n      case 'node':\n        // For Node.js, the project root is the \"output\"\n        return projectPath;\n\n      case 'static':\n        // For static sites, the project root is the \"output\"\n        return projectPath;\n    }\n  }\n\n  private runCommand(command: string, args: string[], cwd: string, env: Record<string, string>): Promise<void> {\n    return new Promise((resolve, reject) => {\n      const proc = spawn(command, args, {\n        cwd,\n        env,\n        stdio: 'pipe',\n        shell: true,\n      });\n\n      let stdout = '';\n      let stderr = '';\n\n      proc.stdout?.on('data', (data) => {\n        stdout += data.toString();\n        // Print build output in real-time\n        process.stdout.write(data);\n      });\n\n      proc.stderr?.on('data', (data) => {\n        stderr += data.toString();\n        process.stderr.write(data);\n      });\n\n      proc.on('close', (code) => {\n        if (code === 0) {\n          resolve();\n        } else {\n          reject(new Error(`Build failed with exit code ${code}\\n${stderr}`));\n        }\n      });\n\n      proc.on('error', (error) => {\n        reject(error);\n      });\n    });\n  }\n}\n\nexport const buildService = new BuildService();\n"]}

package/dist/services/packageService.d.ts

@@ -0,0 +1,20 @@
+import { ProjectType } from '../types';
+export interface PackageOptions {
+    projectPath: string;
+    projectType: ProjectType;
+    buildOutputDir: string;
+    includeSource: boolean;
+}
+export interface PackageResult {
+    zipPath: string;
+    size: number;
+}
+export declare class PackageService {
+    package(options: PackageOptions): Promise<PackageResult>;
+    private addSourceFiles;
+    private addBuildArtifacts;
+    private addDirectory;
+    private addLockFile;
+    cleanup(zipPath: string): void;
+}
+export declare const packageService: PackageService;

package/dist/services/packageService.js

@@ -0,0 +1,153 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.packageService = exports.PackageService = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const archiver_1 = __importDefault(require("archiver"));
+const logger_1 = require("../utils/logger");
+class PackageService {
+    async package(options) {
+        const { projectPath, projectType, buildOutputDir, includeSource } = options;
+        const zipPath = path_1.default.join(projectPath, '.runway-deploy.zip');
+        // Remove existing zip if present
+        if (fs_1.default.existsSync(zipPath)) {
+            fs_1.default.unlinkSync(zipPath);
+        }
+        logger_1.logger.info('Creating deployment package...');
+        const output = fs_1.default.createWriteStream(zipPath);
+        const archive = (0, archiver_1.default)('zip', {
+            zlib: { level: 9 }, // Maximum compression
+        });
+        return new Promise((resolve, reject) => {
+            output.on('close', () => {
+                const size = archive.pointer();
+                logger_1.logger.success(`Package created: ${(size / 1024 / 1024).toFixed(2)} MB`);
+                resolve({ zipPath, size });
+            });
+            archive.on('error', (err) => {
+                reject(err);
+            });
+            archive.pipe(output);
+            if (includeSource) {
+                // Server-build mode: include source files
+                this.addSourceFiles(archive, projectPath);
+            }
+            else {
+                // Local-build mode: include only build artifacts
+                this.addBuildArtifacts(archive, projectPath, projectType, buildOutputDir);
+            }
+            archive.finalize();
+        });
+    }
+    addSourceFiles(archive, projectPath) {
+        // Include all files except node_modules, .git, and build outputs
+        const ignorePatterns = [
+            'node_modules/**',
+            '.git/**',
+            '.next/**',
+            'dist/**',
+            'build/**',
+            '.runway-deploy.zip',
+            '*.log',
+            '.env.local',
+            '.env.*.local',
+        ];
+        archive.glob('**/*', {
+            cwd: projectPath,
+            ignore: ignorePatterns,
+            dot: true, // Include dotfiles
+        });
+        logger_1.logger.dim('Including source files for server-side build');
+    }
+    addBuildArtifacts(archive, projectPath, projectType, buildOutputDir) {
+        // Include package.json if it exists (optional for static sites)
+        const packageJsonPath = path_1.default.join(projectPath, 'package.json');
+        if (fs_1.default.existsSync(packageJsonPath)) {
+            archive.file(packageJsonPath, { name: 'package.json' });
+        }
+        switch (projectType) {
+            case 'react':
+                // Include built static files
+                this.addDirectory(archive, buildOutputDir, 'dist');
+                logger_1.logger.dim(`Including build output from ${buildOutputDir}`);
+                break;
+            case 'next':
+                // Include .next directory
+                this.addDirectory(archive, path_1.default.join(projectPath, '.next'), '.next');
+                // Include public directory if exists
+                const publicDir = path_1.default.join(projectPath, 'public');
+                if (fs_1.default.existsSync(publicDir)) {
+                    this.addDirectory(archive, publicDir, 'public');
+                }
+                // Include next.config.js if exists
+                for (const configFile of ['next.config.js', 'next.config.mjs', 'next.config.ts']) {
+                    const configPath = path_1.default.join(projectPath, configFile);
+                    if (fs_1.default.existsSync(configPath)) {
+                        archive.file(configPath, { name: configFile });
+                    }
+                }
+                // Include package-lock.json or yarn.lock for production dependencies
+                this.addLockFile(archive, projectPath);
+                logger_1.logger.dim('Including Next.js build artifacts');
+                break;
+            case 'node':
+                // For Node.js, include everything except node_modules
+                const nodeIgnorePatterns = [
+                    'node_modules/**',
+                    '.git/**',
+                    '.runway-deploy.zip',
+                    '*.log',
+                ];
+                archive.glob('**/*', {
+                    cwd: projectPath,
+                    ignore: nodeIgnorePatterns,
+                    dot: true,
+                });
+                logger_1.logger.dim('Including Node.js project files');
+                break;
+            case 'static':
+                // For static sites, include HTML, CSS, JS, and common assets
+                const staticIgnorePatterns = [
+                    'node_modules/**',
+                    '.git/**',
+                    '.runway-deploy.zip',
+                    '*.log',
+                    '.env',
+                    '.env.*',
+                ];
+                archive.glob('**/*', {
+                    cwd: projectPath,
+                    ignore: staticIgnorePatterns,
+                    dot: false, // Don't include dotfiles for static sites
+                });
+                logger_1.logger.dim('Including static site files');
+                break;
+        }
+    }
+    addDirectory(archive, dirPath, destPath) {
+        if (fs_1.default.existsSync(dirPath)) {
+            archive.directory(dirPath, destPath);
+        }
+    }
+    addLockFile(archive, projectPath) {
+        const lockFiles = ['package-lock.json', 'yarn.lock', 'pnpm-lock.yaml'];
+        for (const lockFile of lockFiles) {
+            const lockPath = path_1.default.join(projectPath, lockFile);
+            if (fs_1.default.existsSync(lockPath)) {
+                archive.file(lockPath, { name: lockFile });
+                break;
+            }
+        }
+    }
+    cleanup(zipPath) {
+        if (fs_1.default.existsSync(zipPath)) {
+            fs_1.default.unlinkSync(zipPath);
+        }
+    }
+}
+exports.PackageService = PackageService;
+exports.packageService = new PackageService();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"packageService.js","sourceRoot":"","sources":["../../src/services/packageService.ts"],"names":[],"mappings":"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","sourcesContent":["import fs from 'fs';\nimport path from 'path';\nimport archiver from 'archiver';\nimport { ProjectType } from '../types';\nimport { logger } from '../utils/logger';\n\nexport interface PackageOptions {\n  projectPath: string;\n  projectType: ProjectType;\n  buildOutputDir: string;\n  includeSource: boolean; // For server-build mode\n}\n\nexport interface PackageResult {\n  zipPath: string;\n  size: number;\n}\n\nexport class PackageService {\n  async package(options: PackageOptions): Promise<PackageResult> {\n    const { projectPath, projectType, buildOutputDir, includeSource } = options;\n\n    const zipPath = path.join(projectPath, '.runway-deploy.zip');\n\n    // Remove existing zip if present\n    if (fs.existsSync(zipPath)) {\n      fs.unlinkSync(zipPath);\n    }\n\n    logger.info('Creating deployment package...');\n\n    const output = fs.createWriteStream(zipPath);\n    const archive = archiver('zip', {\n      zlib: { level: 9 }, // Maximum compression\n    });\n\n    return new Promise((resolve, reject) => {\n      output.on('close', () => {\n        const size = archive.pointer();\n        logger.success(`Package created: ${(size / 1024 / 1024).toFixed(2)} MB`);\n        resolve({ zipPath, size });\n      });\n\n      archive.on('error', (err) => {\n        reject(err);\n      });\n\n      archive.pipe(output);\n\n      if (includeSource) {\n        // Server-build mode: include source files\n        this.addSourceFiles(archive, projectPath);\n      } else {\n        // Local-build mode: include only build artifacts\n        this.addBuildArtifacts(archive, projectPath, projectType, buildOutputDir);\n      }\n\n      archive.finalize();\n    });\n  }\n\n  private addSourceFiles(archive: archiver.Archiver, projectPath: string): void {\n    // Include all files except node_modules, .git, and build outputs\n    const ignorePatterns = [\n      'node_modules/**',\n      '.git/**',\n      '.next/**',\n      'dist/**',\n      'build/**',\n      '.runway-deploy.zip',\n      '*.log',\n      '.env.local',\n      '.env.*.local',\n    ];\n\n    archive.glob('**/*', {\n      cwd: projectPath,\n      ignore: ignorePatterns,\n      dot: true, // Include dotfiles\n    });\n\n    logger.dim('Including source files for server-side build');\n  }\n\n  private addBuildArtifacts(\n    archive: archiver.Archiver,\n    projectPath: string,\n    projectType: ProjectType,\n    buildOutputDir: string\n  ): void {\n    // Include package.json if it exists (optional for static sites)\n    const packageJsonPath = path.join(projectPath, 'package.json');\n    if (fs.existsSync(packageJsonPath)) {\n      archive.file(packageJsonPath, { name: 'package.json' });\n    }\n\n    switch (projectType) {\n      case 'react':\n        // Include built static files\n        this.addDirectory(archive, buildOutputDir, 'dist');\n        logger.dim(`Including build output from ${buildOutputDir}`);\n        break;\n\n      case 'next':\n        // Include .next directory\n        this.addDirectory(archive, path.join(projectPath, '.next'), '.next');\n\n        // Include public directory if exists\n        const publicDir = path.join(projectPath, 'public');\n        if (fs.existsSync(publicDir)) {\n          this.addDirectory(archive, publicDir, 'public');\n        }\n\n        // Include next.config.js if exists\n        for (const configFile of ['next.config.js', 'next.config.mjs', 'next.config.ts']) {\n          const configPath = path.join(projectPath, configFile);\n          if (fs.existsSync(configPath)) {\n            archive.file(configPath, { name: configFile });\n          }\n        }\n\n        // Include package-lock.json or yarn.lock for production dependencies\n        this.addLockFile(archive, projectPath);\n\n        logger.dim('Including Next.js build artifacts');\n        break;\n\n      case 'node':\n        // For Node.js, include everything except node_modules\n        const nodeIgnorePatterns = [\n          'node_modules/**',\n          '.git/**',\n          '.runway-deploy.zip',\n          '*.log',\n        ];\n\n        archive.glob('**/*', {\n          cwd: projectPath,\n          ignore: nodeIgnorePatterns,\n          dot: true,\n        });\n\n        logger.dim('Including Node.js project files');\n        break;\n\n      case 'static':\n        // For static sites, include HTML, CSS, JS, and common assets\n        const staticIgnorePatterns = [\n          'node_modules/**',\n          '.git/**',\n          '.runway-deploy.zip',\n          '*.log',\n          '.env',\n          '.env.*',\n        ];\n\n        archive.glob('**/*', {\n          cwd: projectPath,\n          ignore: staticIgnorePatterns,\n          dot: false, // Don't include dotfiles for static sites\n        });\n\n        logger.dim('Including static site files');\n        break;\n    }\n  }\n\n  private addDirectory(archive: archiver.Archiver, dirPath: string, destPath: string): void {\n    if (fs.existsSync(dirPath)) {\n      archive.directory(dirPath, destPath);\n    }\n  }\n\n  private addLockFile(archive: archiver.Archiver, projectPath: string): void {\n    const lockFiles = ['package-lock.json', 'yarn.lock', 'pnpm-lock.yaml'];\n\n    for (const lockFile of lockFiles) {\n      const lockPath = path.join(projectPath, lockFile);\n      if (fs.existsSync(lockPath)) {\n        archive.file(lockPath, { name: lockFile });\n        break;\n      }\n    }\n  }\n\n  cleanup(zipPath: string): void {\n    if (fs.existsSync(zipPath)) {\n      fs.unlinkSync(zipPath);\n    }\n  }\n}\n\nexport const packageService = new PackageService();\n"]}

package/dist/services/projectDetector.d.ts

@@ -0,0 +1,21 @@
+import { ProjectType, PackageManager } from '../types';
+export interface DetectedProject {
+    type: ProjectType;
+    name: string;
+    version: string;
+    packageManager: PackageManager;
+    buildScript: string | null;
+    startScript: string | null;
+    buildOutputDir: string;
+}
+export declare class ProjectDetector {
+    private projectPath;
+    constructor(projectPath?: string);
+    detect(): Promise<DetectedProject>;
+    private readPackageJson;
+    private detectProjectType;
+    private detectPackageManager;
+    private getBuildOutputDir;
+    validateBuildOutput(): boolean;
+}
+export declare const detectProject: (projectPath?: string) => Promise<DetectedProject>;

package/dist/services/projectDetector.js

@@ -0,0 +1,165 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectProject = exports.ProjectDetector = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+class ProjectDetector {
+    constructor(projectPath = process.cwd()) {
+        this.projectPath = projectPath;
+    }
+    async detect() {
+        // Check for static site first (index.html without package.json or with minimal package.json)
+        const hasIndexHtml = fs_1.default.existsSync(path_1.default.join(this.projectPath, 'index.html'));
+        const hasPackageJson = fs_1.default.existsSync(path_1.default.join(this.projectPath, 'package.json'));
+        // Static site: has index.html but no package.json
+        if (hasIndexHtml && !hasPackageJson) {
+            return {
+                type: 'static',
+                name: path_1.default.basename(this.projectPath),
+                version: '1.0.0',
+                packageManager: 'none',
+                buildScript: null,
+                startScript: null,
+                buildOutputDir: '.',
+            };
+        }
+        // If no package.json and no index.html, unsupported
+        if (!hasPackageJson && !hasIndexHtml) {
+            throw new Error(`No package.json or index.html found in ${this.projectPath}\n\n` +
+                `Runway CLI supports:\n` +
+                `  - Static sites (with index.html)\n` +
+                `  - React/Next.js/Node.js projects (with package.json)\n\n` +
+                `Python, Ruby, Go, and other runtimes are not supported.`);
+        }
+        const packageJson = this.readPackageJson();
+        const type = this.detectProjectType(packageJson, hasIndexHtml);
+        const packageManager = this.detectPackageManager();
+        const buildOutputDir = this.getBuildOutputDir(type);
+        return {
+            type,
+            name: packageJson.name || path_1.default.basename(this.projectPath),
+            version: packageJson.version || '0.0.1',
+            packageManager,
+            buildScript: packageJson.scripts?.build || null,
+            startScript: packageJson.scripts?.start || null,
+            buildOutputDir,
+        };
+    }
+    readPackageJson() {
+        const packageJsonPath = path_1.default.join(this.projectPath, 'package.json');
+        try {
+            const content = fs_1.default.readFileSync(packageJsonPath, 'utf-8');
+            return JSON.parse(content);
+        }
+        catch (error) {
+            throw new Error(`Failed to parse package.json: ${error}`);
+        }
+    }
+    detectProjectType(packageJson, hasIndexHtml) {
+        const deps = {
+            ...packageJson.dependencies,
+            ...packageJson.devDependencies,
+        };
+        // Check for Next.js
+        if (deps['next']) {
+            return 'next';
+        }
+        // Check for React (and not Next.js)
+        if (deps['react'] || deps['react-dom']) {
+            const hasVite = deps['vite'] !== undefined;
+            const hasCRA = deps['react-scripts'] !== undefined;
+            if (hasVite || hasCRA || packageJson.scripts?.build) {
+                return 'react';
+            }
+        }
+        // Check for Node.js indicators
+        const hasStartScript = packageJson.scripts?.start !== undefined;
+        const hasMainEntry = fs_1.default.existsSync(path_1.default.join(this.projectPath, 'index.js')) ||
+            fs_1.default.existsSync(path_1.default.join(this.projectPath, 'src/index.js')) ||
+            fs_1.default.existsSync(path_1.default.join(this.projectPath, 'src/index.ts')) ||
+            fs_1.default.existsSync(path_1.default.join(this.projectPath, 'server.js')) ||
+            fs_1.default.existsSync(path_1.default.join(this.projectPath, 'app.js'));
+        if (hasStartScript || hasMainEntry) {
+            return 'node';
+        }
+        // If has index.html with package.json but no framework detected, treat as static
+        if (hasIndexHtml) {
+            return 'static';
+        }
+        // If has a build script, assume it's a frontend project that compiles to static
+        if (packageJson.scripts?.build) {
+            return 'static';
+        }
+        throw new Error(`Could not detect a supported project type.\n\n` +
+            `Runway supports: React, Next.js, Node.js, and Static HTML.\n\n` +
+            `For Node.js apps, add a "start" script to package.json.\n` +
+            `For static sites, ensure index.html exists at the project root.`);
+    }
+    detectPackageManager() {
+        if (fs_1.default.existsSync(path_1.default.join(this.projectPath, 'pnpm-lock.yaml'))) {
+            return 'pnpm';
+        }
+        if (fs_1.default.existsSync(path_1.default.join(this.projectPath, 'yarn.lock'))) {
+            return 'yarn';
+        }
+        if (fs_1.default.existsSync(path_1.default.join(this.projectPath, 'package-lock.json'))) {
+            return 'npm';
+        }
+        // No lock file found
+        return 'npm';
+    }
+    getBuildOutputDir(type) {
+        switch (type) {
+            case 'react':
+                if (fs_1.default.existsSync(path_1.default.join(this.projectPath, 'vite.config.ts')) ||
+                    fs_1.default.existsSync(path_1.default.join(this.projectPath, 'vite.config.js'))) {
+                    return 'dist';
+                }
+                return 'build';
+            case 'next':
+                return '.next';
+            case 'node':
+                return '.';
+            case 'static':
+                return '.';
+        }
+    }
+    validateBuildOutput() {
+        const hasPackageJson = fs_1.default.existsSync(path_1.default.join(this.projectPath, 'package.json'));
+        const hasIndexHtml = fs_1.default.existsSync(path_1.default.join(this.projectPath, 'index.html'));
+        // For static without package.json
+        if (!hasPackageJson) {
+            return hasIndexHtml;
+        }
+        const packageJson = this.readPackageJson();
+        const type = this.detectProjectType(packageJson, hasIndexHtml);
+        const outputDir = this.getBuildOutputDir(type);
+        const outputPath = path_1.default.join(this.projectPath, outputDir);
+        if (type === 'node') {
+            return fs_1.default.existsSync(path_1.default.join(this.projectPath, 'package.json'));
+        }
+        if (type === 'static') {
+            return fs_1.default.existsSync(path_1.default.join(this.projectPath, 'index.html'));
+        }
+        if (!fs_1.default.existsSync(outputPath)) {
+            return false;
+        }
+        if (type === 'react') {
+            return fs_1.default.existsSync(path_1.default.join(outputPath, 'index.html'));
+        }
+        if (type === 'next') {
+            return fs_1.default.existsSync(path_1.default.join(outputPath, 'server'));
+        }
+        return false;
+    }
+}
+exports.ProjectDetector = ProjectDetector;
+const detectProject = async (projectPath) => {
+    const detector = new ProjectDetector(projectPath);
+    return detector.detect();
+};
+exports.detectProject = detectProject;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"projectDetector.js","sourceRoot":"","sources":["../../src/services/projectDetector.ts"],"names":[],"mappings":"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","sourcesContent":["import fs from 'fs';\nimport path from 'path';\nimport { ProjectType, PackageManager } from '../types';\n\nexport interface DetectedProject {\n  type: ProjectType;\n  name: string;\n  version: string;\n  packageManager: PackageManager;\n  buildScript: string | null;\n  startScript: string | null;\n  buildOutputDir: string;\n}\n\ninterface PackageJson {\n  name?: string;\n  version?: string;\n  scripts?: Record<string, string>;\n  dependencies?: Record<string, string>;\n  devDependencies?: Record<string, string>;\n}\n\nexport class ProjectDetector {\n  private projectPath: string;\n\n  constructor(projectPath: string = process.cwd()) {\n    this.projectPath = projectPath;\n  }\n\n  async detect(): Promise<DetectedProject> {\n    // Check for static site first (index.html without package.json or with minimal package.json)\n    const hasIndexHtml = fs.existsSync(path.join(this.projectPath, 'index.html'));\n    const hasPackageJson = fs.existsSync(path.join(this.projectPath, 'package.json'));\n\n    // Static site: has index.html but no package.json\n    if (hasIndexHtml && !hasPackageJson) {\n      return {\n        type: 'static',\n        name: path.basename(this.projectPath),\n        version: '1.0.0',\n        packageManager: 'none',\n        buildScript: null,\n        startScript: null,\n        buildOutputDir: '.',\n      };\n    }\n\n    // If no package.json and no index.html, unsupported\n    if (!hasPackageJson && !hasIndexHtml) {\n      throw new Error(\n        `No package.json or index.html found in ${this.projectPath}\\n\\n` +\n        `Runway CLI supports:\\n` +\n        `  - Static sites (with index.html)\\n` +\n        `  - React/Next.js/Node.js projects (with package.json)\\n\\n` +\n        `Python, Ruby, Go, and other runtimes are not supported.`\n      );\n    }\n\n    const packageJson = this.readPackageJson();\n    const type = this.detectProjectType(packageJson, hasIndexHtml);\n    const packageManager = this.detectPackageManager();\n    const buildOutputDir = this.getBuildOutputDir(type);\n\n    return {\n      type,\n      name: packageJson.name || path.basename(this.projectPath),\n      version: packageJson.version || '0.0.1',\n      packageManager,\n      buildScript: packageJson.scripts?.build || null,\n      startScript: packageJson.scripts?.start || null,\n      buildOutputDir,\n    };\n  }\n\n  private readPackageJson(): PackageJson {\n    const packageJsonPath = path.join(this.projectPath, 'package.json');\n\n    try {\n      const content = fs.readFileSync(packageJsonPath, 'utf-8');\n      return JSON.parse(content);\n    } catch (error) {\n      throw new Error(`Failed to parse package.json: ${error}`);\n    }\n  }\n\n  private detectProjectType(packageJson: PackageJson, hasIndexHtml: boolean): ProjectType {\n    const deps = {\n      ...packageJson.dependencies,\n      ...packageJson.devDependencies,\n    };\n\n    // Check for Next.js\n    if (deps['next']) {\n      return 'next';\n    }\n\n    // Check for React (and not Next.js)\n    if (deps['react'] || deps['react-dom']) {\n      const hasVite = deps['vite'] !== undefined;\n      const hasCRA = deps['react-scripts'] !== undefined;\n\n      if (hasVite || hasCRA || packageJson.scripts?.build) {\n        return 'react';\n      }\n    }\n\n    // Check for Node.js indicators\n    const hasStartScript = packageJson.scripts?.start !== undefined;\n    const hasMainEntry = fs.existsSync(path.join(this.projectPath, 'index.js')) ||\n                         fs.existsSync(path.join(this.projectPath, 'src/index.js')) ||\n                         fs.existsSync(path.join(this.projectPath, 'src/index.ts')) ||\n                         fs.existsSync(path.join(this.projectPath, 'server.js')) ||\n                         fs.existsSync(path.join(this.projectPath, 'app.js'));\n\n    if (hasStartScript || hasMainEntry) {\n      return 'node';\n    }\n\n    // If has index.html with package.json but no framework detected, treat as static\n    if (hasIndexHtml) {\n      return 'static';\n    }\n\n    // If has a build script, assume it's a frontend project that compiles to static\n    if (packageJson.scripts?.build) {\n      return 'static';\n    }\n\n    throw new Error(\n      `Could not detect a supported project type.\\n\\n` +\n      `Runway supports: React, Next.js, Node.js, and Static HTML.\\n\\n` +\n      `For Node.js apps, add a \"start\" script to package.json.\\n` +\n      `For static sites, ensure index.html exists at the project root.`\n    );\n  }\n\n  private detectPackageManager(): PackageManager {\n    if (fs.existsSync(path.join(this.projectPath, 'pnpm-lock.yaml'))) {\n      return 'pnpm';\n    }\n\n    if (fs.existsSync(path.join(this.projectPath, 'yarn.lock'))) {\n      return 'yarn';\n    }\n\n    if (fs.existsSync(path.join(this.projectPath, 'package-lock.json'))) {\n      return 'npm';\n    }\n\n    // No lock file found\n    return 'npm';\n  }\n\n  private getBuildOutputDir(type: ProjectType): string {\n    switch (type) {\n      case 'react':\n        if (fs.existsSync(path.join(this.projectPath, 'vite.config.ts')) ||\n            fs.existsSync(path.join(this.projectPath, 'vite.config.js'))) {\n          return 'dist';\n        }\n        return 'build';\n\n      case 'next':\n        return '.next';\n\n      case 'node':\n        return '.';\n\n      case 'static':\n        return '.';\n    }\n  }\n\n  validateBuildOutput(): boolean {\n    const hasPackageJson = fs.existsSync(path.join(this.projectPath, 'package.json'));\n    const hasIndexHtml = fs.existsSync(path.join(this.projectPath, 'index.html'));\n\n    // For static without package.json\n    if (!hasPackageJson) {\n      return hasIndexHtml;\n    }\n\n    const packageJson = this.readPackageJson();\n    const type = this.detectProjectType(packageJson, hasIndexHtml);\n    const outputDir = this.getBuildOutputDir(type);\n    const outputPath = path.join(this.projectPath, outputDir);\n\n    if (type === 'node') {\n      return fs.existsSync(path.join(this.projectPath, 'package.json'));\n    }\n\n    if (type === 'static') {\n      return fs.existsSync(path.join(this.projectPath, 'index.html'));\n    }\n\n    if (!fs.existsSync(outputPath)) {\n      return false;\n    }\n\n    if (type === 'react') {\n      return fs.existsSync(path.join(outputPath, 'index.html'));\n    }\n\n    if (type === 'next') {\n      return fs.existsSync(path.join(outputPath, 'server'));\n    }\n\n    return false;\n  }\n}\n\nexport const detectProject = async (projectPath?: string): Promise<DetectedProject> => {\n  const detector = new ProjectDetector(projectPath);\n  return detector.detect();\n};\n"]}