hub-launch 1.0.3

package/dist/commands/launch.js

@@ -0,0 +1,684 @@
+import axios from 'axios';
+import chalk from 'chalk';
+import os from 'os';
+import path from 'path';
+import { logger } from '../utils/logger.js';
+import { GitService } from '../services/git/GitService.js';
+import { PlanService } from '../services/plan/PlanService.js';
+import { HulaApiClient } from '../services/api/HulaApiClient.js';
+import { TempFileService } from '../services/logs/TempFileService.js';
+import { EditorService } from '../services/editor/EditorService.js';
+import { executeUpload } from './upload.js';
+import { loadGitHubToken } from './login.js';
+import { resolveProject } from '../utils/project-resolver.js';
+import { HULA_PROJECT_URL } from '../config/constants.js';
+const DEFAULT_CONTAINER_RESOURCES = { cpu: 2, memory: 4, disk: 10 };
+/**
+ * Launch command - Trigger a launch job on hula-project server
+ *
+ * Usage: hula launch <issueName> <planPath> [options]
+ * Usage: hula launch --show <name>
+ * Usage: hula launch --logs <name>
+ */
+export function launchCommand(program, config) {
+    program
+        .command('launch [issueName] [planPath]')
+        .description('Trigger a launch job on hula-project server')
+        .option('--url <url>', 'Override hula-project server URL')
+        .option('--api-key <key>', 'Override API key')
+        .option('--duration <hours>', 'Hours to keep Mac awake', parseInt)
+        .option('--launch <path>', 'Path to launch.md file (relative to project)')
+        .option('--worktree <path>', 'Base directory for worktree')
+        .option('--no-worktree', 'Run in current directory (no isolation)')
+        .option('--resume <step>', 'Resume from step N (1-9)', parseInt)
+        .option('--fix <instructions>', 'Fix instructions (use with --resume)')
+        .option('--regression', 'Force regression tests to run')
+        .option('--verbose', 'Show full output')
+        .option('--handoff <username>', 'Assign the created issue to this GitHub user')
+        .option('--anthropic-key <key>', 'Anthropic API key for Claude Code (ephemeral)')
+        .option('--daytona-key <key>', 'Daytona API key (required by hula-server)')
+        .option('--daytona-tier <n>', 'Daytona org tier (1–4) for capacity calculation', parseInt)
+        .option('--container-cpu <n>', 'vCPU cores for the sandbox (1–32)', parseInt)
+        .option('--container-memory <n>', 'GiB RAM for the sandbox (1–128)', parseInt)
+        .option('--container-disk <n>', 'GiB disk for the sandbox (5–200)', parseInt)
+        .option('--update-notification-url <url>', 'Webhook URL to POST a notification to on every terminal task transition')
+        .option('--show <name>', 'Show job status for the specified issue')
+        .option('--logs <name>', 'Show job logs for the specified issue')
+        .option('--lines <n>', 'Number of log lines to show (default: 100)', parseInt)
+        .option('--type <type>', 'Log type to fetch: log or output (default: log)')
+        .option('--editor', 'Open logs in editor instead of printing to stdout')
+        .action(async (issueName, planPath, options) => {
+        try {
+            // Handle --show flag
+            if (options.show) {
+                await showJobStatus(config, options.show, options);
+                return;
+            }
+            // Handle --logs flag
+            if (options.logs) {
+                await showJobLogs(config, options.logs, options);
+                return;
+            }
+            // Regular launch requires issueName and planPath
+            if (!issueName || !planPath) {
+                logger.error('Usage: hula launch <issueName> <planPath>');
+                logger.info('Or use --show <name> or --logs <name> to view job details');
+                process.exit(1);
+            }
+            await executeLaunch(config, issueName, planPath, options);
+        }
+        catch (error) {
+            logger.error('Failed to trigger launch:');
+            logger.error(error instanceof Error ? error.message : String(error));
+            process.exit(1);
+        }
+    });
+}
+async function validateLaunchCredentials(anthropicApiKey, githubToken) {
+    console.log('Checking your credentials before launch...\n');
+    // --- Anthropic ---
+    const anthropicAuthHeaders = {
+        Authorization: `Bearer ${anthropicApiKey}`,
+        'anthropic-version': '2023-06-01',
+    };
+    const anthropicPromise = axios
+        .get('https://api.anthropic.com/v1/models', {
+        headers: anthropicAuthHeaders,
+        timeout: 8000,
+    })
+        .then(() => ({ ok: true }))
+        .catch((err) => {
+        if (axios.isAxiosError(err) &&
+            err.response &&
+            err.response.status < 500) {
+            // Any 4xx → token is rejected (invalid, expired, or forbidden)
+            return {
+                ok: false,
+                hard: true,
+                message: 'Anthropic OAuth token is invalid or expired.',
+                hint: 'Generate a new OAuth token at https://claude.ai/settings (requires a paid Claude.ai plan — Pro or Max).',
+            };
+        }
+        // Network error / timeout / 5xx — non-blocking warning
+        return {
+            ok: false,
+            hard: false,
+            message: 'Could not reach the Anthropic API to verify your OAuth token (network issue).',
+            hint: 'Proceeding anyway — the server will validate the token on startup.',
+        };
+    });
+    // --- GitHub ---
+    const githubPromise = githubToken
+        ? axios
+            .get('https://api.github.com/user', {
+            headers: { Authorization: `Bearer ${githubToken}` },
+            timeout: 8000,
+        })
+            .then(() => ({ ok: true }))
+            .catch((err) => {
+            if (axios.isAxiosError(err) &&
+                err.response?.status === 401) {
+                return {
+                    ok: false,
+                    hard: true,
+                    message: 'GitHub token is invalid or expired.',
+                    hint: "Run 'hula login' to refresh your GitHub authentication.",
+                };
+            }
+            return {
+                ok: false,
+                hard: false,
+                message: 'Could not reach the GitHub API to verify your token (network issue).',
+                hint: 'Proceeding anyway — the server will validate the token.',
+            };
+        })
+        : Promise.resolve({
+            ok: false,
+            hard: true,
+            message: 'No GitHub token found.',
+            hint: "Run 'hula login' to authenticate with GitHub first.",
+        });
+    const [anthropicResult, githubResult] = await Promise.allSettled([
+        anthropicPromise,
+        githubPromise,
+    ]);
+    let hasHardFailure = false;
+    // Print Anthropic result
+    const result = anthropicResult.status === 'fulfilled'
+        ? anthropicResult.value
+        : {
+            ok: false,
+            hard: false,
+            message: 'Unexpected error during Anthropic validation.',
+            hint: 'Proceeding anyway.',
+        };
+    if (result.ok) {
+        console.log(`  ${chalk.green('✓')} Anthropic OAuth token is valid — Claude Code is ready to go 🤖`);
+    }
+    else if (result.hard) {
+        console.error(`  ${chalk.red('✗')} ${result.message}`);
+        console.error(`    ${chalk.red('→')} ${result.hint}`);
+        hasHardFailure = true;
+    }
+    else {
+        console.warn(`  ${chalk.yellow('⚠')} ${result.message}`);
+        console.warn(`    ${chalk.yellow('→')} ${result.hint}`);
+    }
+    // Print GitHub result
+    const ghResult = githubResult.status === 'fulfilled'
+        ? githubResult.value
+        : {
+            ok: false,
+            hard: false,
+            message: 'Unexpected error during GitHub validation.',
+            hint: 'Proceeding anyway.',
+        };
+    if (ghResult.ok) {
+        console.log(`  ${chalk.green('✓')} GitHub token is valid — you're all set 🐙`);
+    }
+    else if (ghResult.hard) {
+        console.error(`  ${chalk.red('✗')} ${ghResult.message}`);
+        console.error(`    ${chalk.red('→')} ${ghResult.hint}`);
+        hasHardFailure = true;
+    }
+    else {
+        console.warn(`  ${chalk.yellow('⚠')} ${ghResult.message}`);
+        console.warn(`    ${chalk.yellow('→')} ${ghResult.hint}`);
+    }
+    console.log();
+    if (hasHardFailure) {
+        process.exit(1);
+    }
+}
+async function executeLaunch(config, issueName, planPath, options) {
+    logger.section('Launch');
+    // Check if plan is synced to origin/main
+    const planSyncStatus = await checkPlanSyncStatus(config, planPath);
+    if (!planSyncStatus.synced) {
+        if (planSyncStatus.location === 'not-found') {
+            logger.error('Plan not found locally or on origin/main');
+            logger.info('Make sure you created the plan with /hula-plan');
+            process.exit(1);
+        }
+        // Plan exists locally but not on origin/main - auto-upload
+        logger.info('Plan found locally, pushing to origin/main...');
+        try {
+            await executeUpload(config, planPath);
+            logger.success('Plan synced to origin/main');
+            logger.blank();
+        }
+        catch (uploadError) {
+            logger.error('Failed to upload plan:');
+            logger.error(uploadError instanceof Error
+                ? uploadError.message
+                : String(uploadError));
+            process.exit(1);
+        }
+    }
+    // Get server URL and API key
+    const serverUrl = options.url || config.hulaProjectUrl || HULA_PROJECT_URL;
+    const apiKey = options.apiKey || config.hulaApiKey || process.env.HULA_API_KEY;
+    if (!apiKey) {
+        logger.error('No API key configured.');
+        logger.info('Set hulaApiKey in your config or use --api-key option.');
+        logger.info('You can also set HULA_API_KEY environment variable.');
+        logger.info("Run 'hula login' to authenticate with hula-project.");
+        process.exit(1);
+    }
+    // Get project ID - from config or detect from git
+    const repositoryId = await resolveProject(config);
+    // Validate fix requires resume
+    if (options.fix && options.resume === undefined) {
+        logger.error('--fix requires --resume to be set');
+        process.exit(1);
+    }
+    // Validate resume range
+    if (options.resume !== undefined &&
+        (options.resume < 1 || options.resume > 9)) {
+        logger.error('--resume must be between 1 and 9');
+        process.exit(1);
+    }
+    // Build the API endpoint
+    const endpoint = `${serverUrl.replace(/\/$/, '')}/api/v1/ralph-run`;
+    const updateNotificationUrl = options.updateNotificationUrl ||
+        config.updateNotificationUrl ||
+        process.env.HULA_UPDATE_NOTIFICATION_URL;
+    // Resolve Daytona tier — CLI flag > config > DAYTONA_TIER env var > default 1
+    const daytonaTierRaw = options.daytonaTier ??
+        config.daytonaTier ??
+        (process.env.DAYTONA_TIER ? parseInt(process.env.DAYTONA_TIER, 10) : 1);
+    if (!Number.isInteger(daytonaTierRaw) ||
+        ![1, 2, 3, 4].includes(daytonaTierRaw)) {
+        logger.error('daytonaTier must be 1, 2, 3, or 4 (set via --daytona-tier, config.daytonaTier, or DAYTONA_TIER env var)');
+        process.exit(1);
+    }
+    const daytonaTier = daytonaTierRaw;
+    logger.info(`Triggering launch job...`);
+    logger.log(`  Issue Name: ${issueName}`);
+    logger.log(`  Plan Path: ${planPath}`);
+    logger.log(`  Server: ${serverUrl}`);
+    // Log optional parameters if set
+    if (options.duration)
+        logger.log(`  Duration: ${options.duration} hours`);
+    if (options.launch)
+        logger.log(`  Launch Path: ${options.launch}`);
+    if (options.worktree === false)
+        logger.log(`  Worktree: disabled`);
+    else if (typeof options.worktree === 'string')
+        logger.log(`  Worktree Base: ${options.worktree}`);
+    if (options.resume)
+        logger.log(`  Resume From: Step ${options.resume}`);
+    if (options.fix)
+        logger.log(`  Fix Instructions: ${options.fix}`);
+    if (options.regression)
+        logger.log(`  Force Regression: yes`);
+    if (options.verbose)
+        logger.log(`  Verbose: yes`);
+    if (options.handoff)
+        logger.log(`  Handoff To: ${options.handoff}`);
+    if (updateNotificationUrl)
+        logger.log(`  Notify on completion: enabled`);
+    logger.log(`  Daytona Tier: ${daytonaTier}`);
+    logger.blank();
+    // Build request body
+    const requestBody = {
+        issueName,
+        planPath,
+        repositoryId,
+    };
+    if (options.duration !== undefined) {
+        requestBody.duration = options.duration;
+    }
+    // Keep 'ralphPath' property name for server API compatibility
+    // even though the CLI option is now '--launch'
+    if (options.launch) {
+        requestBody.ralphPath = options.launch;
+    }
+    // Handle worktree: commander sets it to false for --no-worktree
+    if (options.worktree === false) {
+        requestBody.worktree = false;
+    }
+    else if (typeof options.worktree === 'string') {
+        requestBody.worktree = options.worktree;
+    }
+    if (options.resume !== undefined) {
+        requestBody.resume = options.resume;
+    }
+    if (options.fix) {
+        requestBody.fix = options.fix;
+    }
+    if (options.regression) {
+        requestBody.regression = true;
+    }
+    if (options.verbose) {
+        requestBody.verbose = true;
+    }
+    if (options.handoff) {
+        requestBody.handoff = options.handoff;
+    }
+    // Resolve ephemeral credentials — collect ALL errors before exiting
+    const anthropicApiKey = options.anthropicKey ||
+        config.anthropicApiKey ||
+        process.env.ANTHROPIC_API_KEY;
+    const daytonaApiKey = options.daytonaKey ||
+        config.daytonaApiKey ||
+        process.env.DAYTONA_API_KEY;
+    const credentialErrors = [];
+    if (!anthropicApiKey) {
+        credentialErrors.push([
+            chalk.red('✗ No Anthropic OAuth token configured.'),
+            '  Set anthropicApiKey in your config at .hublaunch/hublaunch.config.js, use --anthropic-key, or set ANTHROPIC_API_KEY env var.',
+            '  Get your OAuth token at: https://claude.ai/settings (requires a paid Claude.ai plan — Pro or Max)',
+        ].join('\n'));
+    }
+    else if (!anthropicApiKey.startsWith('sk-ant-oat')) {
+        credentialErrors.push([
+            chalk.red('✗ Anthropic credential must be an OAuth token (starts with sk-ant-oat01-...).'),
+            '  Standard API keys (sk-ant-api03-...) are not supported — the container requires CLAUDE_CODE_OAUTH_TOKEN.',
+            '  Get your OAuth token at: https://claude.ai/settings (requires a paid Claude.ai plan — Pro or Max)',
+        ].join('\n'));
+    }
+    if (!daytonaApiKey) {
+        credentialErrors.push([
+            chalk.red('✗ No Daytona API key configured.'),
+            '  Set daytonaApiKey in your config at .hublaunch/hublaunch.config.js, use --daytona-key, or set DAYTONA_API_KEY env var.',
+            '  Get your Daytona API key at: https://app.daytona.io',
+        ].join('\n'));
+    }
+    if (credentialErrors.length > 0) {
+        credentialErrors.forEach((msg) => console.error(msg));
+        process.exit(1);
+    }
+    requestBody.anthropicApiKey = anthropicApiKey;
+    requestBody.daytonaApiKey = daytonaApiKey;
+    requestBody.daytonaTier = daytonaTier;
+    const cpuRaw = options.containerCpu ?? config.containerResources?.cpu;
+    const memRaw = options.containerMemory ?? config.containerResources?.memory;
+    const diskRaw = options.containerDisk ?? config.containerResources?.disk;
+    if (cpuRaw !== undefined || memRaw !== undefined || diskRaw !== undefined) {
+        const cpu = cpuRaw ?? DEFAULT_CONTAINER_RESOURCES.cpu;
+        const memory = memRaw ?? DEFAULT_CONTAINER_RESOURCES.memory;
+        const disk = diskRaw ?? DEFAULT_CONTAINER_RESOURCES.disk;
+        if (!Number.isInteger(cpu) || cpu < 1 || cpu > 32) {
+            logger.error('containerResources.cpu must be an integer between 1 and 32');
+            process.exit(1);
+        }
+        if (!Number.isInteger(memory) || memory < 1 || memory > 128) {
+            logger.error('containerResources.memory must be an integer between 1 and 128 GiB');
+            process.exit(1);
+        }
+        if (!Number.isInteger(disk) || disk < 5 || disk > 200) {
+            logger.error('containerResources.disk must be an integer between 5 and 200 GiB');
+            process.exit(1);
+        }
+        requestBody.containerResources = { cpu, memory, disk };
+        logger.log(`  Container Resources: cpu=${cpu} memory=${memory}GiB disk=${disk}GiB`);
+    }
+    if (updateNotificationUrl) {
+        requestBody.updateNotificationUrl = updateNotificationUrl;
+    }
+    const tokenData = await loadGitHubToken();
+    const githubToken = tokenData?.access_token || process.env.GITHUB_TOKEN;
+    if (githubToken) {
+        requestBody.githubToken = githubToken;
+    }
+    // Pre-flight credential validation
+    // anthropicApiKey is guaranteed non-null here — missing key exits above
+    await validateLaunchCredentials(anthropicApiKey, githubToken);
+    try {
+        const response = await axios.post(endpoint, requestBody, {
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${apiKey}`,
+            },
+            timeout: 30000, // 30 second timeout
+        });
+        if (response.data.success) {
+            logger.success(response.data.message);
+            if (response.data.job) {
+                const job = response.data.job;
+                logger.blank();
+                logger.info('Job Details:');
+                logger.log(`  ID: ${job.id}`);
+                logger.log(`  Issue: ${job.issueName}`);
+                logger.log(`  Plan: ${job.planPath}`);
+                if (job.pid) {
+                    logger.log(`  PID: ${job.pid}`);
+                }
+                logger.log(`  Status: ${job.status}`);
+                logger.log(`  Started At: ${job.startedAt}`);
+            }
+            logger.blank();
+            logger.info('You can go to https://www.hublaunch.site/dashboard to see a summary of your active plans.');
+            if (!updateNotificationUrl) {
+                logger.info('Set updateNotificationUrl in your local hublaunch.config.js file to be able to get update messages about the status.');
+            }
+            logger.blank();
+            // Clean up local plan file — it's now on origin/main and submitted to server
+            const planService = new PlanService(config.planPath);
+            planService.deletePlan(planPath);
+        }
+        else {
+            logger.error(response.data.error || 'Unknown error occurred');
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        if (axios.isAxiosError(error)) {
+            if (error.response) {
+                const status = error.response.status;
+                const data = error.response.data;
+                switch (status) {
+                    case 400:
+                        logger.error(`Bad request: ${data.error || 'Invalid parameters'}`);
+                        break;
+                    case 401:
+                        logger.error('Authentication failed. Your API key may be invalid.');
+                        logger.info("Run 'hula login' to re-authenticate.");
+                        break;
+                    case 403:
+                        if (data.error === 'need_pro_plan') {
+                            logger.error('You cannot run launch because you are on the free tier.');
+                            logger.blank();
+                            logger.info('Your options:');
+                            logger.info('  • Run /hula-create, which will assign the issue to Copilot on GitHub.');
+                            logger.info('  • Go to https://www.hublaunch.site and upgrade your subscription to Pro.');
+                            logger.blank();
+                            logger.info('The Pro tier allows launching as many plans as you like, subject to the constraints of your own Anthropic and Daytona subscriptions.');
+                        }
+                        else {
+                            logger.error('Access denied. You may not be authorized for launch.');
+                        }
+                        break;
+                    case 404:
+                        logger.error(data.error || `Not found: ${planPath}`);
+                        break;
+                    case 409:
+                        logger.error(`Job already running: ${issueName}`);
+                        break;
+                    case 500:
+                        logger.error(`Server error: ${data.error || 'Internal server error'}`);
+                        break;
+                    default:
+                        logger.error(`Request failed with status ${status}: ${data.error || error.message}`);
+                }
+            }
+            else if (error.code === 'ECONNREFUSED') {
+                logger.error(`Cannot connect to server at ${serverUrl}`);
+                logger.info('Make sure the hula-project server is running.');
+            }
+            else if (error.code === 'ETIMEDOUT' || error.code === 'ECONNABORTED') {
+                logger.error('Request timed out');
+                logger.info('The server may be slow or unreachable.');
+            }
+            else {
+                logger.error(`Network error: ${error.message}`);
+            }
+        }
+        else {
+            throw error;
+        }
+        process.exit(1);
+    }
+}
+/**
+ * Show job status for a tracked issue
+ */
+async function showJobStatus(config, issueName, options) {
+    const serverUrl = options.url || config.hulaProjectUrl || process.env.HULA_PROJECT_URL;
+    const apiKey = options.apiKey || config.hulaApiKey || process.env.HULA_API_KEY;
+    if (!serverUrl || !apiKey) {
+        logger.error('Server URL and API key are required.');
+        logger.info("Run 'hula login' to authenticate with hula-project.");
+        process.exit(1);
+    }
+    const endpoint = `${serverUrl.replace(/\/$/, '')}/api/v1/ralph-run/${encodeURIComponent(issueName)}/status`;
+    const project = await resolveProject(config);
+    try {
+        const response = await axios.get(endpoint, {
+            headers: { Authorization: `Bearer ${apiKey}` },
+            params: { project },
+            timeout: 15000,
+        });
+        const data = response.data;
+        if (data.jobStatus) {
+            logger.section(`Job Status: ${issueName}`);
+            logger.log(`  Status: ${formatJobStatus(data.jobStatus)}`);
+            if (data.jobPid)
+                logger.log(`  PID: ${data.jobPid}`);
+            if (data.jobStartedAt)
+                logger.log(`  Started: ${data.jobStartedAt}`);
+            if (data.jobCompletedAt)
+                logger.log(`  Completed: ${data.jobCompletedAt}`);
+            if (data.jobExitCode !== null && data.jobExitCode !== undefined) {
+                logger.log(`  Exit Code: ${data.jobExitCode}`);
+            }
+            if (data.prSource)
+                logger.log(`  Source: ${data.prSource}`);
+            if (data.planPath)
+                logger.log(`  Plan: ${data.planPath}`);
+            if (data.jobWorkerHost)
+                logger.log(`  Worker: ${data.jobWorkerHost}`);
+            logger.blank();
+        }
+        else {
+            logger.error(`No job found for issue: ${issueName}`);
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        handleApiError(error, serverUrl);
+        process.exit(1);
+    }
+}
+/**
+ * Show job logs for a tracked issue
+ */
+async function showJobLogs(config, issueName, options) {
+    const serverUrl = options.url || config.hulaProjectUrl || process.env.HULA_PROJECT_URL;
+    const apiKey = options.apiKey || config.hulaApiKey || process.env.HULA_API_KEY;
+    const lines = options.lines || 100;
+    const logType = options.type === 'output' ? 'output' : 'log';
+    if (!serverUrl || !apiKey) {
+        logger.error('Server URL and API key are required.');
+        logger.info("Run 'hula login' to authenticate with hula-project.");
+        process.exit(1);
+    }
+    const apiClient = new HulaApiClient({
+        baseUrl: serverUrl.replace(/\/$/, ''),
+        apiKey,
+        timeout: 30000,
+    });
+    const project = await resolveProject(config);
+    try {
+        const content = await apiClient.fetchTaskLogs(issueName, {
+            type: logType,
+            lines,
+            project,
+        });
+        if (options.editor) {
+            const tempFileService = new TempFileService(path.join(os.tmpdir(), 'hublaunch-logs'));
+            const filePath = await tempFileService.createTempFile(content, issueName);
+            logger.info(`Log file created: ${filePath}`);
+            const editorService = new EditorService(config.editorCommand);
+            await editorService.openFile(filePath);
+            logger.success('✓ Log file opened in editor');
+        }
+        else {
+            process.stdout.write(content);
+        }
+    }
+    catch (error) {
+        handleApiError(error, serverUrl);
+        process.exit(1);
+    }
+}
+/**
+ * Format job status with color/emoji indicator
+ */
+function formatJobStatus(status) {
+    switch (status) {
+        case 'queued':
+            return '⏳ queued';
+        case 'running':
+            return '🔄 running';
+        case 'completed':
+            return '✅ completed';
+        case 'failed':
+            return '❌ failed';
+        case 'cancelled':
+            return '⏹️ cancelled';
+        default:
+            return status;
+    }
+}
+/**
+ * Handle API errors consistently
+ */
+function handleApiError(error, serverUrl) {
+    if (axios.isAxiosError(error)) {
+        if (error.response) {
+            const status = error.response.status;
+            const data = error.response.data;
+            switch (status) {
+                case 401:
+                    logger.error('Authentication failed. Your API key may be invalid.');
+                    logger.info("Run 'hula login' to re-authenticate.");
+                    break;
+                case 404:
+                    logger.error(data.error || 'Not found');
+                    break;
+                default:
+                    logger.error(data.error || `Request failed with status ${status}`);
+            }
+        }
+        else if (error.code === 'ECONNREFUSED') {
+            logger.error(`Cannot connect to server at ${serverUrl}`);
+        }
+        else {
+            logger.error(`Network error: ${error.message}`);
+        }
+    }
+    else {
+        throw error;
+    }
+}
+/**
+ * Check if plan is synced to origin/main
+ */
+async function checkPlanSyncStatus(config, planPath) {
+    const gitService = new GitService();
+    const planService = new PlanService(config.planPath);
+    // Fetch latest from origin
+    await gitService.fetch('origin', 'main');
+    // Check if plan exists on origin/main
+    const relativePath = planService.getRelativePath(planPath);
+    const onOrigin = await gitService.fileExistsOnRef('origin/main', relativePath);
+    if (onOrigin) {
+        return { synced: true, location: 'origin-main' };
+    }
+    // Check local main
+    const onLocalMain = await gitService.fileExistsOnRef('main', relativePath);
+    if (onLocalMain) {
+        return { synced: false, location: 'local-main' };
+    }
+    return { synced: false, location: 'not-found' };
+}
+/**
+ * Deprecated ralph command - alias for launch
+ * @deprecated Use launchCommand instead
+ */
+export function ralphCommand(program, config) {
+    program
+        .command('ralph <issueName> <planPath>')
+        .description('[DEPRECATED] Use "hula launch" instead')
+        .option('--url <url>', 'Override hula-project server URL')
+        .option('--api-key <key>', 'Override API key')
+        .option('--duration <hours>', 'Hours to keep Mac awake', parseInt)
+        .option('--ralph <path>', 'Path to ralph.md file (relative to project)')
+        .option('--launch <path>', 'Path to launch.md file (relative to project)')
+        .option('--worktree <path>', 'Base directory for worktree')
+        .option('--no-worktree', 'Run in current directory (no isolation)')
+        .option('--resume <step>', 'Resume from step N (1-9)', parseInt)
+        .option('--fix <instructions>', 'Fix instructions (use with --resume)')
+        .option('--regression', 'Force regression tests to run')
+        .option('--verbose', 'Show full output')
+        .action(async (issueName, planPath, options) => {
+        logger.warning('⚠️  "hula ralph" is deprecated. Please use "hula launch" instead.');
+        logger.blank();
+        // Support both --ralph and --launch options for backward compatibility
+        const launchOptions = {
+            ...options,
+            launch: options.launch || options.ralph,
+        };
+        try {
+            await executeLaunch(config, issueName, planPath, launchOptions);
+        }
+        catch (error) {
+            logger.error('Failed to trigger launch:');
+            logger.error(error instanceof Error ? error.message : String(error));
+            process.exit(1);
+        }
+    });
+}
+//# sourceMappingURL=launch.js.map