runway-cli 0.8.0

package/dist/commands/deploy.js

@@ -0,0 +1,334 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deployCommand = deployCommand;
+const inquirer_1 = __importDefault(require("inquirer"));
+const ora_1 = __importDefault(require("ora"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const projectDetector_1 = require("../services/projectDetector");
+const buildService_1 = require("../services/buildService");
+const packageService_1 = require("../services/packageService");
+const uploadService_1 = require("../services/uploadService");
+const config_1 = require("../utils/config");
+const logger_1 = require("../utils/logger");
+/**
+ * Parse a .env file into a Record
+ */
+function parseEnvFile(filePath) {
+    const content = fs_1.default.readFileSync(filePath, 'utf-8');
+    const vars = {};
+    for (const line of content.split('\n')) {
+        const trimmed = line.trim();
+        // Skip empty lines and comments
+        if (!trimmed || trimmed.startsWith('#'))
+            continue;
+        const eqIndex = trimmed.indexOf('=');
+        if (eqIndex > 0) {
+            const key = trimmed.slice(0, eqIndex).trim();
+            let value = trimmed.slice(eqIndex + 1).trim();
+            // Remove surrounding quotes if present
+            if ((value.startsWith('"') && value.endsWith('"')) ||
+                (value.startsWith("'") && value.endsWith("'"))) {
+                value = value.slice(1, -1);
+            }
+            vars[key] = value;
+        }
+    }
+    return vars;
+}
+/**
+ * Prompt user for manual ENV variable entry
+ */
+async function promptManualEnvVars() {
+    const vars = {};
+    logger_1.logger.dim('Enter environment variables (empty name to finish):');
+    while (true) {
+        const { key } = await inquirer_1.default.prompt([
+            {
+                type: 'input',
+                name: 'key',
+                message: 'Variable name:',
+            },
+        ]);
+        if (!key || !key.trim()) {
+            break;
+        }
+        const { value } = await inquirer_1.default.prompt([
+            {
+                type: 'input',
+                name: 'value',
+                message: `Value for ${key}:`,
+            },
+        ]);
+        vars[key.toUpperCase().replace(/[^A-Z0-9_]/g, '')] = value;
+    }
+    return vars;
+}
+async function deployCommand(options) {
+    logger_1.logger.header('Runway Deploy');
+    // Check configuration
+    if (!(0, config_1.isConfigured)()) {
+        logger_1.logger.error('CLI not configured. Run "runway init" first.');
+        return;
+    }
+    const config = (0, config_1.getConfig)();
+    logger_1.logger.dim(`Server: ${config.serverUrl}`);
+    logger_1.logger.blank();
+    // Detect project
+    const spinner = (0, ora_1.default)('Detecting project...').start();
+    let detectedProject;
+    try {
+        detectedProject = await (0, projectDetector_1.detectProject)();
+        spinner.succeed(`Detected: ${detectedProject.type} project (${detectedProject.packageManager})`);
+    }
+    catch (error) {
+        spinner.fail('Failed to detect project');
+        logger_1.logger.error(error instanceof Error ? error.message : 'Unknown error');
+        return;
+    }
+    // Determine project name
+    let projectName = options.name || detectedProject.name;
+    // Interactive mode if name not provided
+    if (!options.name) {
+        const answers = await inquirer_1.default.prompt([
+            {
+                type: 'input',
+                name: 'name',
+                message: 'Project name:',
+                default: projectName,
+                validate: (input) => {
+                    if (input.length < 2)
+                        return 'Name must be at least 2 characters';
+                    if (!/^[a-zA-Z0-9-_]+$/.test(input))
+                        return 'Name can only contain letters, numbers, hyphens, and underscores';
+                    return true;
+                },
+            },
+        ]);
+        projectName = answers.name;
+    }
+    // Determine project type
+    const projectType = options.type || detectedProject.type;
+    // Determine build mode
+    let buildMode;
+    if (options.buildServer) {
+        buildMode = 'server';
+    }
+    else if (options.buildLocal) {
+        buildMode = 'local';
+    }
+    else {
+        buildMode = config.defaultBuildMode || 'local';
+    }
+    logger_1.logger.blank();
+    logger_1.logger.info(`Project: ${projectName}`);
+    logger_1.logger.info(`Type: ${projectType}`);
+    logger_1.logger.info(`Build mode: ${buildMode}`);
+    if (options.version) {
+        logger_1.logger.info(`Version: ${options.version}`);
+    }
+    logger_1.logger.blank();
+    // Confirm deployment
+    const { confirm } = await inquirer_1.default.prompt([
+        {
+            type: 'confirm',
+            name: 'confirm',
+            message: 'Proceed with deployment?',
+            default: true,
+        },
+    ]);
+    if (!confirm) {
+        logger_1.logger.warn('Deployment cancelled.');
+        return;
+    }
+    logger_1.logger.blank();
+    // ENV source prompt for React/Next local builds
+    let envVars = {};
+    let envInjected = false;
+    let envFilePath = options.envFile;
+    if (buildMode === 'local' && (projectType === 'react' || projectType === 'next')) {
+        const defaultEnvPath = path_1.default.join(process.cwd(), '.env');
+        const hasEnvFile = fs_1.default.existsSync(defaultEnvPath);
+        if (!options.skipEnvPrompt && !options.envFile) {
+            const envChoices = [
+                ...(hasEnvFile ? [{ name: 'Use .env file', value: 'file' }] : []),
+                { name: 'Enter variables manually', value: 'manual' },
+                { name: 'Skip (ENV will be locked after deploy)', value: 'skip' },
+            ];
+            const { envSource } = await inquirer_1.default.prompt([
+                {
+                    type: 'list',
+                    name: 'envSource',
+                    message: 'Environment variables for build:',
+                    choices: envChoices,
+                    default: hasEnvFile ? 'file' : 'skip',
+                },
+            ]);
+            if (envSource === 'file') {
+                envFilePath = defaultEnvPath;
+                envVars = parseEnvFile(defaultEnvPath);
+                envInjected = Object.keys(envVars).length > 0;
+                logger_1.logger.success(`Loaded ${Object.keys(envVars).length} variables from .env`);
+            }
+            else if (envSource === 'manual') {
+                envVars = await promptManualEnvVars();
+                envInjected = Object.keys(envVars).length > 0;
+                if (envInjected) {
+                    logger_1.logger.success(`Added ${Object.keys(envVars).length} environment variables`);
+                }
+            }
+            else {
+                logger_1.logger.warn('Skipping ENV injection - environment variables will be locked after deployment.');
+            }
+        }
+        else if (options.envFile && fs_1.default.existsSync(options.envFile)) {
+            envVars = parseEnvFile(options.envFile);
+            envInjected = Object.keys(envVars).length > 0;
+            logger_1.logger.success(`Loaded ${Object.keys(envVars).length} variables from ${options.envFile}`);
+        }
+        logger_1.logger.blank();
+    }
+    // Step 1: Build (for local-build mode)
+    let buildOutputDir = detectedProject.buildOutputDir;
+    if (buildMode === 'local') {
+        logger_1.logger.step(1, 4, 'Building project...');
+        const buildResult = await buildService_1.buildService.build({
+            projectPath: process.cwd(),
+            projectType,
+            projectName,
+            packageManager: detectedProject.packageManager,
+            envFile: envFilePath,
+        });
+        if (!buildResult.success) {
+            logger_1.logger.error(`Build failed: ${buildResult.error}`);
+            return;
+        }
+        buildOutputDir = buildResult.outputDir;
+        logger_1.logger.success(`Build completed in ${(buildResult.duration / 1000).toFixed(1)}s`);
+        logger_1.logger.blank();
+    }
+    // Step 2: Package
+    const packageStep = buildMode === 'local' ? 2 : 1;
+    const totalSteps = buildMode === 'local' ? 4 : 3;
+    logger_1.logger.step(packageStep, totalSteps, 'Creating deployment package...');
+    let packageResult;
+    try {
+        packageResult = await packageService_1.packageService.package({
+            projectPath: process.cwd(),
+            projectType,
+            buildOutputDir,
+            includeSource: buildMode === 'server',
+        });
+    }
+    catch (error) {
+        logger_1.logger.error(`Packaging failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        return;
+    }
+    logger_1.logger.blank();
+    // Step 3: Analyze & Upload
+    logger_1.logger.step(packageStep + 1, totalSteps, 'Analyzing and uploading to server...');
+    let uploadService;
+    try {
+        uploadService = (0, uploadService_1.createUploadService)();
+    }
+    catch (error) {
+        logger_1.logger.error(error instanceof Error ? error.message : 'Unknown error');
+        packageService_1.packageService.cleanup(packageResult.zipPath);
+        return;
+    }
+    // Analyze package first (for server-build mode to get warnings)
+    let confirmServerBuild = false;
+    if (buildMode === 'server') {
+        const analyzeResult = await uploadService.analyzePackage(packageResult.zipPath, projectType);
+        if (analyzeResult.success && analyzeResult.analysis) {
+            const analysis = analyzeResult.analysis;
+            // Display warnings
+            if (analysis.warnings && analysis.warnings.length > 0) {
+                logger_1.logger.blank();
+                logger_1.logger.warn('Server Analysis:');
+                for (const warning of analysis.warnings) {
+                    const prefix = warning.level === 'critical' ? '❌' : warning.level === 'warning' ? '⚠️' : 'ℹ️';
+                    logger_1.logger.dim(`  ${prefix} ${warning.message}`);
+                }
+                logger_1.logger.blank();
+            }
+            // Handle confirmation for server-side build
+            if (analysis.requiresConfirmation) {
+                const { confirmBuild } = await inquirer_1.default.prompt([
+                    {
+                        type: 'confirm',
+                        name: 'confirmBuild',
+                        message: `${analysis.confirmationReason || 'Server-side build required'}. This may consume significant resources. Continue?`,
+                        default: true,
+                    },
+                ]);
+                if (!confirmBuild) {
+                    logger_1.logger.warn('Deployment cancelled by user.');
+                    packageService_1.packageService.cleanup(packageResult.zipPath);
+                    return;
+                }
+                confirmServerBuild = true;
+            }
+        }
+    }
+    const uploadResult = await uploadService.upload({
+        zipPath: packageResult.zipPath,
+        projectName,
+        projectType,
+        version: options.version,
+        buildMode,
+        confirmServerBuild,
+        // ENV mutability tracking
+        deploymentSource: 'cli',
+        envInjected,
+    });
+    // Cleanup zip file
+    packageService_1.packageService.cleanup(packageResult.zipPath);
+    if (!uploadResult.success) {
+        logger_1.logger.error(`Upload failed: ${uploadResult.error}`);
+        return;
+    }
+    logger_1.logger.success('Upload complete');
+    logger_1.logger.blank();
+    // Step 4: Wait for deployment (if deployment ID available)
+    if (uploadResult.deploymentId) {
+        logger_1.logger.step(packageStep + 2, totalSteps, 'Waiting for deployment to complete...');
+        try {
+            const finalStatus = await uploadService.pollDeploymentStatus(uploadResult.deploymentId, (status) => {
+                if (status.progress !== undefined) {
+                    process.stdout.write(`\r  Progress: ${status.progress}%`);
+                }
+            });
+            process.stdout.write('\n');
+            if (finalStatus.status === 'success') {
+                logger_1.logger.blank();
+                logger_1.logger.success('Deployment successful!');
+                const safeName = projectName.toLowerCase().replace(/[^a-z0-9]/g, '-');
+                logger_1.logger.blank();
+                logger_1.logger.info(`Your app is available at: ${config.serverUrl}/app/${safeName}`);
+            }
+            else {
+                logger_1.logger.error(`Deployment failed: ${finalStatus.error || 'Unknown error'}`);
+                if (finalStatus.logs) {
+                    logger_1.logger.blank();
+                    logger_1.logger.dim('Logs:');
+                    console.log(finalStatus.logs);
+                }
+            }
+        }
+        catch (error) {
+            logger_1.logger.warn('Could not track deployment status');
+            logger_1.logger.dim('Check the web UI for deployment status');
+        }
+    }
+    else {
+        logger_1.logger.blank();
+        logger_1.logger.success('Upload successful!');
+        logger_1.logger.dim('Deployment is being processed. Check the web UI for status.');
+    }
+    logger_1.logger.blank();
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"deploy.js","sourceRoot":"","sources":["../../src/commands/deploy.ts"],"names":[],"mappings":"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","sourcesContent":["import inquirer from 'inquirer';\nimport ora from 'ora';\nimport fs from 'fs';\nimport path from 'path';\nimport { ProjectType, BuildMode } from '../types';\nimport { detectProject } from '../services/projectDetector';\nimport { buildService } from '../services/buildService';\nimport { packageService } from '../services/packageService';\nimport { createUploadService } from '../services/uploadService';\nimport { isConfigured, getConfig } from '../utils/config';\nimport { logger } from '../utils/logger';\n\ninterface DeployOptions {\n  name?: string;\n  type?: ProjectType;\n  version?: string;\n  buildLocal?: boolean;\n  buildServer?: boolean;\n  envFile?: string;\n  skipEnvPrompt?: boolean;\n}\n\n/**\n * Parse a .env file into a Record\n */\nfunction parseEnvFile(filePath: string): Record<string, string> {\n  const content = fs.readFileSync(filePath, 'utf-8');\n  const vars: Record<string, string> = {};\n\n  for (const line of content.split('\\n')) {\n    const trimmed = line.trim();\n    // Skip empty lines and comments\n    if (!trimmed || trimmed.startsWith('#')) continue;\n\n    const eqIndex = trimmed.indexOf('=');\n    if (eqIndex > 0) {\n      const key = trimmed.slice(0, eqIndex).trim();\n      let value = trimmed.slice(eqIndex + 1).trim();\n      // Remove surrounding quotes if present\n      if ((value.startsWith('\"') && value.endsWith('\"')) ||\n          (value.startsWith(\"'\") && value.endsWith(\"'\"))) {\n        value = value.slice(1, -1);\n      }\n      vars[key] = value;\n    }\n  }\n\n  return vars;\n}\n\n/**\n * Prompt user for manual ENV variable entry\n */\nasync function promptManualEnvVars(): Promise<Record<string, string>> {\n  const vars: Record<string, string> = {};\n\n  logger.dim('Enter environment variables (empty name to finish):');\n\n  while (true) {\n    const { key } = await inquirer.prompt([\n      {\n        type: 'input',\n        name: 'key',\n        message: 'Variable name:',\n      },\n    ]);\n\n    if (!key || !key.trim()) {\n      break;\n    }\n\n    const { value } = await inquirer.prompt([\n      {\n        type: 'input',\n        name: 'value',\n        message: `Value for ${key}:`,\n      },\n    ]);\n\n    vars[key.toUpperCase().replace(/[^A-Z0-9_]/g, '')] = value;\n  }\n\n  return vars;\n}\n\nexport async function deployCommand(options: DeployOptions): Promise<void> {\n  logger.header('Runway Deploy');\n\n  // Check configuration\n  if (!isConfigured()) {\n    logger.error('CLI not configured. Run \"runway init\" first.');\n    return;\n  }\n\n  const config = getConfig();\n  logger.dim(`Server: ${config.serverUrl}`);\n  logger.blank();\n\n  // Detect project\n  const spinner = ora('Detecting project...').start();\n  let detectedProject;\n\n  try {\n    detectedProject = await detectProject();\n    spinner.succeed(`Detected: ${detectedProject.type} project (${detectedProject.packageManager})`);\n  } catch (error) {\n    spinner.fail('Failed to detect project');\n    logger.error(error instanceof Error ? error.message : 'Unknown error');\n    return;\n  }\n\n  // Determine project name\n  let projectName = options.name || detectedProject.name;\n\n  // Interactive mode if name not provided\n  if (!options.name) {\n    const answers = await inquirer.prompt([\n      {\n        type: 'input',\n        name: 'name',\n        message: 'Project name:',\n        default: projectName,\n        validate: (input: string) => {\n          if (input.length < 2) return 'Name must be at least 2 characters';\n          if (!/^[a-zA-Z0-9-_]+$/.test(input)) return 'Name can only contain letters, numbers, hyphens, and underscores';\n          return true;\n        },\n      },\n    ]);\n    projectName = answers.name;\n  }\n\n  // Determine project type\n  const projectType = options.type || detectedProject.type;\n\n  // Determine build mode\n  let buildMode: BuildMode;\n  if (options.buildServer) {\n    buildMode = 'server';\n  } else if (options.buildLocal) {\n    buildMode = 'local';\n  } else {\n    buildMode = config.defaultBuildMode || 'local';\n  }\n\n  logger.blank();\n  logger.info(`Project: ${projectName}`);\n  logger.info(`Type: ${projectType}`);\n  logger.info(`Build mode: ${buildMode}`);\n  if (options.version) {\n    logger.info(`Version: ${options.version}`);\n  }\n  logger.blank();\n\n  // Confirm deployment\n  const { confirm } = await inquirer.prompt([\n    {\n      type: 'confirm',\n      name: 'confirm',\n      message: 'Proceed with deployment?',\n      default: true,\n    },\n  ]);\n\n  if (!confirm) {\n    logger.warn('Deployment cancelled.');\n    return;\n  }\n\n  logger.blank();\n\n  // ENV source prompt for React/Next local builds\n  let envVars: Record<string, string> = {};\n  let envInjected = false;\n  let envFilePath = options.envFile;\n\n  if (buildMode === 'local' && (projectType === 'react' || projectType === 'next')) {\n    const defaultEnvPath = path.join(process.cwd(), '.env');\n    const hasEnvFile = fs.existsSync(defaultEnvPath);\n\n    if (!options.skipEnvPrompt && !options.envFile) {\n      const envChoices = [\n        ...(hasEnvFile ? [{ name: 'Use .env file', value: 'file' }] : []),\n        { name: 'Enter variables manually', value: 'manual' },\n        { name: 'Skip (ENV will be locked after deploy)', value: 'skip' },\n      ];\n\n      const { envSource } = await inquirer.prompt([\n        {\n          type: 'list',\n          name: 'envSource',\n          message: 'Environment variables for build:',\n          choices: envChoices,\n          default: hasEnvFile ? 'file' : 'skip',\n        },\n      ]);\n\n      if (envSource === 'file') {\n        envFilePath = defaultEnvPath;\n        envVars = parseEnvFile(defaultEnvPath);\n        envInjected = Object.keys(envVars).length > 0;\n        logger.success(`Loaded ${Object.keys(envVars).length} variables from .env`);\n      } else if (envSource === 'manual') {\n        envVars = await promptManualEnvVars();\n        envInjected = Object.keys(envVars).length > 0;\n        if (envInjected) {\n          logger.success(`Added ${Object.keys(envVars).length} environment variables`);\n        }\n      } else {\n        logger.warn('Skipping ENV injection - environment variables will be locked after deployment.');\n      }\n    } else if (options.envFile && fs.existsSync(options.envFile)) {\n      envVars = parseEnvFile(options.envFile);\n      envInjected = Object.keys(envVars).length > 0;\n      logger.success(`Loaded ${Object.keys(envVars).length} variables from ${options.envFile}`);\n    }\n\n    logger.blank();\n  }\n\n  // Step 1: Build (for local-build mode)\n  let buildOutputDir = detectedProject.buildOutputDir;\n\n  if (buildMode === 'local') {\n    logger.step(1, 4, 'Building project...');\n\n    const buildResult = await buildService.build({\n      projectPath: process.cwd(),\n      projectType,\n      projectName,\n      packageManager: detectedProject.packageManager,\n      envFile: envFilePath,\n    });\n\n    if (!buildResult.success) {\n      logger.error(`Build failed: ${buildResult.error}`);\n      return;\n    }\n\n    buildOutputDir = buildResult.outputDir;\n    logger.success(`Build completed in ${(buildResult.duration / 1000).toFixed(1)}s`);\n    logger.blank();\n  }\n\n  // Step 2: Package\n  const packageStep = buildMode === 'local' ? 2 : 1;\n  const totalSteps = buildMode === 'local' ? 4 : 3;\n\n  logger.step(packageStep, totalSteps, 'Creating deployment package...');\n\n  let packageResult;\n  try {\n    packageResult = await packageService.package({\n      projectPath: process.cwd(),\n      projectType,\n      buildOutputDir,\n      includeSource: buildMode === 'server',\n    });\n  } catch (error) {\n    logger.error(`Packaging failed: ${error instanceof Error ? error.message : 'Unknown error'}`);\n    return;\n  }\n\n  logger.blank();\n\n  // Step 3: Analyze & Upload\n  logger.step(packageStep + 1, totalSteps, 'Analyzing and uploading to server...');\n\n  let uploadService;\n  try {\n    uploadService = createUploadService();\n  } catch (error) {\n    logger.error(error instanceof Error ? error.message : 'Unknown error');\n    packageService.cleanup(packageResult.zipPath);\n    return;\n  }\n\n  // Analyze package first (for server-build mode to get warnings)\n  let confirmServerBuild = false;\n  if (buildMode === 'server') {\n    const analyzeResult = await uploadService.analyzePackage(packageResult.zipPath, projectType);\n\n    if (analyzeResult.success && analyzeResult.analysis) {\n      const analysis = analyzeResult.analysis;\n\n      // Display warnings\n      if (analysis.warnings && analysis.warnings.length > 0) {\n        logger.blank();\n        logger.warn('Server Analysis:');\n        for (const warning of analysis.warnings) {\n          const prefix = warning.level === 'critical' ? '❌' : warning.level === 'warning' ? '⚠️' : 'ℹ️';\n          logger.dim(`  ${prefix} ${warning.message}`);\n        }\n        logger.blank();\n      }\n\n      // Handle confirmation for server-side build\n      if (analysis.requiresConfirmation) {\n        const { confirmBuild } = await inquirer.prompt([\n          {\n            type: 'confirm',\n            name: 'confirmBuild',\n            message: `${analysis.confirmationReason || 'Server-side build required'}. This may consume significant resources. Continue?`,\n            default: true,\n          },\n        ]);\n\n        if (!confirmBuild) {\n          logger.warn('Deployment cancelled by user.');\n          packageService.cleanup(packageResult.zipPath);\n          return;\n        }\n        confirmServerBuild = true;\n      }\n    }\n  }\n\n  const uploadResult = await uploadService.upload({\n    zipPath: packageResult.zipPath,\n    projectName,\n    projectType,\n    version: options.version,\n    buildMode,\n    confirmServerBuild,\n    // ENV mutability tracking\n    deploymentSource: 'cli',\n    envInjected,\n  });\n\n  // Cleanup zip file\n  packageService.cleanup(packageResult.zipPath);\n\n  if (!uploadResult.success) {\n    logger.error(`Upload failed: ${uploadResult.error}`);\n    return;\n  }\n\n  logger.success('Upload complete');\n  logger.blank();\n\n  // Step 4: Wait for deployment (if deployment ID available)\n  if (uploadResult.deploymentId) {\n    logger.step(packageStep + 2, totalSteps, 'Waiting for deployment to complete...');\n\n    try {\n      const finalStatus = await uploadService.pollDeploymentStatus(\n        uploadResult.deploymentId,\n        (status) => {\n          if (status.progress !== undefined) {\n            process.stdout.write(`\\r  Progress: ${status.progress}%`);\n          }\n        }\n      );\n\n      process.stdout.write('\\n');\n\n      if (finalStatus.status === 'success') {\n        logger.blank();\n        logger.success('Deployment successful!');\n\n        const safeName = projectName.toLowerCase().replace(/[^a-z0-9]/g, '-');\n        logger.blank();\n        logger.info(`Your app is available at: ${config.serverUrl}/app/${safeName}`);\n      } else {\n        logger.error(`Deployment failed: ${finalStatus.error || 'Unknown error'}`);\n        if (finalStatus.logs) {\n          logger.blank();\n          logger.dim('Logs:');\n          console.log(finalStatus.logs);\n        }\n      }\n    } catch (error) {\n      logger.warn('Could not track deployment status');\n      logger.dim('Check the web UI for deployment status');\n    }\n  } else {\n    logger.blank();\n    logger.success('Upload successful!');\n    logger.dim('Deployment is being processed. Check the web UI for status.');\n  }\n\n  logger.blank();\n}\n"]}

package/dist/commands/init.d.ts

@@ -0,0 +1,5 @@
+interface InitOptions {
+    server?: string;
+}
+export declare function initCommand(options: InitOptions): Promise<void>;
+export {};

package/dist/commands/init.js

@@ -0,0 +1,196 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initCommand = initCommand;
+const inquirer_1 = __importDefault(require("inquirer"));
+const axios_1 = __importDefault(require("axios"));
+const config_1 = require("../utils/config");
+const logger_1 = require("../utils/logger");
+const authService_1 = require("../services/authService");
+async function initCommand(options) {
+    logger_1.logger.header('Runway CLI Setup');
+    // Check if already configured
+    if ((0, config_1.isConfigured)()) {
+        const config = (0, config_1.getConfig)();
+        logger_1.logger.info(`Currently configured to: ${config.serverUrl}`);
+        if (config.securityMode) {
+            logger_1.logger.dim(`Security mode: ${config.securityMode === 'domain-https' ? 'HTTPS (secure)' : 'HTTP (limited)'}`);
+        }
+        const { reconfigure } = await inquirer_1.default.prompt([
+            {
+                type: 'confirm',
+                name: 'reconfigure',
+                message: 'Do you want to reconfigure?',
+                default: false,
+            },
+        ]);
+        if (!reconfigure) {
+            logger_1.logger.info('Configuration unchanged.');
+            return;
+        }
+    }
+    // Get server URL
+    let serverUrl = options.server;
+    if (!serverUrl) {
+        const answers = await inquirer_1.default.prompt([
+            {
+                type: 'input',
+                name: 'serverUrl',
+                message: 'Enter your Runway server URL:',
+                default: 'https://deploy.example.com',
+                validate: (input) => {
+                    try {
+                        new URL(input);
+                        return true;
+                    }
+                    catch {
+                        return 'Please enter a valid URL';
+                    }
+                },
+            },
+        ]);
+        serverUrl = answers.serverUrl;
+    }
+    // Normalize URL
+    serverUrl = serverUrl.replace(/\/+$/, '');
+    // Test connection
+    logger_1.logger.info('Testing connection...');
+    try {
+        await axios_1.default.get(`${serverUrl}/health`, { timeout: 10000 });
+        logger_1.logger.success('Server is reachable');
+    }
+    catch (error) {
+        logger_1.logger.error(`Cannot reach server at ${serverUrl}`);
+        logger_1.logger.dim('Make sure the server is running and the URL is correct.');
+        return;
+    }
+    // Initialize auth service
+    const authService = new authService_1.AuthService(serverUrl);
+    // Check security mode
+    logger_1.logger.info('Checking server security mode...');
+    let securityInfo;
+    try {
+        securityInfo = await authService.getSecurityMode();
+    }
+    catch (error) {
+        logger_1.logger.error('Failed to get server security mode');
+        logger_1.logger.dim('The server may be running an older version without CLI auth support.');
+        logger_1.logger.dim('Falling back to legacy authentication...');
+        await legacyAuth(serverUrl);
+        return;
+    }
+    // Display security info
+    if (securityInfo.securityMode === 'domain-https') {
+        logger_1.logger.success(`Server has HTTPS enabled: ${securityInfo.domain}`);
+        logger_1.logger.dim('Authentication will use secure TLS connection.');
+    }
+    else {
+        logger_1.logger.warn('Server is running in HTTP mode (no domain configured)');
+        logger_1.logger.dim('Authentication will use RSA key exchange (MITM vulnerable).');
+        logger_1.logger.blank();
+        const { proceed } = await inquirer_1.default.prompt([
+            {
+                type: 'confirm',
+                name: 'proceed',
+                message: 'Continue with RSA authentication?',
+                default: true,
+            },
+        ]);
+        if (!proceed) {
+            logger_1.logger.blank();
+            logger_1.logger.info('To enable secure authentication:');
+            logger_1.logger.dim('  1. Configure a domain on your Runway server');
+            logger_1.logger.dim('  2. Enable HTTPS through the Settings page');
+            logger_1.logger.dim('  3. Run `runway init` again');
+            return;
+        }
+    }
+    // Get credentials
+    logger_1.logger.blank();
+    const credentials = await inquirer_1.default.prompt([
+        {
+            type: 'input',
+            name: 'username',
+            message: 'Username:',
+            validate: (input) => input.length > 0 || 'Username is required',
+        },
+        {
+            type: 'password',
+            name: 'password',
+            message: 'Password:',
+            validate: (input) => input.length > 0 || 'Password is required',
+        },
+    ]);
+    // Authenticate using the auth service
+    logger_1.logger.info('Authenticating...');
+    try {
+        const authResult = await authService.authenticate(credentials.username, credentials.password);
+        // Save configuration with all auth data
+        (0, config_1.setServerUrl)(serverUrl);
+        (0, config_1.setAuthData)(authResult.token, authResult.expiresAt, authResult.securityMode);
+        logger_1.logger.blank();
+        logger_1.logger.success('Configuration saved successfully!');
+        logger_1.logger.blank();
+        logger_1.logger.info('You can now deploy projects with:');
+        logger_1.logger.dim('  runway deploy');
+        logger_1.logger.blank();
+        // Show token expiry warning for HTTP mode
+        if (authResult.securityMode === 'ip-http') {
+            logger_1.logger.warn('Note: Token expires in 15 minutes due to HTTP mode.');
+            logger_1.logger.dim('Run `runway init` to re-authenticate when needed.');
+        }
+    }
+    catch (error) {
+        // Error already logged by AuthService
+        logger_1.logger.blank();
+        logger_1.logger.dim('Check your credentials and try again.');
+    }
+}
+/**
+ * Legacy authentication for servers without CLI auth support
+ */
+async function legacyAuth(serverUrl) {
+    const credentials = await inquirer_1.default.prompt([
+        {
+            type: 'input',
+            name: 'username',
+            message: 'Username:',
+            validate: (input) => input.length > 0 || 'Username is required',
+        },
+        {
+            type: 'password',
+            name: 'password',
+            message: 'Password:',
+            validate: (input) => input.length > 0 || 'Password is required',
+        },
+    ]);
+    logger_1.logger.info('Authenticating...');
+    try {
+        const response = await axios_1.default.post(`${serverUrl}/api/auth/login`, credentials, { timeout: 10000 });
+        if (response.data.success && response.data?.token) {
+            // Save configuration (legacy mode without expiry tracking)
+            (0, config_1.setServerUrl)(serverUrl);
+            (0, config_1.setAuthData)(response.data.token, '', 'ip-http');
+            logger_1.logger.blank();
+            logger_1.logger.success('Configuration saved successfully!');
+            logger_1.logger.blank();
+            logger_1.logger.info('You can now deploy projects with:');
+            logger_1.logger.dim('  runway deploy');
+            logger_1.logger.blank();
+        }
+        else {
+            logger_1.logger.error('Authentication failed: ' + (response.data.error || 'Unknown error'));
+        }
+    }
+    catch (error) {
+        if (axios_1.default.isAxiosError(error)) {
+            logger_1.logger.error('Authentication failed: ' + (error.response?.data?.error || error.message));
+        }
+        else {
+            logger_1.logger.error('Authentication failed: ' + (error instanceof Error ? error.message : 'Unknown error'));
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"init.js","sourceRoot":"","sources":["../../src/commands/init.ts"],"names":[],"mappings":"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","sourcesContent":["import inquirer from 'inquirer';\nimport axios from 'axios';\nimport { setServerUrl, setAuthData, getConfig, isConfigured } from '../utils/config';\nimport { logger } from '../utils/logger';\nimport { AuthService } from '../services/authService';\n\ninterface InitOptions {\n  server?: string;\n}\n\nexport async function initCommand(options: InitOptions): Promise<void> {\n  logger.header('Runway CLI Setup');\n\n  // Check if already configured\n  if (isConfigured()) {\n    const config = getConfig();\n    logger.info(`Currently configured to: ${config.serverUrl}`);\n    if (config.securityMode) {\n      logger.dim(`Security mode: ${config.securityMode === 'domain-https' ? 'HTTPS (secure)' : 'HTTP (limited)'}`);\n    }\n\n    const { reconfigure } = await inquirer.prompt([\n      {\n        type: 'confirm',\n        name: 'reconfigure',\n        message: 'Do you want to reconfigure?',\n        default: false,\n      },\n    ]);\n\n    if (!reconfigure) {\n      logger.info('Configuration unchanged.');\n      return;\n    }\n  }\n\n  // Get server URL\n  let serverUrl = options.server;\n\n  if (!serverUrl) {\n    const answers = await inquirer.prompt([\n      {\n        type: 'input',\n        name: 'serverUrl',\n        message: 'Enter your Runway server URL:',\n        default: 'https://deploy.example.com',\n        validate: (input: string) => {\n          try {\n            new URL(input);\n            return true;\n          } catch {\n            return 'Please enter a valid URL';\n          }\n        },\n      },\n    ]);\n    serverUrl = answers.serverUrl as string;\n  }\n\n  // Normalize URL\n  serverUrl = serverUrl!.replace(/\\/+$/, '');\n\n  // Test connection\n  logger.info('Testing connection...');\n  try {\n    await axios.get(`${serverUrl}/health`, { timeout: 10000 });\n    logger.success('Server is reachable');\n  } catch (error) {\n    logger.error(`Cannot reach server at ${serverUrl}`);\n    logger.dim('Make sure the server is running and the URL is correct.');\n    return;\n  }\n\n  // Initialize auth service\n  const authService = new AuthService(serverUrl);\n\n  // Check security mode\n  logger.info('Checking server security mode...');\n  let securityInfo;\n  try {\n    securityInfo = await authService.getSecurityMode();\n  } catch (error) {\n    logger.error('Failed to get server security mode');\n    logger.dim('The server may be running an older version without CLI auth support.');\n    logger.dim('Falling back to legacy authentication...');\n    await legacyAuth(serverUrl);\n    return;\n  }\n\n  // Display security info\n  if (securityInfo.securityMode === 'domain-https') {\n    logger.success(`Server has HTTPS enabled: ${securityInfo.domain}`);\n    logger.dim('Authentication will use secure TLS connection.');\n  } else {\n    logger.warn('Server is running in HTTP mode (no domain configured)');\n    logger.dim('Authentication will use RSA key exchange (MITM vulnerable).');\n    logger.blank();\n\n    const { proceed } = await inquirer.prompt([\n      {\n        type: 'confirm',\n        name: 'proceed',\n        message: 'Continue with RSA authentication?',\n        default: true,\n      },\n    ]);\n\n    if (!proceed) {\n      logger.blank();\n      logger.info('To enable secure authentication:');\n      logger.dim('  1. Configure a domain on your Runway server');\n      logger.dim('  2. Enable HTTPS through the Settings page');\n      logger.dim('  3. Run `runway init` again');\n      return;\n    }\n  }\n\n  // Get credentials\n  logger.blank();\n  const credentials = await inquirer.prompt([\n    {\n      type: 'input',\n      name: 'username',\n      message: 'Username:',\n      validate: (input: string) => input.length > 0 || 'Username is required',\n    },\n    {\n      type: 'password',\n      name: 'password',\n      message: 'Password:',\n      validate: (input: string) => input.length > 0 || 'Password is required',\n    },\n  ]);\n\n  // Authenticate using the auth service\n  logger.info('Authenticating...');\n  try {\n    const authResult = await authService.authenticate(\n      credentials.username,\n      credentials.password\n    );\n\n    // Save configuration with all auth data\n    setServerUrl(serverUrl);\n    setAuthData(authResult.token, authResult.expiresAt, authResult.securityMode);\n\n    logger.blank();\n    logger.success('Configuration saved successfully!');\n    logger.blank();\n    logger.info('You can now deploy projects with:');\n    logger.dim('  runway deploy');\n    logger.blank();\n\n    // Show token expiry warning for HTTP mode\n    if (authResult.securityMode === 'ip-http') {\n      logger.warn('Note: Token expires in 15 minutes due to HTTP mode.');\n      logger.dim('Run `runway init` to re-authenticate when needed.');\n    }\n  } catch (error) {\n    // Error already logged by AuthService\n    logger.blank();\n    logger.dim('Check your credentials and try again.');\n  }\n}\n\n/**\n * Legacy authentication for servers without CLI auth support\n */\nasync function legacyAuth(serverUrl: string): Promise<void> {\n  const credentials = await inquirer.prompt([\n    {\n      type: 'input',\n      name: 'username',\n      message: 'Username:',\n      validate: (input: string) => input.length > 0 || 'Username is required',\n    },\n    {\n      type: 'password',\n      name: 'password',\n      message: 'Password:',\n      validate: (input: string) => input.length > 0 || 'Password is required',\n    },\n  ]);\n\n  logger.info('Authenticating...');\n  try {\n    const response = await axios.post(\n      `${serverUrl}/api/auth/login`,\n      credentials,\n      { timeout: 10000 }\n    );\n\n    if (response.data.success && response.data?.token) {\n      // Save configuration (legacy mode without expiry tracking)\n      setServerUrl(serverUrl);\n      setAuthData(response.data.token, '', 'ip-http');\n\n      logger.blank();\n      logger.success('Configuration saved successfully!');\n      logger.blank();\n      logger.info('You can now deploy projects with:');\n      logger.dim('  runway deploy');\n      logger.blank();\n    } else {\n      logger.error('Authentication failed: ' + (response.data.error || 'Unknown error'));\n    }\n  } catch (error) {\n    if (axios.isAxiosError(error)) {\n      logger.error('Authentication failed: ' + (error.response?.data?.error || error.message));\n    } else {\n      logger.error('Authentication failed: ' + (error instanceof Error ? error.message : 'Unknown error'));\n    }\n  }\n}\n"]}

package/dist/commands/list.d.ts

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