hub-launch 1.30.0 → 1.32.0

package/dist/commands/launch.js

@@ -14,6 +14,7 @@ import { GroupLaunchService, validateGroupId, } from '../services/group/GroupLau
 import { TempFileService } from '../services/logs/TempFileService.js';
 import { EditorService } from '../services/editor/EditorService.js';
 import { ensurePlanBranch, PlanNotFoundError, } from '../services/plan/PlanBranchService.js';
+import { parseGitHubRef, findLinkedIssueNumber, resolveIssueSource, resolvePrSource, buildPlanMarkdown, writeGeneratedPlan, } from '../services/plan/GitHubSourcePlanService.js';
 import { loadGitHubToken } from './login.js';
 import { resolveProject } from '../utils/project-resolver.js';
 import { HULA_PROJECT_URL } from '../config/constants.js';
@@ -25,6 +26,7 @@ import { findGitRoot } from '../utils/git-utils.js';
 import { upsertProviderApiKey } from '../utils/config-file-edit.js';
 import { validateNoReservedVars, readAndFilterEnvVars, RESERVED_ENV_VARS, } from '../utils/env-vars.js';
 import { HookExecutor } from '../services/hooks/HookExecutor.js';
+import { describeSandboxProfile, resolveSandboxProfile, sandboxProfileForRequest, } from '../utils/sandbox-profile.js';
 const DEFAULT_CONTAINER_RESOURCES = { cpu: 2, memory: 4, disk: 10 };
 /**
  * Launch command - Trigger a launch job on hula-project server
@@ -69,11 +71,15 @@ export function launchCommand(program, config) {
         //   'Run in test mode (server uses a mock Claude — fast E2E run, still creates a real PR)',
         // )
         .option('--handoff <username>', 'Assign the created issue to this GitHub user')
+        .option('--issue <ref>', 'Work on an existing GitHub issue (number, #number, or URL). Never creates a new issue. A single positional is the tracking name, not a plan path.')
+        .option('--pr <ref>', 'Continue an existing pull request in this repository (number, #number, or URL). Pushes to its branch. A single positional is the tracking name, not a plan path.')
+        .option('--base <branch>', 'Branch to cut the new work branch from and open the PR into (default: the repository default branch)')
         .option('--provider <type>', 'LLM provider: claude | openai | openrouter (default: config or claude)')
         .option('--provider-key <key>', 'Provider credential (ephemeral; never stored server-side beyond the run)')
         .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('--sandbox-profile <profile>', 'Sandbox image: base | android | android:17 | android:21 (default: config sandboxProfile, else base)')
         .option('--update-notification-url <url>', 'Webhook URL to POST a notification to on every terminal task transition')
         .option('--update-notification-name-tag <tag>', 'Verbatim "initiated by" label for notifications (Slack mention markup pings). Falls back to config then HULA_UPDATE_NOTIFICATION_NAME_TAG.')
         .option('--show <name>', 'Show job status for the specified issue')
@@ -121,6 +127,13 @@ export function launchCommand(program, config) {
                 logger.error(folderFlagError);
                 process.exit(1);
             }
+            // Validate the launch-from-existing `--issue` / `--pr` / `--base`
+            // flag combination before any work.
+            const sourceFlagError = validateSourceFlags(options, Boolean(planPath));
+            if (sourceFlagError) {
+                logger.error(sourceFlagError);
+                process.exit(1);
+            }
             // Validate an explicitly-supplied group id against the server format.
             if (typeof options.groupId === 'string') {
                 const groupIdError = validateGroupId(options.groupId);
@@ -162,6 +175,13 @@ export function launchCommand(program, config) {
                 await executeKill(config, issueName, options);
                 return;
             }
+            // With --issue / --pr the plan (and tracking name) are derived from
+            // GitHub, so neither positional is required. A single positional is
+            // the tracking name; the plan path is generated.
+            if (options.issue || options.pr) {
+                await executeLaunch(config, issueName, planPath, options);
+                return;
+            }
             // Regular launch / --kill-and-relaunch requires issueName and planPath
             if (!issueName || !planPath) {
                 logger.error('Usage: hula launch <issueName> <planPath>');
@@ -217,7 +237,52 @@ export function validateKillFlags(options) {
  * `--kill` needs only the tracking name; every other mode needs a plan.
  */
 export function requiresPlanPath(options) {
-    return !options.kill;
+    return !options.kill && !options.issue && !options.pr;
+}
+/**
+ * Launch-only flags that cannot be combined with `--issue` / `--pr`. These are
+ * either read/group modes or the kill flows, none of which make sense when
+ * starting from an existing issue or PR (single-repo launch only).
+ */
+const SOURCE_INCOMPATIBLE_FLAGS = [
+    { key: 'folder', flag: '--folder' },
+    { key: 'groupId', flag: '--group-id' },
+    { key: 'kill', flag: '--kill' },
+    { key: 'killAndRelaunch', flag: '--kill-and-relaunch' },
+    { key: 'show', flag: '--show' },
+    { key: 'logs', flag: '--logs' },
+    { key: 'showGroup', flag: '--show-group' },
+];
+/**
+ * Validate the `--issue` / `--pr` / `--base` flag matrix.
+ *
+ * - A plan file may accompany `--issue` OR `--pr`, but not both — with both and
+ *   a plan file there is no single instruction source. Without a plan file,
+ *   `--issue` and `--pr` combine (plan generated from both).
+ * - `--base` is meaningless with `--pr` (the base comes from the PR itself).
+ * - `--issue` / `--pr` are single-repo launch flows, incompatible with the
+ *   read/group/kill flags in {@link SOURCE_INCOMPATIBLE_FLAGS}.
+ *
+ * Returns an error message when the combination is invalid, or `null` when OK.
+ */
+export function validateSourceFlags(options, hasPlanPathPositional) {
+    const hasIssue = Boolean(options.issue);
+    const hasPr = Boolean(options.pr);
+    if (hasPlanPathPositional && hasIssue && hasPr) {
+        return 'Pass a plan file with --issue or with --pr, not with both. Without a plan file, --issue and --pr can be combined.';
+    }
+    if (hasPr && options.base) {
+        return '--base cannot be used with --pr: the base branch comes from the pull request';
+    }
+    if (hasIssue || hasPr) {
+        for (const { key, flag } of SOURCE_INCOMPATIBLE_FLAGS) {
+            const value = options[key];
+            if (value !== undefined && value !== false) {
+                return `--issue/--pr cannot be combined with ${flag}`;
+            }
+        }
+    }
+    return null;
 }
 /**
  * Validate the multi-repo `--folder` / `--group-id` / `--plan` flag matrix.
@@ -492,6 +557,8 @@ async function validateProviderCredentials(providerType, authToken, githubToken)
         process.exit(1);
     }
 }
+/** Client-side ceiling for the launch POST (ms). */
+export const LAUNCH_REQUEST_TIMEOUT_MS = 120_000;
 /**
  * Billing page of the server the CLI is actually talking to. Never hardcode
  * hublaunch.site — a preview or self-hosted deployment must point the user at
@@ -500,23 +567,36 @@ async function validateProviderCredentials(providerType, authToken, githubToken)
 function billingUrl(serverUrl) {
     return `${serverUrl.replace(/\/$/, '')}/dashboard/billing`;
 }
-/**
- * Explain why a launch was refused for billing reasons.
- *
- * `subscriptionStatus` is what the server reported for this account (`null`
- * when it has never had a subscription, so a free trial is still available);
- * `serverError` is the server's own 402 message when the refusal came from the
- * launch endpoint rather than the pre-flight check — it is more specific than
- * anything the CLI can infer ("Out of PR credits — buy more to launch"), so it
- * wins. `actionUrl` is the `upgradeUrl`/`buyCreditsUrl` from that same payload.
- *
- * With none of them supplied, the wording stays generic rather than asserting a
- * tier the CLI has not confirmed.
- */
-function printNoProAccessError(opts) {
-    const { serverUrl, subscriptionStatus, serverError, actionUrl } = opts;
+/** The "Your options" lines printed under a billing refusal. */
+export function billingRefusalOptions(opts) {
+    const { serverUrl, subscriptionStatus, actionUrl, refusal } = opts;
     const url = actionUrl || billingUrl(serverUrl);
-    const neverSubscribed = subscriptionStatus === null || subscriptionStatus === undefined;
+    const neverSubscribed = subscriptionStatus === null;
+    const paymentFailed = subscriptionStatus === 'past_due' || subscriptionStatus === 'unpaid';
+    let first;
+    if (refusal === 'credits') {
+        first = `  • Buy more credits at ${url}. Purchased credits never expire.`;
+    }
+    else if (neverSubscribed) {
+        first = `  • Start a free trial at ${url} — no charge today, cancel anytime.`;
+    }
+    else if (paymentFailed) {
+        first = `  • Update your payment method at ${url}.`;
+    }
+    else if (subscriptionStatus === undefined) {
+        first = `  • See your plan and credits at ${url}.`;
+    }
+    else {
+        first = `  • Subscribe or top up credits at ${url}.`;
+    }
+    return [
+        first,
+        '  • Run /hula-create, which will assign the issue to Copilot on GitHub.',
+    ];
+}
+function printNoProAccessError(opts) {
+    const { subscriptionStatus, serverError } = opts;
+    const neverSubscribed = subscriptionStatus === null;
     const paymentFailed = subscriptionStatus === 'past_due' || subscriptionStatus === 'unpaid';
     if (serverError) {
         logger.error(serverError);
@@ -524,6 +604,9 @@ function printNoProAccessError(opts) {
     else if (neverSubscribed) {
         logger.error('Launching requires Pro — this account has no subscription yet.');
     }
+    else if (subscriptionStatus === undefined) {
+        logger.error('Launching requires Pro.');
+    }
     else if (subscriptionStatus === 'canceled') {
         logger.error('Launching requires Pro — your subscription was cancelled.');
     }
@@ -535,18 +618,10 @@ function printNoProAccessError(opts) {
     }
     logger.blank();
     logger.info('Your options:');
-    if (neverSubscribed) {
-        logger.info(`  • Start a free trial at ${url} — no charge today, cancel anytime.`);
-    }
-    else if (paymentFailed) {
-        logger.info(`  • Update your payment method at ${url}.`);
-    }
-    else {
-        logger.info(`  • Subscribe or top up credits at ${url}.`);
-    }
-    logger.info('  • Run /hula-create, which will assign the issue to Copilot on GitHub.');
+    for (const line of billingRefusalOptions(opts))
+        logger.info(line);
     logger.blank();
-    logger.info('The Pro tier allows launching as many plans as you like, subject to the constraints of your own LLM provider (Claude, OpenAI, or OpenRouter) subscription.');
+    logger.info('Pro includes a monthly allowance of PR credits, and you can buy more at any time. Runs also use your own LLM provider (Claude, OpenAI, or OpenRouter) subscription.');
 }
 /**
  * Check whether the account may launch — Pro, including an active free trial
@@ -720,6 +795,11 @@ export function buildRalphRunRequestBody(input) {
     if (input.containerResources) {
         body.containerResources = input.containerResources;
     }
+    // Maps to RalphRunRequest.sandboxProfile. Only non-base profiles are sent so
+    // base launches stay byte-identical (see sandboxProfileForRequest).
+    if (input.sandboxProfile) {
+        body.sandboxProfile = input.sandboxProfile;
+    }
     if (input.updateNotificationUrl) {
         body.updateNotificationUrl = input.updateNotificationUrl;
     }
@@ -737,8 +817,69 @@ export function buildRalphRunRequestBody(input) {
     if (input.branchExists) {
         body.branchExists = true;
     }
+    // Launch-from-existing linkage (appended after branchExists, each only when
+    // defined, so non-source launches stay byte-identical). An older server
+    // ignores these unknown fields.
+    if (input.issueNumber !== undefined) {
+        body.issueNumber = input.issueNumber;
+    }
+    if (input.prNumber !== undefined) {
+        body.prNumber = input.prNumber;
+    }
+    if (input.headBranch !== undefined) {
+        body.headBranch = input.headBranch;
+    }
+    if (input.baseBranch !== undefined) {
+        body.baseBranch = input.baseBranch;
+    }
     return body;
 }
+/**
+ * True when `msg` is one of the deliberate validation errors thrown by
+ * {@link resolveIssueSource} / {@link resolvePrSource} (closed, merged, fork,
+ * wrong kind) — those must pass through verbatim, not be re-wrapped as a fetch
+ * failure.
+ */
+function isGitHubSourceValidationError(msg) {
+    return /is a pull request, not an issue|is an issue, not a pull request|is closed\. Reopen|is already merged|comes from a fork/.test(msg);
+}
+/**
+ * {@link resolveIssueSource} with the GitHub-fetch error mapping from the plan's
+ * edge cases: 404 → a clear "not found in <owner/repo>", any other fetch error
+ * → "Could not fetch issue #<n>: …". Validation errors pass through unchanged.
+ */
+async function resolveIssueSourceWrapped(n, repo, repoFullName) {
+    try {
+        return await resolveIssueSource(n, repo);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (isGitHubSourceValidationError(msg))
+            throw err;
+        if (/404|not found/i.test(msg)) {
+            throw new Error(`Issue #${n} not found in ${repoFullName}`);
+        }
+        throw new Error(`Could not fetch issue #${n}: ${msg}`);
+    }
+}
+/**
+ * {@link resolvePrSource} with the same GitHub-fetch error mapping as
+ * {@link resolveIssueSourceWrapped}.
+ */
+async function resolvePrSourceWrapped(n, repoFullName) {
+    try {
+        return await resolvePrSource(n);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (isGitHubSourceValidationError(msg))
+            throw err;
+        if (/404|not found/i.test(msg)) {
+            throw new Error(`PR #${n} not found in ${repoFullName}`);
+        }
+        throw new Error(`Could not fetch PR #${n}: ${msg}`);
+    }
+}
 /**
  * Single-repo launch entry point. Runs the plan-sync/upload check, then defers
  * the body-build + POST to {@link launchSingleRepo} in single mode (keeps the
@@ -776,11 +917,121 @@ conflictModeOverride) {
  * @param options - Parsed CLI options.
  * @param ctx - Mode + shared-once context (see {@link SingleRepoLaunchContext}).
  */
-async function launchSingleRepo(repoConfig, repoRoot, issueName, planPath, options, ctx) {
+async function launchSingleRepo(repoConfig, repoRoot, issueNameInput, planPathInput, options, ctx) {
     const isGroup = ctx.mode === 'group';
     // Effective conflict mode: an explicit override (from the 409 resolver) or the
     // --kill-and-relaunch flag. Undefined = default 'reject' (byte-identical body).
     const conflictMode = deriveConflictMode(options, ctx.conflictModeOverride);
+    // ── Launch-from-existing resolution (FR 8) ────────────────────────────────
+    // With --issue / --pr the tracking name and plan are derived from GitHub, and
+    // --base / --pr change the branch the plan is published to and the PR base.
+    // Resolve all of that here, before ensurePlanBranch, so the proven publish
+    // path is reused with overrides and the request body gains the linkage fields.
+    let resolvedIssueName = issueNameInput;
+    let resolvedPlanPath = planPathInput;
+    let planBranchOpts;
+    const sourceBody = {};
+    if (options.issue || options.pr || options.base) {
+        try {
+            const repoFullName = ctx.repositoryId ??
+                (await resolveProject(repoConfig, undefined, repoRoot));
+            const [repoOwner, repoName] = repoFullName.split('/');
+            // Reject a URL that points at a different repository than this one.
+            const assertSameRepo = (ref, kind) => {
+                if (ref.owner &&
+                    ref.repo &&
+                    (ref.owner.toLowerCase() !== (repoOwner ?? '').toLowerCase() ||
+                        ref.repo.toLowerCase() !== (repoName ?? '').toLowerCase())) {
+                    throw new Error(`--${kind} URL points to ${ref.owner}/${ref.repo}, but this repository is ${repoOwner}/${repoName}`);
+                }
+            };
+            let pr;
+            let issue;
+            if (options.pr) {
+                const prRef = parseGitHubRef(options.pr, 'pr');
+                assertSameRepo(prRef, 'pr');
+                pr = await resolvePrSourceWrapped(prRef.number, repoFullName);
+                // Linked issue: an explicit --issue wins; otherwise auto-detect from the
+                // PR body and drop a closed linked issue with a warning.
+                if (options.issue) {
+                    const issueRef = parseGitHubRef(options.issue, 'issue');
+                    assertSameRepo(issueRef, 'issue');
+                    issue = await resolveIssueSourceWrapped(issueRef.number, { owner: issueRef.owner, name: issueRef.repo }, repoFullName);
+                }
+                else {
+                    const linked = findLinkedIssueNumber(pr.body);
+                    if (linked !== null) {
+                        try {
+                            issue = await resolveIssueSourceWrapped(linked, {}, repoFullName);
+                        }
+                        catch (linkedErr) {
+                            const linkedMsg = linkedErr instanceof Error
+                                ? linkedErr.message
+                                : String(linkedErr);
+                            if (linkedMsg.includes('is closed')) {
+                                logger.warning(`Linked issue #${linked} is closed — continuing without linking it`);
+                            }
+                            else {
+                                throw linkedErr;
+                            }
+                        }
+                    }
+                }
+            }
+            else if (options.issue) {
+                const issueRef = parseGitHubRef(options.issue, 'issue');
+                assertSameRepo(issueRef, 'issue');
+                issue = await resolveIssueSourceWrapped(issueRef.number, { owner: issueRef.owner, name: issueRef.repo }, repoFullName);
+            }
+            // Tracking name: the positional if given, else pr-<n> / issue-<n>.
+            if (!resolvedIssueName) {
+                resolvedIssueName = pr
+                    ? `pr-${pr.number}`
+                    : issue
+                        ? `issue-${issue.number}`
+                        : resolvedIssueName;
+            }
+            // Plan path: the positional if given, else a generated plan from the
+            // GitHub text (only reachable with --issue / --pr; --base alone still
+            // requires a positional plan because requiresPlanPath stays true).
+            if (!resolvedPlanPath && (pr || issue)) {
+                const slug = pr ? `pr-${pr.number}` : `issue-${issue.number}`;
+                const markdown = buildPlanMarkdown({ issue, pr, repoFullName });
+                resolvedPlanPath = writeGeneratedPlan(repoConfig.planPath, slug, markdown, repoRoot);
+                logger.info(`Generated plan from ${pr ? `PR #${pr.number}` : `issue #${issue.number}`}: ${resolvedPlanPath}`);
+            }
+            // Branch overrides for ensurePlanBranch.
+            if (pr) {
+                planBranchOpts = { branch: pr.head.ref, requireExistingBranch: true };
+            }
+            else if (options.base) {
+                planBranchOpts = { baseBranch: options.base };
+            }
+            // Request-body linkage fields.
+            if (pr) {
+                sourceBody.prNumber = pr.number;
+                sourceBody.headBranch = pr.head.ref;
+                sourceBody.baseBranch = pr.base.ref;
+            }
+            else if (options.base) {
+                sourceBody.baseBranch = options.base;
+            }
+            if (issue) {
+                sourceBody.issueNumber = issue.number;
+            }
+        }
+        catch (sourceErr) {
+            const msg = sourceErr instanceof Error ? sourceErr.message : String(sourceErr);
+            logger.error(msg);
+            if (isGroup)
+                return { ok: false, message: msg };
+            process.exit(1);
+        }
+    }
+    // After resolution both are guaranteed: the handler requires positionals
+    // except with --issue / --pr, which populate them above.
+    const issueName = resolvedIssueName;
+    const planPath = resolvedPlanPath;
     // Plan-branch flow: guarantee the feature branch exists on origin with the
     // current plan content BEFORE anything else — the beforeLaunch hook below
     // may register branch-scoped external resources (e.g. Vercel Preview env
@@ -791,7 +1042,7 @@ async function launchSingleRepo(repoConfig, repoRoot, issueName, planPath, optio
     // that only exist on origin/main.
     let planBranch;
     try {
-        const ensured = await ensurePlanBranch(repoConfig, planPath, issueName, repoRoot);
+        const ensured = await ensurePlanBranch(repoConfig, planPath, issueName, repoRoot, planBranchOpts);
         planBranch = ensured.branch;
         if (ensured.created) {
             logger.success(`Branch '${ensured.branch}' created on origin with the plan`);
@@ -1009,6 +1260,18 @@ async function launchSingleRepo(repoConfig, repoRoot, issueName, planPath, optio
         containerResources = { cpu, memory, disk };
         logger.log(`  Container Resources: cpu=${cpu} memory=${memory}GiB disk=${disk}GiB`);
     }
+    // Resolve the sandbox profile: --sandbox-profile, then config, then base.
+    const profileResult = resolveSandboxProfile(options.sandboxProfile, repoConfig.sandboxProfile);
+    if (profileResult.error) {
+        logger.error(profileResult.error);
+        if (isGroup)
+            return { ok: false, message: profileResult.error };
+        process.exit(1);
+    }
+    const sandboxProfile = sandboxProfileForRequest(profileResult.profile);
+    if (sandboxProfile) {
+        logger.log(`  Sandbox Profile: ${describeSandboxProfile(sandboxProfile)}`);
+    }
     // Resolve the GitHub token: shared (group mode) or loaded (single mode).
     const githubToken = ctx.skipTokenLoad
         ? ctx.githubToken
@@ -1124,6 +1387,7 @@ async function launchSingleRepo(repoConfig, repoRoot, issueName, planPath, optio
         clientSessionId: clientSessionId ?? undefined,
         provider: { type: providerType, authToken },
         containerResources,
+        sandboxProfile,
         updateNotificationUrl,
         updateNotificationNameTag,
         githubToken,
@@ -1132,6 +1396,11 @@ async function launchSingleRepo(repoConfig, repoRoot, issueName, planPath, optio
         // plan committed) exists on origin, so the server must check out the
         // existing branch instead of creating one from the base branch.
         branchExists: true,
+        // Launch-from-existing linkage (undefined unless --issue / --pr / --base).
+        issueNumber: sourceBody.issueNumber,
+        prNumber: sourceBody.prNumber,
+        headBranch: sourceBody.headBranch,
+        baseBranch: sourceBody.baseBranch,
     });
     try {
         const response = await axios.post(endpoint, requestBody, {
@@ -1139,7 +1408,10 @@ async function launchSingleRepo(repoConfig, repoRoot, issueName, planPath, optio
                 'Content-Type': 'application/json',
                 Authorization: `Bearer ${apiKey}`,
             },
-            timeout: 30000, // 30 second timeout
+            // The launch route does GitHub, credential and DB work before it answers;
+            // 30s was shorter than the server's own limit and dropped launches on a
+            // slow (cold) server. See LAUNCH_REQUEST_TIMEOUT_MS.
+            timeout: LAUNCH_REQUEST_TIMEOUT_MS,
         });
         if (response.data.success) {
             // killAndRelaunch over an active task: note the cancellation before the
@@ -1149,13 +1421,15 @@ async function launchSingleRepo(repoConfig, repoRoot, issueName, planPath, optio
             }
             logger.success(response.data.message);
             logger.blank();
+            // Link to the dashboard of the server we launched on, so a preview or
+            // self-hosted launch is not sent to hublaunch.site.
+            const dashboardUrl = `${serverUrl.replace(/\/$/, '')}/dashboard`;
             if (response.data.planId) {
-                const planUrl = `https://www.hublaunch.site/dashboard/plans/${response.data.planId}`;
                 logger.info(`Plan ID: ${response.data.planId}`);
-                logger.info(`Track it: ${planUrl}`);
+                logger.info(`Track it: ${dashboardUrl}/plans/${response.data.planId}`);
             }
             else {
-                logger.info('Track it: https://www.hublaunch.site/dashboard');
+                logger.info(`Track it: ${dashboardUrl}`);
             }
             if (!updateNotificationUrl) {
                 logger.info('Set updateNotificationUrl in your local hublaunch.config.js file to be able to get update messages about the status.');
@@ -1663,7 +1937,9 @@ function describeLaunchAxiosError(error, serverUrl, issueName, planPath) {
             return { message: `Cannot connect to server at ${serverUrl}` };
         }
         if (error.code === 'ETIMEDOUT' || error.code === 'ECONNABORTED') {
-            return { message: 'Request timed out' };
+            return {
+                message: `Request timed out. The launch may still have been queued: check with \`hula info ${issueName} --lastLogs\` before retrying.`,
+            };
         }
         return { message: `Network error: ${error.message}` };
     }
@@ -1698,6 +1974,11 @@ function handleLaunchAxiosError(error, serverUrl, issueName, planPath) {
                         serverUrl,
                         serverError: data.error,
                         actionUrl: data.buyCreditsUrl || data.upgradeUrl,
+                        refusal: data.buyCreditsUrl
+                            ? 'credits'
+                            : data.upgradeUrl
+                                ? 'plan'
+                                : undefined,
                     });
                     break;
                 case 403:
@@ -1724,7 +2005,7 @@ function handleLaunchAxiosError(error, serverUrl, issueName, planPath) {
         }
         else if (error.code === 'ETIMEDOUT' || error.code === 'ECONNABORTED') {
             logger.error('Request timed out');
-            logger.info('The server may be slow or unreachable.');
+            logger.info(`The server may be slow or unreachable. The launch may still have been queued: check with \`hula info ${issueName} --lastLogs\`. Re-running is safe; a launch that did queue is reported as already running.`);
         }
         else {
             logger.error(`Network error: ${error.message}`);