runway-cli 0.8.0

package/dist/commands/list.js

@@ -0,0 +1,84 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listCommand = listCommand;
+const ora_1 = __importDefault(require("ora"));
+const chalk_1 = __importDefault(require("chalk"));
+const uploadService_1 = require("../services/uploadService");
+const config_1 = require("../utils/config");
+const logger_1 = require("../utils/logger");
+async function listCommand() {
+    // 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();
+    const spinner = (0, ora_1.default)('Fetching projects...').start();
+    try {
+        const uploadService = (0, uploadService_1.createUploadService)();
+        const projects = await uploadService.listProjects();
+        spinner.stop();
+        if (projects.length === 0) {
+            logger_1.logger.info('No projects deployed yet.');
+            logger_1.logger.blank();
+            logger_1.logger.dim('Deploy your first project with: runway deploy');
+            return;
+        }
+        console.log('');
+        console.log(chalk_1.default.bold('  Deployed Projects:'));
+        console.log('');
+        for (const project of projects) {
+            const statusColor = getStatusColor(project.status);
+            const statusIcon = getStatusIcon(project.status);
+            console.log(`  ${statusIcon} ${chalk_1.default.bold(project.name)} ` +
+                chalk_1.default.dim(`(${project.type})`) +
+                ` - ${statusColor(project.status)}`);
+        }
+        console.log('');
+        logger_1.logger.dim(`Total: ${projects.length} project(s)`);
+    }
+    catch (error) {
+        spinner.fail('Failed to fetch projects');
+        logger_1.logger.error(error instanceof Error ? error.message : 'Unknown error');
+    }
+}
+function getStatusColor(status) {
+    switch (status) {
+        case 'running':
+        case 'online':
+            return chalk_1.default.green;
+        case 'stopped':
+            return chalk_1.default.yellow;
+        case 'failed':
+        case 'error':
+            return chalk_1.default.red;
+        case 'building':
+        case 'deploying':
+            return chalk_1.default.blue;
+        default:
+            return chalk_1.default.gray;
+    }
+}
+function getStatusIcon(status) {
+    switch (status) {
+        case 'running':
+        case 'online':
+            return chalk_1.default.green('●');
+        case 'stopped':
+            return chalk_1.default.yellow('○');
+        case 'failed':
+        case 'error':
+            return chalk_1.default.red('●');
+        case 'building':
+        case 'deploying':
+            return chalk_1.default.blue('◐');
+        default:
+            return chalk_1.default.gray('○');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/status.d.ts

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

package/dist/commands/status.js

@@ -0,0 +1,117 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.statusCommand = statusCommand;
+const ora_1 = __importDefault(require("ora"));
+const chalk_1 = __importDefault(require("chalk"));
+const axios_1 = __importDefault(require("axios"));
+const config_1 = require("../utils/config");
+const logger_1 = require("../utils/logger");
+async function statusCommand(projectName) {
+    if (!projectName) {
+        logger_1.logger.error('Project name is required');
+        logger_1.logger.dim('Usage: runway status <project-name>');
+        return;
+    }
+    // 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)();
+    const spinner = (0, ora_1.default)(`Fetching status for ${projectName}...`).start();
+    try {
+        // First, get the list of projects to find the one we want
+        const response = await axios_1.default.get(`${config.serverUrl}/api/project`, {
+            headers: {
+                Authorization: `Bearer ${config.token}`,
+            },
+        });
+        const projects = response.data.data || [];
+        const project = projects.find((p) => p.name.toLowerCase() === projectName.toLowerCase());
+        spinner.stop();
+        if (!project) {
+            logger_1.logger.error(`Project "${projectName}" not found`);
+            logger_1.logger.blank();
+            logger_1.logger.dim('Available projects:');
+            for (const p of projects) {
+                logger_1.logger.dim(`  - ${p.name}`);
+            }
+            return;
+        }
+        // Display project details
+        logger_1.logger.blank();
+        console.log(chalk_1.default.bold(`  ${project.name}`));
+        console.log('');
+        console.log(`  ${chalk_1.default.dim('Type:')}     ${project.type}`);
+        console.log(`  ${chalk_1.default.dim('Status:')}   ${getStatusBadge(project.status)}`);
+        if (project.port) {
+            console.log(`  ${chalk_1.default.dim('Port:')}     ${project.port}`);
+        }
+        if (project.uptime !== undefined) {
+            console.log(`  ${chalk_1.default.dim('Uptime:')}   ${formatUptime(project.uptime)}`);
+        }
+        if (project.memory !== undefined) {
+            console.log(`  ${chalk_1.default.dim('Memory:')}   ${formatBytes(project.memory)}`);
+        }
+        if (project.cpu !== undefined) {
+            console.log(`  ${chalk_1.default.dim('CPU:')}      ${project.cpu.toFixed(1)}%`);
+        }
+        const safeName = project.name.toLowerCase().replace(/[^a-z0-9]/g, '-');
+        console.log(`  ${chalk_1.default.dim('URL:')}      ${config.serverUrl}/app/${safeName}`);
+        logger_1.logger.blank();
+    }
+    catch (error) {
+        spinner.fail('Failed to fetch status');
+        if (axios_1.default.isAxiosError(error)) {
+            logger_1.logger.error(error.response?.data?.error || error.message);
+        }
+        else {
+            logger_1.logger.error(error instanceof Error ? error.message : 'Unknown error');
+        }
+    }
+}
+function getStatusBadge(status) {
+    switch (status) {
+        case 'running':
+        case 'online':
+            return chalk_1.default.black.bgGreen(` ${status.toUpperCase()} `);
+        case 'stopped':
+            return chalk_1.default.black.bgYellow(` ${status.toUpperCase()} `);
+        case 'failed':
+        case 'error':
+            return chalk_1.default.white.bgRed(` ${status.toUpperCase()} `);
+        case 'building':
+        case 'deploying':
+            return chalk_1.default.black.bgBlue(` ${status.toUpperCase()} `);
+        default:
+            return chalk_1.default.white.bgGray(` ${status.toUpperCase()} `);
+    }
+}
+function formatUptime(seconds) {
+    if (seconds < 60) {
+        return `${Math.floor(seconds)}s`;
+    }
+    if (seconds < 3600) {
+        return `${Math.floor(seconds / 60)}m`;
+    }
+    if (seconds < 86400) {
+        return `${Math.floor(seconds / 3600)}h ${Math.floor((seconds % 3600) / 60)}m`;
+    }
+    return `${Math.floor(seconds / 86400)}d ${Math.floor((seconds % 86400) / 3600)}h`;
+}
+function formatBytes(bytes) {
+    if (bytes < 1024) {
+        return `${bytes} B`;
+    }
+    if (bytes < 1024 * 1024) {
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    }
+    if (bytes < 1024 * 1024 * 1024) {
+        return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+    }
+    return `${(bytes / 1024 / 1024 / 1024).toFixed(1)} GB`;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"status.js","sourceRoot":"","sources":["../../src/commands/status.ts"],"names":[],"mappings":"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","sourcesContent":["import ora from 'ora';\nimport chalk from 'chalk';\nimport axios from 'axios';\nimport { isConfigured, getConfig } from '../utils/config';\nimport { logger } from '../utils/logger';\n\nexport async function statusCommand(projectName: string): Promise<void> {\n  if (!projectName) {\n    logger.error('Project name is required');\n    logger.dim('Usage: runway status <project-name>');\n    return;\n  }\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  const spinner = ora(`Fetching status for ${projectName}...`).start();\n\n  try {\n    // First, get the list of projects to find the one we want\n    const response = await axios.get(\n      `${config.serverUrl}/api/project`,\n      {\n        headers: {\n          Authorization: `Bearer ${config.token}`,\n        },\n      }\n    );\n\n    const projects = response.data.data || [];\n    const project = projects.find(\n      (p: { name: string }) => p.name.toLowerCase() === projectName.toLowerCase()\n    );\n\n    spinner.stop();\n\n    if (!project) {\n      logger.error(`Project \"${projectName}\" not found`);\n      logger.blank();\n      logger.dim('Available projects:');\n      for (const p of projects) {\n        logger.dim(`  - ${p.name}`);\n      }\n      return;\n    }\n\n    // Display project details\n    logger.blank();\n    console.log(chalk.bold(`  ${project.name}`));\n    console.log('');\n    console.log(`  ${chalk.dim('Type:')}     ${project.type}`);\n    console.log(`  ${chalk.dim('Status:')}   ${getStatusBadge(project.status)}`);\n\n    if (project.port) {\n      console.log(`  ${chalk.dim('Port:')}     ${project.port}`);\n    }\n\n    if (project.uptime !== undefined) {\n      console.log(`  ${chalk.dim('Uptime:')}   ${formatUptime(project.uptime)}`);\n    }\n\n    if (project.memory !== undefined) {\n      console.log(`  ${chalk.dim('Memory:')}   ${formatBytes(project.memory)}`);\n    }\n\n    if (project.cpu !== undefined) {\n      console.log(`  ${chalk.dim('CPU:')}      ${project.cpu.toFixed(1)}%`);\n    }\n\n    const safeName = project.name.toLowerCase().replace(/[^a-z0-9]/g, '-');\n    console.log(`  ${chalk.dim('URL:')}      ${config.serverUrl}/app/${safeName}`);\n\n    logger.blank();\n  } catch (error) {\n    spinner.fail('Failed to fetch status');\n    if (axios.isAxiosError(error)) {\n      logger.error(error.response?.data?.error || error.message);\n    } else {\n      logger.error(error instanceof Error ? error.message : 'Unknown error');\n    }\n  }\n}\n\nfunction getStatusBadge(status: string): string {\n  switch (status) {\n    case 'running':\n    case 'online':\n      return chalk.black.bgGreen(` ${status.toUpperCase()} `);\n    case 'stopped':\n      return chalk.black.bgYellow(` ${status.toUpperCase()} `);\n    case 'failed':\n    case 'error':\n      return chalk.white.bgRed(` ${status.toUpperCase()} `);\n    case 'building':\n    case 'deploying':\n      return chalk.black.bgBlue(` ${status.toUpperCase()} `);\n    default:\n      return chalk.white.bgGray(` ${status.toUpperCase()} `);\n  }\n}\n\nfunction formatUptime(seconds: number): string {\n  if (seconds < 60) {\n    return `${Math.floor(seconds)}s`;\n  }\n  if (seconds < 3600) {\n    return `${Math.floor(seconds / 60)}m`;\n  }\n  if (seconds < 86400) {\n    return `${Math.floor(seconds / 3600)}h ${Math.floor((seconds % 3600) / 60)}m`;\n  }\n  return `${Math.floor(seconds / 86400)}d ${Math.floor((seconds % 86400) / 3600)}h`;\n}\n\nfunction formatBytes(bytes: number): string {\n  if (bytes < 1024) {\n    return `${bytes} B`;\n  }\n  if (bytes < 1024 * 1024) {\n    return `${(bytes / 1024).toFixed(1)} KB`;\n  }\n  if (bytes < 1024 * 1024 * 1024) {\n    return `${(bytes / 1024 / 1024).toFixed(1)} MB`;\n  }\n  return `${(bytes / 1024 / 1024 / 1024).toFixed(1)} GB`;\n}\n"]}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const init_1 = require("./commands/init");
+const deploy_1 = require("./commands/deploy");
+const list_1 = require("./commands/list");
+const status_1 = require("./commands/status");
+const program = new commander_1.Command();
+program
+    .name('runway')
+    .description('CLI tool for deploying projects to Runway')
+    .version('0.0.1');
+// Init command
+program
+    .command('init')
+    .description('Configure the Runway CLI')
+    .option('-s, --server <url>', 'Server URL')
+    .action(init_1.initCommand);
+// Deploy command
+program
+    .command('deploy')
+    .description('Deploy the current project')
+    .option('-n, --name <name>', 'Project name')
+    .option('-t, --type <type>', 'Project type (react, next, node)')
+    .option('-v, --version <version>', 'Version string')
+    .option('--build-local', 'Build locally before uploading (default)')
+    .option('--build-server', 'Upload source and build on server')
+    .option('-e, --env-file <path>', 'Path to environment file')
+    .action(deploy_1.deployCommand);
+// List command
+program
+    .command('list')
+    .alias('ls')
+    .description('List deployed projects')
+    .action(list_1.listCommand);
+// Status command
+program
+    .command('status <project>')
+    .description('Get status of a deployed project')
+    .action(status_1.statusCommand);
+// Parse command line arguments
+program.parse();
+//# sourceMappingURL=data:application/json;base64,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

package/dist/services/authService.d.ts

@@ -0,0 +1,64 @@
+export type SecurityMode = 'ip-http' | 'domain-https';
+export interface SecurityModeResponse {
+    success: boolean;
+    data: {
+        securityMode: SecurityMode;
+        serverIp: string | null;
+        domain: string | null;
+        domainActive: boolean;
+        requiresRSA: boolean;
+        tokenMaxAge: number;
+        tokenType: 'pairing' | 'standard';
+    };
+}
+export interface PublicKeyResponse {
+    success: boolean;
+    data: {
+        publicKey: string;
+    };
+    warning?: string;
+}
+export interface AuthResponse {
+    success: boolean;
+    data: {
+        token: string;
+        expiresIn: number;
+        expiresAt: string;
+        tokenType: 'pairing' | 'standard';
+        securityMode: SecurityMode;
+    };
+}
+/**
+ * CLI Authentication Service
+ *
+ * Handles authentication flow for both HTTP (RSA) and HTTPS (direct) modes.
+ */
+export declare class AuthService {
+    private serverUrl;
+    constructor(serverUrl: string);
+    /**
+     * Get server security mode and connection info
+     */
+    getSecurityMode(): Promise<SecurityModeResponse['data']>;
+    /**
+     * Authenticate with the server
+     * Automatically handles RSA or direct auth based on security mode
+     */
+    authenticate(username: string, password: string): Promise<AuthResponse['data']>;
+    /**
+     * RSA-encrypted authentication (HTTP mode)
+     */
+    private authenticateWithRSA;
+    /**
+     * Direct authentication (HTTPS mode)
+     */
+    private authenticateDirect;
+    /**
+     * Refresh token (only works in HTTPS mode)
+     */
+    refreshToken(currentToken: string): Promise<AuthResponse['data'] | null>;
+    /**
+     * Handle axios errors with user-friendly messages
+     */
+    private handleError;
+}

package/dist/services/authService.js

@@ -0,0 +1,162 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthService = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const axios_1 = __importDefault(require("axios"));
+const logger_1 = require("../utils/logger");
+/**
+ * CLI Authentication Service
+ *
+ * Handles authentication flow for both HTTP (RSA) and HTTPS (direct) modes.
+ */
+class AuthService {
+    constructor(serverUrl) {
+        // Normalize URL
+        this.serverUrl = serverUrl.replace(/\/+$/, '');
+    }
+    /**
+     * Get server security mode and connection info
+     */
+    async getSecurityMode() {
+        try {
+            const response = await axios_1.default.get(`${this.serverUrl}/api/cli/security-mode`, { timeout: 10000 });
+            return response.data.data;
+        }
+        catch (error) {
+            this.handleError(error, 'Failed to get security mode');
+            throw error;
+        }
+    }
+    /**
+     * Authenticate with the server
+     * Automatically handles RSA or direct auth based on security mode
+     */
+    async authenticate(username, password) {
+        const modeInfo = await this.getSecurityMode();
+        if (modeInfo.requiresRSA) {
+            return this.authenticateWithRSA(username, password);
+        }
+        else {
+            return this.authenticateDirect(username, password);
+        }
+    }
+    /**
+     * RSA-encrypted authentication (HTTP mode)
+     */
+    async authenticateWithRSA(username, password) {
+        // Show MITM warning
+        logger_1.logger.blank();
+        logger_1.logger.warn('WARNING: Using RSA key exchange over HTTP');
+        logger_1.logger.warn('This method is vulnerable to man-in-the-middle attacks.');
+        logger_1.logger.warn('Configure a domain on your server for secure authentication.');
+        logger_1.logger.blank();
+        // Fetch public key
+        let publicKey;
+        try {
+            const keyResponse = await axios_1.default.get(`${this.serverUrl}/api/cli/public-key`, { timeout: 10000 });
+            publicKey = keyResponse.data.data.publicKey;
+        }
+        catch (error) {
+            this.handleError(error, 'Failed to fetch RSA public key');
+            throw error;
+        }
+        // Encrypt credentials
+        const credentials = JSON.stringify({ username, password });
+        let encrypted;
+        try {
+            const encryptedBuffer = crypto_1.default.publicEncrypt({
+                key: publicKey,
+                padding: crypto_1.default.constants.RSA_PKCS1_OAEP_PADDING,
+                oaepHash: 'sha256',
+            }, Buffer.from(credentials));
+            encrypted = encryptedBuffer.toString('base64');
+        }
+        catch (error) {
+            logger_1.logger.error('Failed to encrypt credentials');
+            throw new Error('Encryption failed');
+        }
+        // Send encrypted credentials
+        try {
+            const authResponse = await axios_1.default.post(`${this.serverUrl}/api/cli/auth`, { encryptedCredentials: encrypted }, { timeout: 10000 });
+            const data = authResponse.data.data;
+            logger_1.logger.info(`Token expires in ${Math.round(data.expiresIn / 60000)} minutes`);
+            logger_1.logger.warn('Short token lifetime due to HTTP mode. Re-authenticate as needed.');
+            return data;
+        }
+        catch (error) {
+            this.handleError(error, 'Authentication failed');
+            throw error;
+        }
+    }
+    /**
+     * Direct authentication (HTTPS mode)
+     */
+    async authenticateDirect(username, password) {
+        try {
+            const response = await axios_1.default.post(`${this.serverUrl}/api/cli/auth`, { username, password }, { timeout: 10000 });
+            const data = response.data.data;
+            const hours = Math.round(data.expiresIn / 3600000);
+            logger_1.logger.success(`Authenticated successfully`);
+            logger_1.logger.info(`Token expires in ${hours} hours`);
+            return data;
+        }
+        catch (error) {
+            this.handleError(error, 'Authentication failed');
+            throw error;
+        }
+    }
+    /**
+     * Refresh token (only works in HTTPS mode)
+     */
+    async refreshToken(currentToken) {
+        try {
+            const response = await axios_1.default.post(`${this.serverUrl}/api/cli/refresh`, {}, {
+                timeout: 10000,
+                headers: {
+                    Authorization: `Bearer ${currentToken}`,
+                },
+            });
+            logger_1.logger.success('Token refreshed successfully');
+            return response.data.data;
+        }
+        catch (error) {
+            if (axios_1.default.isAxiosError(error)) {
+                const status = error.response?.status;
+                if (status === 400) {
+                    // Token refresh not available (HTTP mode)
+                    logger_1.logger.warn('Token refresh not available. Please re-authenticate.');
+                    return null;
+                }
+                if (status === 401) {
+                    logger_1.logger.warn('Token expired. Please re-authenticate.');
+                    return null;
+                }
+            }
+            logger_1.logger.error('Failed to refresh token');
+            return null;
+        }
+    }
+    /**
+     * Handle axios errors with user-friendly messages
+     */
+    handleError(error, context) {
+        if (axios_1.default.isAxiosError(error)) {
+            const axiosError = error;
+            const message = axiosError.response?.data?.error ||
+                axiosError.response?.data?.message ||
+                axiosError.message;
+            logger_1.logger.error(`${context}: ${message}`);
+        }
+        else if (error instanceof Error) {
+            logger_1.logger.error(`${context}: ${error.message}`);
+        }
+        else {
+            logger_1.logger.error(`${context}: Unknown error`);
+        }
+    }
+}
+exports.AuthService = AuthService;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"authService.js","sourceRoot":"","sources":["../../src/services/authService.ts"],"names":[],"mappings":"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","sourcesContent":["import crypto from 'crypto';\nimport axios, { AxiosError } from 'axios';\nimport { logger } from '../utils/logger';\n\nexport type SecurityMode = 'ip-http' | 'domain-https';\n\nexport interface SecurityModeResponse {\n  success: boolean;\n  data: {\n    securityMode: SecurityMode;\n    serverIp: string | null;\n    domain: string | null;\n    domainActive: boolean;\n    requiresRSA: boolean;\n    tokenMaxAge: number;\n    tokenType: 'pairing' | 'standard';\n  };\n}\n\nexport interface PublicKeyResponse {\n  success: boolean;\n  data: {\n    publicKey: string;\n  };\n  warning?: string;\n}\n\nexport interface AuthResponse {\n  success: boolean;\n  data: {\n    token: string;\n    expiresIn: number;\n    expiresAt: string;\n    tokenType: 'pairing' | 'standard';\n    securityMode: SecurityMode;\n  };\n}\n\n/**\n * CLI Authentication Service\n *\n * Handles authentication flow for both HTTP (RSA) and HTTPS (direct) modes.\n */\nexport class AuthService {\n  private serverUrl: string;\n\n  constructor(serverUrl: string) {\n    // Normalize URL\n    this.serverUrl = serverUrl.replace(/\\/+$/, '');\n  }\n\n  /**\n   * Get server security mode and connection info\n   */\n  async getSecurityMode(): Promise<SecurityModeResponse['data']> {\n    try {\n      const response = await axios.get<SecurityModeResponse>(\n        `${this.serverUrl}/api/cli/security-mode`,\n        { timeout: 10000 }\n      );\n      return response.data.data;\n    } catch (error) {\n      this.handleError(error, 'Failed to get security mode');\n      throw error;\n    }\n  }\n\n  /**\n   * Authenticate with the server\n   * Automatically handles RSA or direct auth based on security mode\n   */\n  async authenticate(username: string, password: string): Promise<AuthResponse['data']> {\n    const modeInfo = await this.getSecurityMode();\n\n    if (modeInfo.requiresRSA) {\n      return this.authenticateWithRSA(username, password);\n    } else {\n      return this.authenticateDirect(username, password);\n    }\n  }\n\n  /**\n   * RSA-encrypted authentication (HTTP mode)\n   */\n  private async authenticateWithRSA(\n    username: string,\n    password: string\n  ): Promise<AuthResponse['data']> {\n    // Show MITM warning\n    logger.blank();\n    logger.warn('WARNING: Using RSA key exchange over HTTP');\n    logger.warn('This method is vulnerable to man-in-the-middle attacks.');\n    logger.warn('Configure a domain on your server for secure authentication.');\n    logger.blank();\n\n    // Fetch public key\n    let publicKey: string;\n    try {\n      const keyResponse = await axios.get<PublicKeyResponse>(\n        `${this.serverUrl}/api/cli/public-key`,\n        { timeout: 10000 }\n      );\n      publicKey = keyResponse.data.data.publicKey;\n    } catch (error) {\n      this.handleError(error, 'Failed to fetch RSA public key');\n      throw error;\n    }\n\n    // Encrypt credentials\n    const credentials = JSON.stringify({ username, password });\n    let encrypted: string;\n\n    try {\n      const encryptedBuffer = crypto.publicEncrypt(\n        {\n          key: publicKey,\n          padding: crypto.constants.RSA_PKCS1_OAEP_PADDING,\n          oaepHash: 'sha256',\n        },\n        Buffer.from(credentials)\n      );\n      encrypted = encryptedBuffer.toString('base64');\n    } catch (error) {\n      logger.error('Failed to encrypt credentials');\n      throw new Error('Encryption failed');\n    }\n\n    // Send encrypted credentials\n    try {\n      const authResponse = await axios.post<AuthResponse>(\n        `${this.serverUrl}/api/cli/auth`,\n        { encryptedCredentials: encrypted },\n        { timeout: 10000 }\n      );\n\n      const data = authResponse.data.data;\n      logger.info(`Token expires in ${Math.round(data.expiresIn / 60000)} minutes`);\n      logger.warn('Short token lifetime due to HTTP mode. Re-authenticate as needed.');\n\n      return data;\n    } catch (error) {\n      this.handleError(error, 'Authentication failed');\n      throw error;\n    }\n  }\n\n  /**\n   * Direct authentication (HTTPS mode)\n   */\n  private async authenticateDirect(\n    username: string,\n    password: string\n  ): Promise<AuthResponse['data']> {\n    try {\n      const response = await axios.post<AuthResponse>(\n        `${this.serverUrl}/api/cli/auth`,\n        { username, password },\n        { timeout: 10000 }\n      );\n\n      const data = response.data.data;\n      const hours = Math.round(data.expiresIn / 3600000);\n      logger.success(`Authenticated successfully`);\n      logger.info(`Token expires in ${hours} hours`);\n\n      return data;\n    } catch (error) {\n      this.handleError(error, 'Authentication failed');\n      throw error;\n    }\n  }\n\n  /**\n   * Refresh token (only works in HTTPS mode)\n   */\n  async refreshToken(currentToken: string): Promise<AuthResponse['data'] | null> {\n    try {\n      const response = await axios.post<AuthResponse>(\n        `${this.serverUrl}/api/cli/refresh`,\n        {},\n        {\n          timeout: 10000,\n          headers: {\n            Authorization: `Bearer ${currentToken}`,\n          },\n        }\n      );\n\n      logger.success('Token refreshed successfully');\n      return response.data.data;\n    } catch (error) {\n      if (axios.isAxiosError(error)) {\n        const status = error.response?.status;\n        if (status === 400) {\n          // Token refresh not available (HTTP mode)\n          logger.warn('Token refresh not available. Please re-authenticate.');\n          return null;\n        }\n        if (status === 401) {\n          logger.warn('Token expired. Please re-authenticate.');\n          return null;\n        }\n      }\n      logger.error('Failed to refresh token');\n      return null;\n    }\n  }\n\n  /**\n   * Handle axios errors with user-friendly messages\n   */\n  private handleError(error: unknown, context: string): void {\n    if (axios.isAxiosError(error)) {\n      const axiosError = error as AxiosError<{ error?: string; message?: string }>;\n      const message =\n        axiosError.response?.data?.error ||\n        axiosError.response?.data?.message ||\n        axiosError.message;\n      logger.error(`${context}: ${message}`);\n    } else if (error instanceof Error) {\n      logger.error(`${context}: ${error.message}`);\n    } else {\n      logger.error(`${context}: Unknown error`);\n    }\n  }\n}\n"]}

package/dist/services/buildService.d.ts

@@ -0,0 +1,21 @@
+import { ProjectType, PackageManager } from '../types';
+export interface BuildOptions {
+    projectPath: string;
+    projectType: ProjectType;
+    projectName: string;
+    packageManager: PackageManager;
+    envFile?: string;
+}
+export interface BuildResult {
+    success: boolean;
+    outputDir: string;
+    duration: number;
+    error?: string;
+}
+export declare class BuildService {
+    build(options: BuildOptions): Promise<BuildResult>;
+    private getBuildArgs;
+    private getOutputDir;
+    private runCommand;
+}
+export declare const buildService: BuildService;