fabrica-e-commerce 0.1.16 → 0.2.1

package/src/deploy.js

@@ -4,7 +4,7 @@ import crypto from 'node:crypto';
 import { HARDCODED_ENV, REQUIRED_ENV_KEYS, STORE_REPO } from './config.js';
 import { buildsDir, saveProject } from './store.js';
 import { runCommand, runCommandCapture, openUrl } from './system.js';
-import { dimOrange, kv, section, spinner, subBox, red, orange } from './ui.js';
+import { kv, section, endSections, spinner, subBox, log, red, dimOrange } from './ui.js';
 import { ask, choose } from './prompt.js';
 
 const VERCEL_ENVIRONMENTS = ['production', 'preview', 'development'];
@@ -12,15 +12,23 @@ const VERCEL_ENVIRONMENTS = ['production', 'preview', 'development'];
 export async function collectEnv(supabase) {
   section('Environment variables');
   const env = { ...HARDCODED_ENV, SUPABASE_URL: supabase.url, SUPABASE_ANON_KEY: supabase.anonKey };
-  for (const key of REQUIRED_ENV_KEYS) env[key] = await ask(`${key}`);
+  for (const key of REQUIRED_ENV_KEYS) {
+    endSections();           // flush so the ask() prompt appears cleanly
+    env[key] = await ask(`${key}`);
+    section('Environment variables');
+  }
   return env;
 }
 
 export async function cloneRepo() {
+  endSections();
   section('Clone storefront');
   const projectName = await ask('Vercel project name', `fabrica-store-${Date.now()}`);
+  section('Clone storefront');
   const id = crypto.randomUUID();
   const target = path.join(buildsDir, `${projectName}-${id.slice(0, 8)}`);
+  // git clone output goes directly to inherited stdio — show it outside the box
+  endSections();
   await runCommand('git', ['clone', STORE_REPO, target]);
   return { id, projectName, target };
 }
@@ -38,20 +46,21 @@ export async function ensureVercelLogin() {
     return;
   }
   spin.fail('Not logged in to Vercel');
-  console.log('  Opening "vercel login" — finish the login in your browser...');
+  log('Opening "vercel login" — finish the login in your browser...');
+  endSections();
   await runCommand('npx', ['vercel@latest', 'login']);
+  section('Vercel login');
   if (!(await isLoggedInToVercel())) {
     throw new Error('Vercel login was not completed. Run "fabrica build" again after logging in.');
   }
   kv('Vercel', 'Logged in');
 }
 
-// Capture vercel CLI output and render it in a sub-box, errors in red
+// Capture vercel CLI output and add it into the current section buffer as a subBox
 async function runVercelBoxed(args, options = {}) {
   const result = await runCommandCapture('npx', ['vercel@latest', ...args], options);
   const raw = ((result.stdout || '') + (result.stderr || '')).trim();
   if (!raw) return result;
-
   const lines = raw.split('\n').map((l) => l.trimEnd()).filter(Boolean);
   const isErr = result.code !== 0 || lines.some((l) => /^Error:/i.test(l));
   subBox(lines, { isError: isErr });
@@ -73,21 +82,18 @@ async function connectGithubRepo(project, repoUrl) {
   const spin = spinner(`Connecting Vercel project to ${repoUrl}`);
   const attempts = 6;
   let lastError = '';
-  for (let attempt = 1; attempt <= attempts; attempt += 1) {
+  for (let attempt = 1; attempt <= attempts; attempt++) {
     const connect = await runCommandCapture('npx', ['--yes', 'vercel@latest', 'git', 'connect', repoUrl, '--yes'], { cwd: project.target });
-    if (connect.code === 0) {
-      spin.succeed('Vercel project connected to GitHub repo');
-      return true;
-    }
+    if (connect.code === 0) { spin.succeed('Vercel project connected to GitHub repo'); return true; }
     lastError = (connect.stderr || connect.stdout || '').trim();
-    if (attempt < attempts) await new Promise((resolve) => setTimeout(resolve, attempt * 3000));
+    if (attempt < attempts) await new Promise((r) => setTimeout(r, attempt * 3000));
   }
   spin.fail('Could not auto-connect Git — continuing with a direct deploy');
   subBox([
     'This usually means one of two things:',
     `1) Vercel hasn't finished indexing the new fork yet`,
-    `   Re-link manually: npx vercel git connect ${repoUrl}`,
-    '2) The "Vercel" GitHub App is set to "Only select repositories"',
+    `   Re-link: npx vercel git connect ${repoUrl}`,
+    '2) Vercel GitHub App set to "Only select repositories"',
     '   Fix at: https://github.com/settings/installations',
     lastError ? `Last error: ${lastError}` : '',
   ].filter(Boolean), { isError: true });
@@ -97,6 +103,7 @@ async function connectGithubRepo(project, repoUrl) {
 export async function deployToVercel(project, env, githubRepo) {
   section('Vercel deployment');
   await ensureVercelLogin();
+  section('Vercel deployment');
 
   await runVercelBoxed(['link', '--yes', '--project', project.projectName], { cwd: project.target });
 
@@ -110,24 +117,23 @@ export async function deployToVercel(project, env, githubRepo) {
   const deployResult = await runCommandCapture('npx', ['vercel@latest', '--prod', '--yes'], { cwd: project.target });
   const deployOutput = ((deployResult.stdout || '') + (deployResult.stderr || '')).trim();
 
-  // Extract URLs from deploy output
   let productionUrl = null;
   let aliasedUrl = null;
   let inspectUrl = null;
   for (const line of deployOutput.split('\n')) {
-    const m = line.match(/Production\s+(\S+)/);      if (m) productionUrl = m[1];
-    const a = line.match(/Aliased\s+(\S+)/);          if (a) aliasedUrl = a[1];
-    const i = line.match(/Inspect\s+(\S+)/);          if (i) inspectUrl = i[1];
+    const m = line.match(/Production\s+(\S+)/); if (m) productionUrl = m[1];
+    const a = line.match(/Aliased\s+(\S+)/);    if (a) aliasedUrl = a[1];
+    const i = line.match(/Inspect\s+(\S+)/);    if (i) inspectUrl = i[1];
   }
 
   subBox(deployOutput.split('\n').filter(Boolean));
   deploySpin.succeed('Production deployment created');
 
-  // Auto-open the aliased/production URL
   const openTarget = aliasedUrl || productionUrl;
   if (openTarget) {
     kv('Opening', openTarget);
-    await openUrl(openTarget);
+    // open after flush
+    process.nextTick(() => openUrl(openTarget));
   }
 
   const record = {
@@ -146,60 +152,20 @@ export async function deployToVercel(project, env, githubRepo) {
   return record;
 }
 
-export async function runLocally(project, env) {
-  section('Local Next.js setup');
-  const envPath = path.join(project.target, '.env.local');
-  const contents = Object.entries(env).map(([key, value]) => `${key}=${String(value).replace(/\n/g, '\\n')}`).join('\n') + '\n';
-  await fs.writeFile(envPath, contents, 'utf8');
-  kv('Env file', envPath);
-
-  const hasPnpmLock = await fs.access(path.join(project.target, 'pnpm-lock.yaml')).then(() => true, () => false);
-  const pnpmAvailable = (await runCommandCapture('pnpm', ['--version'])).code === 0;
-  const installCommand = hasPnpmLock && pnpmAvailable ? ['pnpm', ['install']] : ['npm', ['install']];
-  const devCommand = hasPnpmLock && pnpmAvailable ? ['pnpm', ['run', 'dev']] : ['npm', ['run', 'dev']];
-
-  await runCommand(installCommand[0], installCommand[1], { cwd: project.target });
-
-  const record = {
-    ...project,
-    type: 'local',
-    repo: STORE_REPO,
-    githubRepo: null,
-    createdAt: new Date().toISOString(),
-    envKeys: Object.keys(env),
-    env,
-    supabaseUrl: env.SUPABASE_URL,
-    productionUrl: 'http://localhost:3000',
-  };
-  await saveProject(record);
-
-  section('Local app');
-  kv('Path', project.target);
-  kv('URL', 'http://localhost:3000');
-  console.log('  Starting the Next.js dev server. Press Ctrl+C to stop.');
-
-  // Auto-open after a brief delay so server has time to start
-  setTimeout(() => openUrl('http://localhost:3000'), 3000);
-  await runCommand(devCommand[0], devCommand[1], { cwd: project.target });
-}
-
-// Called by env command - update a single env var for cloud or local project
 export async function updateProjectEnv(project, key, value) {
   if (project.type === 'local') {
-    // Update .env.local
     const envPath = path.join(project.target, '.env.local');
     let contents = '';
-    try { contents = await fs.readFile(envPath, 'utf8'); } catch { /* no file yet */ }
+    try { contents = await fs.readFile(envPath, 'utf8'); } catch { /* new file */ }
     const lines = contents.split('\n');
     const idx = lines.findIndex((l) => l.startsWith(`${key}=`));
-    const newLine = `${key}=${value}`;
-    if (idx >= 0) lines[idx] = newLine;
-    else lines.push(newLine);
+    if (idx >= 0) lines[idx] = `${key}=${value}`;
+    else lines.push(`${key}=${value}`);
     await fs.writeFile(envPath, lines.join('\n'), 'utf8');
     kv('Updated', `${key} in .env.local`);
   } else {
-    // Cloud: update on Vercel + redeploy
     await ensureVercelLogin();
+    section('Applying update');
     for (const environment of VERCEL_ENVIRONMENTS) {
       await runVercelBoxed(['env', 'rm', key, environment, '--yes'], { cwd: project.target, allowFailure: true });
       await runVercelBoxed(['env', 'add', key, environment], { cwd: project.target, input: `${value}\n` });
@@ -208,7 +174,39 @@ export async function updateProjectEnv(project, key, value) {
     await runVercelBoxed(['--prod', '--yes'], { cwd: project.target });
     spin.succeed(`Redeployed ${project.projectName}`);
   }
-  // Persist updated env in store
   const updated = { ...project, env: { ...(project.env || {}), [key]: value } };
   await saveProject(updated);
 }
+
+export async function runLocally(project, env) {
+  section('Local setup');
+  const envPath = path.join(project.target, '.env.local');
+  const contents = Object.entries(env).map(([k, v]) => `${k}=${String(v).replace(/\n/g, '\\n')}`).join('\n') + '\n';
+  await fs.writeFile(envPath, contents, 'utf8');
+  kv('Env file', envPath);
+
+  const hasPnpmLock = await fs.access(path.join(project.target, 'pnpm-lock.yaml')).then(() => true, () => false);
+  const pnpmAvailable = (await runCommandCapture('pnpm', ['--version'])).code === 0;
+  const installCmd = hasPnpmLock && pnpmAvailable ? ['pnpm', ['install']] : ['npm', ['install']];
+  const devCmd     = hasPnpmLock && pnpmAvailable ? ['pnpm', ['run', 'dev']] : ['npm', ['run', 'dev']];
+
+  const record = {
+    ...project, type: 'local', repo: STORE_REPO, githubRepo: null,
+    createdAt: new Date().toISOString(), envKeys: Object.keys(env),
+    env, supabaseUrl: env.SUPABASE_URL, productionUrl: 'http://localhost:3000',
+  };
+  await saveProject(record);
+
+  kv('URL', 'http://localhost:3000');
+  log('Installing dependencies...');
+  endSections();
+  await runCommand(installCmd[0], installCmd[1], { cwd: project.target });
+
+  section('Local app');
+  kv('Path', project.target);
+  kv('URL',  'http://localhost:3000');
+  log('Starting dev server — browser opens in 3s...');
+  endSections();
+  setTimeout(() => openUrl('http://localhost:3000'), 3000);
+  await runCommand(devCmd[0], devCmd[1], { cwd: project.target });
+}

package/src/deps.js

@@ -2,124 +2,91 @@ import fs from 'node:fs';
 import path from 'node:path';
 import process from 'node:process';
 import { commandExists, runCommand, runCommandCapture } from './system.js';
-import { kv, section, spinner, subBox } from './ui.js';
+import { kv, kvSuccess, kvFail, section, endSections, spinner, subBox, log, logInfo, logWarn, divider, orange, dimOrange, bold, dim, green, red, cyan, yellow } from './ui.js';
 
-// ── platform detection ────────────────────────────────────────────────────────
-function isTermux() {
-  return process.platform === 'android' ||
-    (process.platform === 'linux' && (process.env.TERMUX_VERSION || process.env.PREFIX?.includes('com.termux')));
+export function isTermux() {
+  return (
+    process.platform === 'android' ||
+    (process.platform === 'linux' &&
+      (process.env.TERMUX_VERSION || process.env.PREFIX?.includes('com.termux')))
+  );
 }
 
-async function runPrivileged(command, args, options = {}) {
-  if (process.platform === 'win32') return runCommand(command, args, options);
-  if (isTermux()) return runCommand(command, args, options); // Termux: no sudo
-  if (await commandExists('sudo')) return runCommand('sudo', [command, ...args], options);
-  return runCommand(command, args, options);
-}
-
-function runPrivilegedShell(script, options = {}) {
-  return runCommand('bash', ['-c', script], options);
+function platform() {
+  if (isTermux()) return 'termux';
+  return process.platform; // win32 | linux | darwin
 }
 
-// ── dependency definitions ────────────────────────────────────────────────────
-const DEPENDENCIES = [
-  {
-    name: 'git',
-    label: 'Git',
-    check: () => checkWithPathRefresh('git'),
-    install: installGit,
-    manualUrl: 'https://git-scm.com/downloads'
-  },
-  {
-    name: 'gh',
-    label: 'GitHub CLI (gh)',
-    check: () => checkWithPathRefresh('gh'),
-    install: installGithubCli,
-    manualUrl: 'https://github.com/cli/cli#installation'
-  },
-  {
-    name: 'vercel',
-    label: 'Vercel CLI (via npx)',
-    check: checkVercelCli,
-    install: warmVercelCli,
-    manualUrl: 'https://vercel.com/docs/cli'
-  }
-];
-
 // ── PATH helpers ──────────────────────────────────────────────────────────────
 function addToPathIfDirectory(directory) {
   if (!directory || !fs.existsSync(directory)) return;
-  const delimiter = path.delimiter;
   const current = process.env.PATH || '';
-  const entries = current.split(delimiter).filter(Boolean);
-  if (!entries.some((entry) => entry.toLowerCase() === directory.toLowerCase())) {
-    process.env.PATH = `${directory}${delimiter}${current}`;
-  }
+  const entries = current.split(path.delimiter).filter(Boolean);
+  if (!entries.some((e) => e.toLowerCase() === directory.toLowerCase()))
+    process.env.PATH = `${directory}${path.delimiter}${current}`;
 }
 
 function refreshWindowsToolPaths() {
   if (process.platform !== 'win32') return;
   const lad = process.env.LOCALAPPDATA;
-  const pf  = process.env.ProgramFiles;
+  const pf   = process.env.ProgramFiles;
   const pf86 = process.env['ProgramFiles(x86)'];
-  const pd  = process.env.ProgramData;
-  addToPathIfDirectory(lad  && path.join(lad, 'Microsoft', 'WinGet', 'Links'));
-  addToPathIfDirectory(pf   && path.join(pf, 'GitHub CLI'));
+  const pd   = process.env.ProgramData;
+  addToPathIfDirectory(lad  && path.join(lad,  'Microsoft', 'WinGet', 'Links'));
+  addToPathIfDirectory(pf   && path.join(pf,   'GitHub CLI'));
   addToPathIfDirectory(pf86 && path.join(pf86, 'GitHub CLI'));
-  addToPathIfDirectory(pd   && path.join(pd, 'chocolatey', 'bin'));
-  addToPathIfDirectory(pf   && path.join(pf, 'Git', 'cmd'));
-  addToPathIfDirectory(pf   && path.join(pf, 'nodejs'));
+  addToPathIfDirectory(pd   && path.join(pd,   'chocolatey', 'bin'));
+  addToPathIfDirectory(pf   && path.join(pf,   'Git', 'cmd'));
+  addToPathIfDirectory(pf   && path.join(pf,   'nodejs'));
 }
 
-async function checkWithPathRefresh(command) {
+async function checkWithPathRefresh(cmd) {
   refreshWindowsToolPaths();
-  return commandExists(command);
+  return commandExists(cmd);
 }
 
 async function runFirstSuccessful(candidates, options = {}) {
-  for (const [command, args] of candidates) {
-    const result = await runCommandCapture(command, args, options);
-    if (result.code === 0) return result;
+  for (const [cmd, args] of candidates) {
+    const r = await runCommandCapture(cmd, args, options);
+    if (r.code === 0) return r;
   }
   return { code: 1, stdout: '', stderr: 'All fallback commands failed' };
 }
 
+// ── Vercel ────────────────────────────────────────────────────────────────────
 async function checkVercelCli() {
   refreshWindowsToolPaths();
-  const result = await runFirstSuccessful([
-    ['npx', ['--yes', 'vercel@latest', '--version']],
-    ['npm', ['exec', '--yes', 'vercel@latest', '--', '--version']],
-    ['vercel', ['--version']]
+  const r = await runFirstSuccessful([
+    ['npx',    ['--yes', 'vercel@latest', '--version']],
+    ['npm',    ['exec', '--yes', 'vercel@latest', '--', '--version']],
+    ['vercel', ['--version']],
   ]);
-  return result.code === 0;
+  return r.code === 0;
 }
 
 async function warmVercelCli() {
   refreshWindowsToolPaths();
-  const warmed = await runFirstSuccessful([
-    ['npx', ['--yes', 'vercel@latest', '--version']],
-    ['npm', ['exec', '--yes', 'vercel@latest', '--', '--version']],
-    ['vercel', ['--version']]
+  const r = await runFirstSuccessful([
+    ['npx',    ['--yes', 'vercel@latest', '--version']],
+    ['npm',    ['exec', '--yes', 'vercel@latest', '--', '--version']],
+    ['vercel', ['--version']],
   ]);
-  if (warmed.code === 0) return;
+  if (r.code === 0) return;
   await runCommand('npm', ['install', '-g', 'vercel@latest'], { allowFailure: true });
 }
 
-// ── Git install ───────────────────────────────────────────────────────────────
+// ── Git ───────────────────────────────────────────────────────────────────────
 async function installGit() {
   refreshWindowsToolPaths();
-  const platform = process.platform;
+  const p = platform();
 
-  if (isTermux()) {
-    await runCommand('pkg', ['install', '-y', 'git'], { allowFailure: true });
-    return;
+  if (p === 'termux') {
+    return runCommand('pkg', ['install', '-y', 'git'], { allowFailure: true });
   }
-
-  if (platform === 'linux') {
+  if (p === 'linux') {
     if (await commandExists('apt-get')) {
-      await runPrivileged('apt-get', ['update'], { allowFailure: true });
-      await runPrivileged('apt-get', ['install', '-y', 'git'], { allowFailure: true });
-      return;
+      await runPrivileged('apt-get', ['update', '-qq'], { allowFailure: true });
+      return runPrivileged('apt-get', ['install', '-y', 'git'], { allowFailure: true });
     }
     if (await commandExists('dnf'))    return runPrivileged('dnf',    ['install', '-y', 'git'], { allowFailure: true });
     if (await commandExists('yum'))    return runPrivileged('yum',    ['install', '-y', 'git'], { allowFailure: true });
@@ -127,14 +94,13 @@ async function installGit() {
     if (await commandExists('zypper')) return runPrivileged('zypper', ['install', '-y', 'git'], { allowFailure: true });
     if (await commandExists('apk'))    return runPrivileged('apk',    ['add', 'git'], { allowFailure: true });
   }
-  if (platform === 'darwin') {
+  if (p === 'darwin') {
     if (await commandExists('brew')) return runCommand('brew', ['install', 'git'], { allowFailure: true });
-    // Xcode command line tools
-    await runCommand('xcode-select', ['--install'], { allowFailure: true });
+    return runCommand('xcode-select', ['--install'], { allowFailure: true });
   }
-  if (platform === 'win32') {
+  if (p === 'win32') {
     if (await commandExists('winget')) {
-      await runCommand('winget', ['install', '--id', 'Git.Git', '-e', '--source', 'winget'], { allowFailure: true });
+      await runCommand('winget', ['install', '--id', 'Git.Git', '-e', '--source', 'winget', '--silent'], { allowFailure: true });
       refreshWindowsToolPaths();
       return;
     }
@@ -145,35 +111,32 @@ async function installGit() {
   }
 }
 
-// ── GitHub CLI install ────────────────────────────────────────────────────────
+// ── GitHub CLI ────────────────────────────────────────────────────────────────
 async function installGithubCli() {
   refreshWindowsToolPaths();
-  const platform = process.platform;
+  const p = platform();
 
-  if (isTermux()) {
-    await runCommand('pkg', ['install', '-y', 'gh'], { allowFailure: true });
-    return;
+  if (p === 'termux') {
+    return runCommand('pkg', ['install', '-y', 'gh'], { allowFailure: true });
   }
-
-  if (platform === 'linux') {
+  if (p === 'linux') {
     if (await commandExists('apt-get')) {
-      const direct = await (await commandExists('sudo')
-        ? runCommandCapture('sudo', ['apt-get', 'install', '-y', 'gh'])
-        : runCommandCapture('apt-get', ['install', '-y', 'gh']));
+      // Try direct first (gh is in Ubuntu 22.04+ repos)
+      const direct = await runCommandCapture('apt-get', ['install', '-y', 'gh']);
       if (direct.code === 0) return;
-      const usesSudo = await commandExists('sudo');
-      const prefix = usesSudo ? 'sudo ' : '';
-      await runPrivilegedShell([
+      // Fall back to GitHub's official APT repo
+      const pre = (await commandExists('sudo')) ? 'sudo ' : '';
+      await runCommand('bash', ['-c', [
         'set -e',
-        `${prefix}apt-get update`,
-        `${prefix}apt-get install -y curl ca-certificates gnupg`,
-        `${prefix}mkdir -p -m 755 /etc/apt/keyrings`,
-        `curl -fsSL https://cli.github.com/packages/githubcli-archive-keyring.gpg | ${prefix}tee /etc/apt/keyrings/githubcli-archive-keyring.gpg > /dev/null`,
-        `${prefix}chmod go+r /etc/apt/keyrings/githubcli-archive-keyring.gpg`,
-        `echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/githubcli-archive-keyring.gpg] https://cli.github.com/packages stable main" | ${prefix}tee /etc/apt/sources.list.d/github-cli.list > /dev/null`,
-        `${prefix}apt-get update`,
-        `${prefix}apt-get install -y gh`
-      ].join(' && '), { allowFailure: true });
+        `${pre}apt-get update -qq`,
+        `${pre}apt-get install -y curl ca-certificates gnupg`,
+        `${pre}mkdir -p -m 755 /etc/apt/keyrings`,
+        `curl -fsSL https://cli.github.com/packages/githubcli-archive-keyring.gpg | ${pre}tee /etc/apt/keyrings/githubcli-archive-keyring.gpg > /dev/null`,
+        `${pre}chmod go+r /etc/apt/keyrings/githubcli-archive-keyring.gpg`,
+        `echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/githubcli-archive-keyring.gpg] https://cli.github.com/packages stable main" | ${pre}tee /etc/apt/sources.list.d/github-cli.list > /dev/null`,
+        `${pre}apt-get update -qq`,
+        `${pre}apt-get install -y gh`,
+      ].join(' && ')], { allowFailure: true });
       return;
     }
     if (await commandExists('dnf'))    return runPrivileged('dnf',    ['install', '-y', 'gh'], { allowFailure: true });
@@ -181,12 +144,12 @@ async function installGithubCli() {
     if (await commandExists('zypper')) return runPrivileged('zypper', ['install', '-y', 'gh'], { allowFailure: true });
     if (await commandExists('apk'))    return runCommand('apk', ['add', 'github-cli'], { allowFailure: true });
   }
-  if (platform === 'darwin') {
+  if (p === 'darwin') {
     if (await commandExists('brew')) return runCommand('brew', ['install', 'gh'], { allowFailure: true });
   }
-  if (platform === 'win32') {
+  if (p === 'win32') {
     if (await commandExists('winget')) {
-      await runCommand('winget', ['install', '--id', 'GitHub.cli', '-e', '--source', 'winget'], { allowFailure: true });
+      await runCommand('winget', ['install', '--id', 'GitHub.cli', '-e', '--source', 'winget', '--silent'], { allowFailure: true });
       refreshWindowsToolPaths();
       return;
     }
@@ -197,40 +160,124 @@ async function installGithubCli() {
   }
 }
 
-// ── Public API ────────────────────────────────────────────────────────────────
+async function runPrivileged(command, args, options = {}) {
+  const p = platform();
+  if (p === 'win32' || p === 'termux') return runCommand(command, args, options);
+  if (await commandExists('sudo')) return runCommand('sudo', [command, ...args], options);
+  return runCommand(command, args, options);
+}
+
+// ── dependency table ──────────────────────────────────────────────────────────
+const DEPENDENCIES = [
+  {
+    name: 'git',
+    label: 'Git',
+    description: 'Version control — clones the storefront repo',
+    check: () => checkWithPathRefresh('git'),
+    install: installGit,
+    manualUrl: 'https://git-scm.com/downloads',
+    termuxPkg: 'git',
+  },
+  {
+    name: 'gh',
+    label: 'GitHub CLI',
+    description: 'Creates your GitHub repo and manages auth',
+    check: () => checkWithPathRefresh('gh'),
+    install: installGithubCli,
+    manualUrl: 'https://github.com/cli/cli#installation',
+    termuxPkg: 'gh',
+  },
+  {
+    name: 'vercel',
+    label: 'Vercel CLI',
+    description: 'Deploys the storefront to Vercel cloud',
+    check: checkVercelCli,
+    install: warmVercelCli,
+    manualUrl: 'https://vercel.com/docs/cli',
+    termuxPkg: null, // via npx only
+  },
+];
+
+// ── ensureDependencies (shared) ───────────────────────────────────────────────
 export async function ensureDependencies({ autoInstall = true, names } = {}) {
-  const targets = names ? DEPENDENCIES.filter((dep) => names.includes(dep.name)) : DEPENDENCIES;
+  const targets = names ? DEPENDENCIES.filter((d) => names.includes(d.name)) : DEPENDENCIES;
   const results = [];
   for (const dep of targets) {
-    const spin = spinner(`Checking ${dep.label}`);
+    const spin = spinner(`Checking ${dep.label}…`);
     let present = await dep.check();
-    if (present) { spin.succeed(`${dep.label} found`); results.push({ ...dep, present, installed: false }); continue; }
-    spin.fail(`${dep.label} missing`);
+    if (present) {
+      spin.succeed(`${green(dep.label)} is ready`);
+      results.push({ ...dep, present, installed: false });
+      continue;
+    }
+    spin.fail(`${dep.label} not found`);
     if (!autoInstall) { results.push({ ...dep, present: false, installed: false }); continue; }
-    const installSpin = spinner(`Installing ${dep.label}`);
-    await dep.install();
-    present = await dep.check();
-    if (present) installSpin.succeed(`${dep.label} installed`);
-    else installSpin.fail(`${dep.label} could not be installed automatically`);
+
+    const p = platform();
+    if (p === 'termux' && dep.termuxPkg === null) {
+      // Vercel on Termux — npx-only, attempt inline
+      const wSpin = spinner(`Warming Vercel CLI via npx (Termux)…`);
+      await dep.install();
+      present = await dep.check();
+      if (present) wSpin.succeed(`Vercel CLI ready via npx`);
+      else         wSpin.fail(`Vercel CLI not available — use: npx vercel`);
+    } else {
+      const installSpin = spinner(`Auto-installing ${dep.label}…`);
+      await dep.install();
+      present = await dep.check();
+      if (present) installSpin.succeed(`${green(dep.label)} installed successfully`);
+      else         installSpin.fail(`${red(dep.label)} could not be installed automatically`);
+    }
     results.push({ ...dep, present, installed: present });
   }
   return results;
 }
 
+// ── vins command ──────────────────────────────────────────────────────────────
 export async function vinsCommand() {
-  section('Fabrica dependency check (vins)');
-  const platform = isTermux() ? 'Termux/Android' : process.platform;
-  kv('Platform', platform);
+  const p = platform();
+  const platformLabel = p === 'termux' ? 'Termux / Android' : p === 'win32' ? 'Windows' : p === 'darwin' ? 'macOS' : 'Linux';
+
+  section('System info');
+  kv('Platform', platformLabel);
+  kv('Node.js',  process.version);
+  kv('Arch',     process.arch);
+  if (p === 'termux') {
+    logInfo('Termux detected — using pkg for native installs, npx for Node tools');
+  }
+
+  section('Checking dependencies');
   const results = await ensureDependencies();
-  section('Summary');
+
+  section('Dependency summary');
+  divider();
   let allGood = true;
-  const summaryLines = [];
   for (const dep of results) {
-    summaryLines.push(`${dep.label}: ${dep.present ? '✓ OK' : '✗ MISSING — install manually'}`);
-    if (!dep.present) { allGood = false; summaryLines.push(`  Manual: ${dep.manualUrl}`); }
+    if (dep.present) {
+      kvSuccess(dep.label, dep.description);
+    } else {
+      kvFail(dep.label, `Missing — ${dep.description}`);
+      allGood = false;
+    }
   }
-  subBox(summaryLines, { isError: !allGood });
-  if (allGood) console.log('\n  All dependencies ready. Run: fabrica build');
-  else { console.log('\n  Some deps could not be installed automatically.'); process.exitCode = 1; }
+  divider();
+
+  const missing = results.filter((d) => !d.present);
+  if (missing.length) {
+    logWarn(`${missing.length} dependency(ies) could not be installed automatically`);
+    for (const dep of missing) {
+      if (p === 'termux' && dep.termuxPkg) {
+        log(`Install ${dep.label}: ${cyan(`pkg install ${dep.termuxPkg}`)}`);
+      } else {
+        log(`Install ${dep.label}: ${cyan(dep.manualUrl)}`);
+      }
+    }
+    log('Then re-run: fabrica vins');
+  } else {
+    log(green('All dependencies ready — run: fabrica build'));
+  }
+
+  endSections();
+  if (!allGood) process.exitCode = 1;
   return results;
 }