ticketlens 0.1.0

package/skills/jtb/scripts/lib/license.mjs

@@ -0,0 +1,195 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import crypto from 'node:crypto';
+import { DEFAULT_CONFIG_DIR } from './config.mjs';
+import { createStyler } from './ansi.mjs';
+
+export const LICENSE_TIERS = { free: 0, pro: 1, team: 2 };
+const LICENSE_FILE = 'license.json';
+const REVALIDATION_DAYS = 7;   // attempt background revalidation after this many days
+const GRACE_DAYS = 30;          // treat license as invalid if not revalidated within this window
+const UPGRADE_URL = 'https://ticketlens.dev/pricing';
+
+const ANSI_RE_LIC = /\x1b\[[0-9;]*m|\x1b\]8;[^\x07]*\x07/g;
+const visLen = (s) => s.replace(ANSI_RE_LIC, '').length;
+function padInner(str, width) {
+  return str + ' '.repeat(Math.max(0, width - visLen(str)));
+}
+
+export function readLicense(configDir = DEFAULT_CONFIG_DIR) {
+  const filePath = path.join(configDir, LICENSE_FILE);
+  try {
+    const data = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    const { sig, ...payload } = data;
+    // Legacy unsigned files are trusted; will be re-signed on next write
+    if (!sig) return payload;
+    const expected = crypto.createHmac('sha256', payload.key || '')
+      .update(JSON.stringify(payload)).digest('hex');
+    return crypto.timingSafeEqual(Buffer.from(sig), Buffer.from(expected)) ? payload : null;
+  } catch {
+    return null;
+  }
+}
+
+export function writeLicense(data, configDir = DEFAULT_CONFIG_DIR) {
+  fs.mkdirSync(configDir, { recursive: true });
+  const filePath = path.join(configDir, LICENSE_FILE);
+  const { sig: _, ...payload } = data; // strip any existing sig before re-signing
+  const mac = crypto.createHmac('sha256', payload.key || '')
+    .update(JSON.stringify(payload)).digest('hex');
+  fs.writeFileSync(filePath, JSON.stringify({ ...payload, sig: mac }), 'utf8');
+  fs.chmodSync(filePath, 0o600);
+}
+
+export function isLicensed(tier, configDir = DEFAULT_CONFIG_DIR) {
+  const required = LICENSE_TIERS[tier] ?? 0;
+  if (required === 0) return true;
+
+  const license = readLicense(configDir);
+  if (!license) return false;
+
+  // Hard expiry — subscription cancelled, confirmed by server
+  if (license.expiresAt && new Date(license.expiresAt) < new Date()) return false;
+
+  // Offline grace period — reject if not revalidated within GRACE_DAYS
+  if (license.validatedAt) {
+    const daysSince = (Date.now() - new Date(license.validatedAt)) / 86400000;
+    if (daysSince > GRACE_DAYS) return false;
+  }
+
+  const actual = LICENSE_TIERS[license.tier] ?? 0;
+  return actual >= required;
+}
+
+/**
+ * Fire-and-forget background revalidation. Call at CLI startup; never awaited.
+ * Silently updates license.json when the validation window has elapsed.
+ */
+export function revalidateIfStale(opts = {}) {
+  const { configDir = DEFAULT_CONFIG_DIR, fetcher = globalThis.fetch } = opts;
+  const license = readLicense(configDir);
+  if (!license?.key || !license?.validatedAt) return;
+  const daysSince = (Date.now() - new Date(license.validatedAt)) / 86400000;
+  if (daysSince < REVALIDATION_DAYS) return;
+  revalidateLicense({ configDir, fetcher }).catch(() => {});
+}
+
+/**
+ * Styled upsell prompt — written to stderr, never pollutes stdout.
+ */
+export function showUpgradePrompt(requiredTier, featureFlag, { stream = process.stderr } = {}) {
+  const s = createStyler({ isTTY: stream.isTTY });
+  const tier = requiredTier.charAt(0).toUpperCase() + requiredTier.slice(1);
+  const W = 44; // inner width
+  const bc = (t) => s.dim(t);
+
+  const featureLine = padInner(` ${s.yellow('◆')} ${s.bold(featureFlag)} requires ${s.bold(s.cyan(tier))}`, W);
+  const upgradeLine = padInner(`  ${s.dim('Upgrade:')}  ${s.link(UPGRADE_URL, s.cyan(UPGRADE_URL))}`, W);
+  const activateLine = padInner(`  ${s.dim('Or run:')}   ${s.dim('ticketlens activate <KEY>')}`, W);
+  const blank = ' '.repeat(W);
+
+  stream.write('\n');
+  stream.write(`  ${bc('┌' + '─'.repeat(W) + '┐')}\n`);
+  stream.write(`  ${bc('│')}${featureLine}${bc('│')}\n`);
+  stream.write(`  ${bc('│')}${blank}${bc('│')}\n`);
+  stream.write(`  ${bc('│')}${upgradeLine}${bc('│')}\n`);
+  stream.write(`  ${bc('│')}${activateLine}${bc('│')}\n`);
+  stream.write(`  ${bc('└' + '─'.repeat(W) + '┘')}\n`);
+  stream.write('\n');
+}
+
+const LEMONSQUEEZY_ACTIVATE_URL = 'https://api.lemonsqueezy.com/v1/licenses/activate';
+const LEMONSQUEEZY_VALIDATE_URL = 'https://api.lemonsqueezy.com/v1/licenses/validate';
+
+function extractTier(meta) {
+  if (!meta) return 'pro';
+  const name = (meta.variant_name || meta.product_name || '').toLowerCase();
+  if (name.includes('team')) return 'team';
+  return 'pro';
+}
+
+export async function activateLicense(key, opts = {}) {
+  const { configDir = DEFAULT_CONFIG_DIR, fetcher = globalThis.fetch, instanceName } = opts;
+  const instance = instanceName || os.hostname();
+
+  try {
+    const res = await fetcher(LEMONSQUEEZY_ACTIVATE_URL, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
+      body: JSON.stringify({ license_key: key, instance_name: instance }),
+    });
+
+    const data = await res.json();
+
+    if (!data.activated && !data.valid) {
+      return { success: false, error: data.error || data.message || 'Invalid license key.' };
+    }
+
+    const meta = data.meta || {};
+    const tier = extractTier(meta);
+
+    const license = {
+      key: data.license_key?.key || key,
+      tier,
+      email: meta.customer_email || null,
+      provider: 'lemonsqueezy',
+      instanceId: data.instance?.id || null,
+      validatedAt: new Date().toISOString(),
+      ...(meta.ends_at ? { expiresAt: meta.ends_at } : {}),
+    };
+
+    writeLicense(license, configDir);
+    return { success: true, tier, email: license.email };
+  } catch (err) {
+    return { success: false, error: err.message };
+  }
+}
+
+export async function revalidateLicense(opts = {}) {
+  const { configDir = DEFAULT_CONFIG_DIR, fetcher = globalThis.fetch, instanceName } = opts;
+  const license = readLicense(configDir);
+  if (!license) return { success: false, error: 'No license found.' };
+
+  const instance = instanceName || os.hostname();
+
+  try {
+    const res = await fetcher(LEMONSQUEEZY_VALIDATE_URL, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
+      body: JSON.stringify({ license_key: license.key, instance_name: instance }),
+    });
+
+    const data = await res.json();
+
+    if (!data.valid) {
+      license.expiresAt = new Date().toISOString();
+      writeLicense(license, configDir);
+      return { success: false, error: 'License is no longer valid.' };
+    }
+
+    license.validatedAt = new Date().toISOString();
+    if (data.meta?.ends_at) license.expiresAt = data.meta.ends_at;
+    else delete license.expiresAt;
+    writeLicense(license, configDir);
+    return { success: true, tier: license.tier };
+  } catch {
+    return { success: true, tier: license.tier, cached: true };
+  }
+}
+
+export function checkLicense(configDir = DEFAULT_CONFIG_DIR) {
+  const license = readLicense(configDir);
+  if (!license) return { tier: 'free', active: false };
+
+  const expired = license.expiresAt ? new Date(license.expiresAt) < new Date() : false;
+
+  return {
+    tier: license.tier,
+    active: !expired,
+    expired,
+    email: license.email,
+    key: license.key,
+    validatedAt: license.validatedAt,
+  };
+}

package/skills/jtb/scripts/lib/pr-assembler.mjs

@@ -0,0 +1,186 @@
+/**
+ * Ticket-to-PR Assembler
+ * Composes a markdown PR description from ticket data, linked commits,
+ * requirements, and compliance coverage.
+ */
+
+import { spawnSync } from 'node:child_process';
+import { fetchTicket } from './jira-client.mjs';
+import { extractRequirements } from './requirement-extractor.mjs';
+import { findLinkedCommits } from './commit-linker.mjs';
+import { runComplianceCheck } from './compliance-checker.mjs';
+import { DEFAULT_CONFIG_DIR } from './config.mjs';
+
+/**
+ * Detect the git remote URL using execFn.
+ * Returns the URL string or null if none detected.
+ *
+ * @param {Function} execFn - injectable spawnSync-compatible function
+ * @returns {string|null}
+ */
+function detectRemoteUrl(execFn) {
+  try {
+    const result = execFn('git', ['remote', 'get-url', 'origin'], { encoding: 'utf8' });
+    if (result.status === 0 && result.stdout) {
+      return result.stdout.trim();
+    }
+  } catch {
+    // non-fatal
+  }
+  return null;
+}
+
+/**
+ * Build the "### Linked tickets" section from a ticket's linkedIssues.
+ *
+ * @param {Array} linkedIssues - array of { key, summary, linkType, direction }
+ * @returns {string} section markdown or empty string
+ */
+function buildLinkedTicketsSection(linkedIssues) {
+  if (!linkedIssues || linkedIssues.length === 0) return '';
+
+  const lines = ['', '### Linked tickets'];
+  for (const issue of linkedIssues) {
+    const rel = issue.linkType ?? issue.direction ?? 'Linked';
+    lines.push(`- ${issue.key}: ${rel} — ${issue.summary}`);
+  }
+  return lines.join('\n');
+}
+
+/**
+ * Build the "### Requirements coverage" section.
+ *
+ * @param {object|null} complianceResult - result from runComplianceCheckFn or null
+ * @param {string[]} requirements - raw requirements list
+ * @returns {string} section markdown
+ */
+function buildCoverageSection(complianceResult, requirements) {
+  if (complianceResult === null) {
+    const lines = ['', '### Requirements coverage (coverage unavailable — Pro required)'];
+    for (const req of requirements) {
+      lines.push(`- ${req}`);
+    }
+    return lines.join('\n');
+  }
+
+  const { coveragePercent, report } = complianceResult;
+  const lines = [``, `### Requirements coverage (${coveragePercent}%)`];
+
+  for (const entry of report) {
+    if (entry.covered) {
+      const loc = entry.location ? ` (${entry.location})` : '';
+      lines.push(`- ✔ ${entry.req}${loc}`);
+    } else {
+      lines.push(`- ✖ ${entry.req}`);
+    }
+  }
+
+  // Include any missing reqs not already in report
+  if (complianceResult.missing && complianceResult.missing.length > 0) {
+    const reportedReqs = new Set(report.map(r => r.req));
+    for (const missed of complianceResult.missing) {
+      if (!reportedReqs.has(missed)) {
+        lines.push(`- ✖ ${missed}`);
+      }
+    }
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Assemble a markdown PR description for the given ticket key.
+ *
+ * @param {string} ticketKey - e.g. 'PROJ-123'
+ * @param {object} opts - injectable dependencies
+ * @param {string} [opts.configDir] - config directory path
+ * @param {Function} [opts.fetchTicketFn] - async fn(ticketKey, opts) → ticket
+ * @param {Function} [opts.extractRequirementsFn] - fn(text) → string[]
+ * @param {Function} [opts.findLinkedCommitsFn] - async fn(ticketKey, opts) → commit[]
+ * @param {Function} [opts.runComplianceCheckFn] - async fn({ brief, ticketKey, configDir }) → result|null
+ * @param {Function} [opts.execFn] - spawnSync-compatible for git remote detection
+ * @param {object} [opts.stream] - stderr for progress output (optional)
+ * @returns {Promise<string>} markdown PR description
+ */
+export async function assemblePr(ticketKey, {
+  configDir = DEFAULT_CONFIG_DIR,
+  cwd = process.cwd(),
+  fetchTicketFn = fetchTicket,
+  extractRequirementsFn = extractRequirements,
+  findLinkedCommitsFn = findLinkedCommits,
+  runComplianceCheckFn = runComplianceCheck,
+  execFn = spawnSync,
+  stream,
+} = {}) {
+  // Fetch ticket data
+  const ticket = await fetchTicketFn(ticketKey, { configDir });
+
+  const summary = ticket.summary ?? ticket.fields?.summary ?? '';
+  const description = ticket.description ?? ticket.fields?.description ?? '';
+  const linkedIssues = ticket.linkedIssues ?? ticket.fields?.issuelinks ?? [];
+
+  // Extract requirements from description
+  const requirements = extractRequirementsFn(description);
+
+  // Find linked commits
+  const { commits = [], branches = [] } = await findLinkedCommitsFn(ticketKey, { cwd });
+
+  // Build a minimal plain-text brief for compliance check input
+  const brief = `## ${ticketKey}: ${summary}\n\n${description}`;
+
+  // Run compliance check (may return null for non-Pro)
+  let complianceResult = null;
+  try {
+    complianceResult = await runComplianceCheckFn({ brief, ticketKey, configDir });
+  } catch {
+    // non-fatal — treat as unavailable
+  }
+
+  // Detect remote URL for auto-close footer
+  const remoteUrl = detectRemoteUrl(execFn);
+  const isGitHubOrGitLab = remoteUrl && (
+    remoteUrl.includes('github.com') || remoteUrl.includes('gitlab.com')
+  );
+
+  // Build output
+  const lines = [`## ${ticketKey}: ${summary}`, ''];
+
+  // What changed — commits are raw git --oneline strings: "<sha> <message>"
+  lines.push('### What changed');
+  if (commits.length === 0) {
+    lines.push('_No linked commits found._');
+  } else {
+    for (const commitLine of commits) {
+      lines.push(`- ${commitLine}`);
+    }
+  }
+
+  // Requirements coverage
+  lines.push(buildCoverageSection(complianceResult, requirements));
+
+  // Acceptance criteria
+  lines.push('');
+  lines.push('### Acceptance criteria');
+  if (requirements.length === 0) {
+    lines.push('_No acceptance criteria found._');
+  } else {
+    for (const req of requirements) {
+      lines.push(`- ${req}`);
+    }
+  }
+
+  // Linked tickets (optional section)
+  const linkedSection = buildLinkedTicketsSection(linkedIssues);
+  if (linkedSection) {
+    lines.push(linkedSection);
+  }
+
+  // Close footer
+  if (isGitHubOrGitLab) {
+    lines.push('');
+    lines.push('---');
+    lines.push(`Closes ${ticketKey}`);
+  }
+
+  return lines.join('\n');
+}

package/skills/jtb/scripts/lib/profile-picker.mjs

@@ -0,0 +1,216 @@
+/**
+ * Interactive profile pickers.
+ * - promptProfileSelect: "profile not found" error recovery.
+ * - promptProfileMismatch: ticket prefix not configured in any profile.
+ * Both fall back to static output on non-TTY.
+ */
+
+import { createStyler } from './ansi.mjs';
+import { runRawSelect } from './select-prompt.mjs';
+
+export function promptProfileSelect({ profileName, suggestion, available }, { stream = process.stderr } = {}) {
+  const s = createStyler({ isTTY: stream.isTTY });
+  const isTTY = stream.isTTY;
+
+  // Static header (written once)
+  stream.write('\n');
+  stream.write(`  ${s.red('✖')} Profile ${s.bold(`"${profileName}"`)} not found.\n`);
+  if (suggestion) {
+    stream.write(`\n  ${s.dim('Did you mean?')}  ${s.brand(suggestion)}\n`);
+  }
+  stream.write(`\n  ${s.dim('Select a profile:')}\n\n`);
+
+  // Non-TTY: just list profiles and exit
+  if (!isTTY || !process.stdin.setRawMode) {
+    for (const name of available) {
+      stream.write(`    ${s.brand('›')} ${name}\n`);
+    }
+    stream.write('\n');
+    return Promise.resolve(null);
+  }
+
+  const initialIndex = suggestion ? Math.max(0, available.indexOf(suggestion)) : 0;
+
+  function renderFn(selected) {
+    const lines = [];
+    for (let i = 0; i < available.length; i++) {
+      const marker = i === selected ? s.brand('❯') : ' ';
+      const label = i === selected ? s.bold(s.brand(available[i])) : available[i];
+      lines.push(`    ${marker} ${label}`);
+    }
+    lines.push('');
+    lines.push(`  ${s.dim('↑/↓ select   Enter confirm   q/Esc cancel')}`);
+    stream.write(lines.join('\n') + '\n');
+    return lines.length;
+  }
+
+  return runRawSelect({ count: available.length, initialIndex, renderFn, stream })
+    .then(index => {
+      if (index === null) return null;
+      stream.write(`  ${s.green('✔')} Using profile ${s.bold(s.brand(available[index]))}\n\n`);
+      return available[index];
+    });
+}
+
+/**
+ * Prompts the user to choose between multiple profiles that all share the
+ * same ticket prefix. Shown before the fetch attempt when ambiguity exists.
+ *
+ * @param {string} ticketKey   e.g. "PROJ-123"
+ * @param {Array<{name:string, baseUrl:string|null}>} profiles  matching profiles
+ * @param {{ stream?: NodeJS.WriteStream }} [opts]
+ * @returns {Promise<string|null>}   chosen profile name, or null if cancelled
+ */
+export function promptMultipleMatches(ticketKey, profiles, { stream = process.stderr } = {}) {
+  const s = createStyler({ isTTY: stream.isTTY });
+  const prefix = ticketKey.split('-')[0];
+
+  stream.write('\n');
+  stream.write(`  ${s.cyan('●')}  ${s.bold(plural(profiles.length, 'profile'))} match prefix ${s.bold(s.cyan(prefix))} — which should handle ${s.dim(ticketKey)}?\n\n`);
+
+  if (!stream.isTTY || !process.stdin.setRawMode) {
+    for (const p of profiles) {
+      const sub = p.baseUrl ? `  ${s.dim(p.baseUrl)}` : '';
+      stream.write(`    ${s.cyan('›')} ${p.name}${sub}\n`);
+    }
+    stream.write(`\n  ${s.dim(`→ Re-run with --profile=NAME to skip this prompt`)}\n\n`);
+    return Promise.resolve(null);
+  }
+
+  function renderFn(selected) {
+    const lines = [];
+    for (let i = 0; i < profiles.length; i++) {
+      const p = profiles[i];
+      const isSelected = i === selected;
+      const marker = isSelected ? s.blue('❯') : ' ';
+      const label = isSelected ? s.bold(s.blue(p.name)) : p.name;
+      lines.push(`    ${marker} ${label}`);
+      if (p.baseUrl) lines.push(`      ${s.dim(p.baseUrl)}`);
+    }
+    lines.push('');
+    lines.push(`  ${s.dim('↑/↓ select   Enter confirm   Esc cancel')}`);
+    stream.write(lines.join('\n') + '\n');
+    return lines.length;
+  }
+
+  return runRawSelect({ count: profiles.length, initialIndex: 0, renderFn, stream })
+    .then(index => {
+      if (index === null) return null;
+      const picked = profiles[index].name;
+      stream.write(`  ${s.green('✔')} Using ${s.bold(s.cyan(picked))}\n\n`);
+      return picked;
+    });
+}
+
+function plural(n, word) {
+  return `${n} ${word}${n === 1 ? '' : 's'}`;
+}
+
+/**
+ * Prompts the user to pick a profile when the ticket's prefix isn't
+ * configured in any profile. The resolved profile is pre-selected.
+ *
+ * @param {string} ticketKey         e.g. "ECNT-3888"
+ * @param {string} currentProfile    name of the auto-resolved profile
+ * @param {Array<{name:string, baseUrl:string|null}>} profiles  all known profiles
+ * @param {{ stream?: NodeJS.WriteStream }} [opts]
+ * @returns {Promise<string|null>}   picked profile name, or null to keep current
+ */
+export function promptProfileMismatch(ticketKey, currentProfile, profiles, { stream = process.stderr } = {}) {
+  const s = createStyler({ isTTY: stream.isTTY });
+  const prefix = ticketKey.split('-')[0];
+
+  stream.write('\n');
+  stream.write(`  ${s.yellow('⚠')}  No profile is configured for ${s.bold(s.cyan(prefix))} tickets.\n`);
+  stream.write(`  ${s.dim('Currently using:')} ${s.cyan(currentProfile)}\n`);
+  stream.write(`\n  ${s.dim(`Which profile should handle ${ticketKey}?`)}\n\n`);
+
+  if (!stream.isTTY || !process.stdin.setRawMode) {
+    for (const p of profiles) {
+      const sub = p.baseUrl ? `  ${s.dim(p.baseUrl)}` : '';
+      stream.write(`    ${s.cyan('›')} ${p.name}${sub}\n`);
+    }
+    stream.write(`\n  ${s.dim(`→ Re-run with --profile=NAME to skip this prompt`)}\n\n`);
+    return Promise.resolve(null);
+  }
+
+  const initialIndex = Math.max(0, profiles.findIndex(p => p.name === currentProfile));
+
+  function renderFn(selected) {
+    const lines = [];
+    for (let i = 0; i < profiles.length; i++) {
+      const p = profiles[i];
+      const isSelected = i === selected;
+      const marker = isSelected ? s.blue('❯') : ' ';
+      const label = isSelected ? s.bold(s.blue(p.name)) : p.name;
+      lines.push(`    ${marker} ${label}`);
+      if (p.baseUrl) lines.push(`      ${s.dim(p.baseUrl)}`);
+    }
+    lines.push('');
+    lines.push(`  ${s.dim(`↑/↓ select   Enter confirm   Esc  continue with ${currentProfile}`)}`);
+    stream.write(lines.join('\n') + '\n');
+    return lines.length;
+  }
+
+  return runRawSelect({ count: profiles.length, initialIndex, renderFn, stream })
+    .then(index => {
+      if (index === null) return null;
+      const picked = profiles[index].name;
+      if (picked === currentProfile) {
+        stream.write(`  ${s.dim(`Continuing with ${s.cyan(picked)}`)}\n\n`);
+      } else {
+        stream.write(`  ${s.green('✔')} Using ${s.bold(s.cyan(picked))} for this fetch\n\n`);
+      }
+      return picked;
+    });
+}
+
+/**
+ * Simple profile selector for the connection-retry flow.
+ * No prefix-warning header — just "switch to which profile?".
+ *
+ * @param {string} currentProfile
+ * @param {Array<{name:string, baseUrl:string|null}>} profiles
+ * @param {{ stream?: NodeJS.WriteStream }} [opts]
+ * @returns {Promise<string|null>}
+ */
+export function promptSwitchProfile(currentProfile, profiles, { stream = process.stderr } = {}) {
+  const s = createStyler({ isTTY: stream.isTTY });
+
+  stream.write(`\n  ${s.dim('Switch to which profile?')}\n\n`);
+
+  if (!stream.isTTY || !process.stdin.setRawMode) {
+    for (const p of profiles) {
+      const sub = p.baseUrl ? `  ${s.dim(p.baseUrl)}` : '';
+      stream.write(`    ${s.cyan('›')} ${p.name}${sub}\n`);
+    }
+    stream.write(`\n  ${s.dim(`→ Re-run with --profile=NAME to specify directly`)}\n\n`);
+    return Promise.resolve(null);
+  }
+
+  const initialIndex = Math.max(0, profiles.findIndex(p => p.name === currentProfile));
+
+  function renderFn(selected) {
+    const lines = [];
+    for (let i = 0; i < profiles.length; i++) {
+      const p = profiles[i];
+      const isSelected = i === selected;
+      const marker = isSelected ? s.blue('❯') : ' ';
+      const label = isSelected ? s.bold(s.blue(p.name)) : p.name;
+      lines.push(`    ${marker} ${label}`);
+      if (p.baseUrl) lines.push(`      ${s.dim(p.baseUrl)}`);
+    }
+    lines.push('');
+    lines.push(`  ${s.dim('↑/↓ select   Enter confirm   Esc cancel')}`);
+    stream.write(lines.join('\n') + '\n');
+    return lines.length;
+  }
+
+  return runRawSelect({ count: profiles.length, initialIndex, renderFn, stream })
+    .then(index => {
+      if (index === null) return null;
+      const picked = profiles[index].name;
+      stream.write(`  ${s.green('✔')} Switching to ${s.bold(s.cyan(picked))}\n\n`);
+      return picked;
+    });
+}