storebound/cli/doctor.ts

// What this machine has for storebound, and how to get what is missing. The same detection as the desktop app's
// Dependencies screen (lib/tools.ts). Store work (listings, products, releases, reviews) needs none of these tools;
// screenshots, app previews, icons and simulator / emulator captures do. Read-only: it prints commands, it runs none.
//   storebound doctor [--dir .] [--json]
//   storebound doctor --install <tool> [--yes]   runs this OS's install command for one tool (winget / brew / apt);
//                                                without --yes only prints it. Never sudo, never an admin prompt.
import { existsSync } from 'node:fs';
import { join, resolve } from 'node:path';
import pkg from '../package.json' with { type: 'json' };
import type { Args } from './lib/args';
import { CONFIG_NAMES } from './lib/config';
import { credentialStatus, maskUser } from './lib/credentials';
import { type PlayCredentials, playCredentials } from './lib/google-auth';
import { log, printJson } from './lib/log';
import { textTable } from './lib/table';
import { androidSdk, type AndroidSdkLookup, detectTools, findPlaywright, installCommands, type ToolStatus } from './lib/tools';
import * as rt from './lib/rt';
import { foreignRsync } from './lib/xcode';

export interface DoctorRow {
  id: ToolStatus['id'] | 'playwright';
  name: string;
  found: boolean;
  version: string | null;
  path: string | null;
  source: ToolStatus['source'];
  usedFor: string;
  /** The version the project needs and ok / missing / outdated. */
  required?: string | null;
  status?: 'ok' | 'missing' | 'outdated';
  /** Install commands for this OS (empty when found). */
  install: string[];
  url: string | null;
}
export interface DoctorResult {
  storebound: string; bun: string | null; runtime: string; platform: string; project: string | null; tools: DoctorRow[]; missing: number;
  /** The Android SDK `play build` hands to Gradle, where it came from, and every place looked at. */
  androidSdk: AndroidSdkLookup;
  /** Store credentials of the project folder (env, .storebound/credentials.json, profile): set, missing or
   *  placeholder (a template value, treated as missing). Never the values. */
  credentials: { key: string; status: 'set' | 'missing' | 'placeholder' }[];
  /** Where Play tokens come from: the credential broker (~/.storebound/broker.json) or the local key file; the
   *  e-mail masked, never a key. */
  play: PlayCredentials;
  /** macOS: a non-Apple rsync first on PATH (Homebrew 3.x breaks Xcode's exportArchive, pitfall 54), else null. */
  foreignRsync: string | null;
}

export function doctor(cwd: string, env: Record<string, string | undefined> = process.env): DoctorResult {
  const tools: DoctorRow[] = detectTools(env, cwd).map(t => ({ id: t.id, name: t.name, found: t.found, version: t.version, path: t.path, source: t.source, usedFor: t.usedFor,
    required: t.required ?? null, status: t.status, install: t.status === 'ok' ? [] : installCommands(t.id), url: t.install.url }));
  const pw = findPlaywright([cwd, rt.packageRoot()]);
  tools.splice(3, 0, { id: 'playwright', name: 'playwright', found: !!pw, version: null, path: pw, source: pw ? 'system' : null,
    usedFor: 'screenshot renders and web captures from a terminal (the desktop app brings its own)', install: pw ? [] : installCommands('playwright'), url: 'https://playwright.dev/docs/intro' });
  const project = CONFIG_NAMES.some(n => existsSync(join(cwd, n))) ? cwd : null;
  const sdk = androidSdk([join(cwd, 'android'), cwd], env);
  return { storebound: pkg.version, bun: rt.bunVersion, runtime: `${rt.runtime.name} ${rt.runtime.version}`, platform: `${process.platform}-${process.arch}`, project, tools, missing: tools.filter(t => !t.found || t.status === 'outdated').length, androidSdk: sdk, credentials: credentialStatus(cwd), play: maskedPlay(cwd),
    foreignRsync: process.platform === 'darwin' ? foreignRsync(env.PATH) : null };
}

function maskedPlay(cwd: string): PlayCredentials {
  const p = playCredentials(cwd);
  return { ...p, principal: p.principal ? maskUser(p.principal) : null };
}

/** The one line about Play access: which source, and the broker's state. */
export function playLine(p: PlayCredentials): string {
  const who = p.principal ? ` for ${p.principal}` : '';
  if (p.source === 'broker') return `Play: tokens from the credential broker ${p.broker!.url}${who}${p.local ? ' (local key as fallback)' : ''}`;
  const broken = p.broker?.error ? ` · credential broker not usable: ${p.broker.error}` : '';
  if (p.source === 'file') return `Play: local service account key${who}${broken}`;
  return `Play: no service account key and no credential broker${broken}`;
}

/** One install command of a tool, run only with --yes; sudo / admin commands are printed, never run. */
export function installPlan(r: DoctorResult, id: string, platform: NodeJS.Platform = process.platform): { tool: DoctorRow; command: string | null; runnable: boolean } {
  const tool = r.tools.find(t => t.id === id);
  if (!tool) throw new Error(`doctor --install: no tool "${id}" (one of ${r.tools.map(t => t.id).join(', ')})`);
  const command = installCommands(tool.id, platform)[0] ?? null;
  return { tool, command, runnable: !!command && !/^sudo |\| *(ba)?sh|^Install /.test(command) };
}

export async function run(args: Args): Promise<void> {
  const r = doctor(resolve(args.str('dir', '.')));
  const want = args.get('install');
  if (want) {
    const plan = installPlan(r, want);
    if (plan.tool.status === 'ok') { log('doctor', `${plan.tool.name} ${plan.tool.version ?? ''} is already here${plan.tool.required ? ` (the project needs ${plan.tool.required})` : ''}`); return; }
    if (!plan.command) throw new Error(`doctor --install: no install command for ${plan.tool.name} on this OS: ${plan.tool.url}`);
    if (!plan.runnable || !args.has('yes')) {
      log('doctor', `would run: ${plan.command}${plan.runnable ? ' (add --yes to run it)' : ' (needs admin rights: run it yourself)'}`);
      return;
    }
    log('doctor', `installing ${plan.tool.name}: ${plan.command}`);
    const p = rt.spawnSync(plan.command.split(/\s+/), { stdout: 'inherit', stderr: 'inherit', timeout: 20 * 60_000 });
    if (!p.success) throw new Error(`${plan.command} failed (exit ${p.exitCode}); open a new terminal if it installed but is not on PATH yet`);
    const after = doctor(resolve(args.str('dir', '.'))).tools.find(t => t.id === plan.tool.id);
    log('doctor', `${plan.tool.name}: ${after?.status ?? 'unknown'}${after?.version ? ` ${after.version}` : ''} (a new terminal may be needed for PATH)`);
    return;
  }
  if (args.has('json')) { printJson(r); return; }
  log('doctor', `storebound ${r.storebound} · ${r.runtime} · ${r.platform}${r.project ? ' · project config found' : ''}`);
  const rows = r.tools.map(t => [t.name, t.status === 'outdated' ? 'too old' : t.found ? (t.source === 'app' ? 'ok (app copy)' : 'ok') : 'missing', (t.version ?? '').slice(0, 16), t.required ?? '', t.usedFor]);
  // at a terminal the last column is cut to the window width, so rows never wrap (piped output stays whole)
  const cols = process.stdout.isTTY ? process.stdout.columns : 0;
  if (cols) {
    const w = (i: number) => Math.max(...[['tool', 'status', 'version', 'needs'][i]!, ...rows.map(x => x[i]!)].map(s => s.length));
    const room = cols - [0, 1, 2, 3].reduce((n, i) => n + w(i) + 2, 0) - 1;
    for (const x of rows) if (x[4]!.length > room) x[4] = room > 8 ? `${x[4]!.slice(0, room - 1)}…` : '';
  }
  console.log(textTable(['tool', 'status', 'version', 'needs', 'used for'], rows));
  log('doctor', r.androidSdk.path ? `Android SDK: ${r.androidSdk.path} (from ${r.androidSdk.source})`
    : `Android SDK: not found (play build needs it). Checked: ${r.androidSdk.checked.join('; ')}`);
  const set = r.credentials.filter(c => c.status === 'set').map(c => c.key), ph = r.credentials.filter(c => c.status === 'placeholder').map(c => c.key);
  log('doctor', `credentials: ${set.length ? set.join(', ') : 'none set'}${ph.length ? ` · placeholders (treated as missing): ${ph.join(', ')}` : ''}`);
  log('doctor', playLine(r.play));
  if (r.foreignRsync) log('doctor', `rsync: ${r.foreignRsync} is first on PATH and breaks Xcode exportArchive ("Copy failed") outside storebound; storebound apple build puts /usr/bin first. Fix for everything else: brew unlink rsync, or put /usr/bin before it`);
  const missing = r.tools.filter(t => !t.found || t.status === 'outdated');
  if (!missing.length) { log('doctor', 'everything storebound can use is here'); return; }
  console.log('\nTo install what is missing (storebound doctor --install <tool> --yes runs the first one; sudo / admin ones you run yourself):');
  for (const t of missing) {
    console.log(`  ${t.name}`);
    for (const c of t.install) console.log(`    ${c}`);
    if (t.url) console.log(`    ${t.url}`);
  }
  log('doctor', `${missing.length} missing. Store work needs none of them; screenshots, previews, icons and captures do.`);
}