@oaklandzoo/ostup 0.7.0 → 0.9.0

package/src/tool-registry.mjs

@@ -0,0 +1,164 @@
+// tool-registry.mjs: single source of truth for the binaries ostup needs (node, git, gh, vercel).
+// Detection logic lives here. Install commands per platform live here. Anything that wants to know
+// "what does the user need installed" reads from REGISTRY. Avoids drift between preflight, bootstrap,
+// and doctor.
+import { execSync } from 'node:child_process';
+
+export const REGISTRY = [
+  {
+    id: 'node',
+    name: 'Node',
+    blurb: 'The engine that runs the website setup tool (ostup).',
+    detect: { cmd: 'node', args: ['--version'], minMajor: 20 },
+    fix: 'Install Node 20+ from https://nodejs.org',
+    install: {
+      darwin: {
+        kind: 'manual',
+        url: 'https://nodejs.org',
+        note: 'The Mac installer (install.sh) handles Node via Homebrew. Re-run the bash installer to get it.',
+      },
+      linux: {
+        kind: 'manual',
+        url: 'https://nodejs.org',
+        note: 'Install Node 20+ from nodejs.org or your package manager.',
+      },
+      win32: {
+        kind: 'manual',
+        url: 'https://nodejs.org',
+        note: 'The Windows installer (install.ps1) handles Node via WinGet. Re-run the PowerShell installer to get it.',
+      },
+    },
+  },
+  {
+    id: 'git',
+    name: 'Git',
+    blurb: 'Saves versions of your project as you work.',
+    detect: { cmd: 'git', args: ['--version'] },
+    fix: 'Install git from https://git-scm.com',
+    install: {
+      darwin: {
+        kind: 'brew',
+        cmd: 'brew',
+        args: ['install', 'git'],
+        postPath: ['/opt/homebrew/bin', '/usr/local/bin'],
+      },
+      linux: {
+        kind: 'apt',
+        cmd: 'apt-get',
+        args: ['install', '-y', 'git'],
+        requiresRoot: true,
+        url: 'https://git-scm.com',
+      },
+      win32: {
+        kind: 'winget',
+        cmd: 'winget',
+        args: ['install', '-e', '--id', 'Git.Git', '--accept-package-agreements', '--accept-source-agreements'],
+        postPath: ['C:\\Program Files\\Git\\cmd'],
+      },
+    },
+  },
+  {
+    id: 'gh',
+    name: 'GitHub CLI',
+    blurb: 'Saves your project on GitHub so it is not just on your laptop.',
+    detect: { cmd: 'gh', args: ['--version'] },
+    fix: 'Install: brew install gh',
+    install: {
+      darwin: {
+        kind: 'brew',
+        cmd: 'brew',
+        args: ['install', 'gh'],
+        postPath: ['/opt/homebrew/bin', '/usr/local/bin'],
+      },
+      linux: {
+        kind: 'apt',
+        cmd: 'apt-get',
+        args: ['install', '-y', 'gh'],
+        requiresRoot: true,
+        url: 'https://cli.github.com',
+      },
+      win32: {
+        kind: 'winget',
+        cmd: 'winget',
+        args: ['install', '-e', '--id', 'GitHub.cli', '--accept-package-agreements', '--accept-source-agreements'],
+        postPath: ['C:\\Program Files\\GitHub CLI'],
+      },
+    },
+  },
+  {
+    id: 'vercel',
+    name: 'Vercel CLI',
+    blurb: 'Publishes your site to a public URL on the internet.',
+    detect: { cmd: 'vercel', args: ['--version'] },
+    fix: 'Install: npm i -g vercel',
+    install: {
+      darwin: {
+        kind: 'npm-g',
+        cmd: 'npm',
+        args: ['install', '-g', 'vercel'],
+      },
+      linux: {
+        kind: 'npm-g',
+        cmd: 'npm',
+        args: ['install', '-g', 'vercel'],
+        note: 'Stock apt-installed Node may need sudo for global installs.',
+      },
+      win32: {
+        kind: 'npm-g',
+        cmd: 'npm',
+        args: ['install', '-g', 'vercel'],
+        note: '%APPDATA%\\npm is on PATH by default with WinGet-installed Node.',
+      },
+    },
+  },
+];
+
+// Back-compat shape for preflight.mjs (and test/preflight.test.mjs which imports CHECKS).
+// Keep the array shape: { name, cmd: [bin, ...args], fix, minNodeMajor? }.
+export const CHECKS = REGISTRY.map((tool) => ({
+  name: tool.name,
+  cmd: [tool.detect.cmd, ...(tool.detect.args || [])],
+  fix: tool.fix,
+  ...(tool.detect.minMajor ? { minNodeMajor: tool.detect.minMajor } : {}),
+}));
+
+function defaultRunner(cmd, args = []) {
+  return execSync([cmd, ...args].join(' '), { stdio: ['ignore', 'pipe', 'ignore'] }).toString();
+}
+
+export function detectAll({ runner = defaultRunner } = {}) {
+  const found = [];
+  const missing = [];
+  for (const tool of REGISTRY) {
+    let out;
+    try {
+      out = runner(tool.detect.cmd, tool.detect.args || []);
+    } catch {
+      missing.push({ tool, reason: 'not-found' });
+      continue;
+    }
+    if (tool.detect.minMajor) {
+      const major = parseInt(String(out).replace(/^v/, '').split('.')[0], 10);
+      if (!Number.isFinite(major) || major < tool.detect.minMajor) {
+        missing.push({ tool, reason: 'version-too-old', detected: String(out).trim() });
+        continue;
+      }
+    }
+    found.push({ tool, version: String(out).trim() });
+  }
+  return { found, missing };
+}
+
+export function installCommandFor(toolOrId, platform = process.platform) {
+  const tool = typeof toolOrId === 'string'
+    ? REGISTRY.find((t) => t.id === toolOrId)
+    : toolOrId;
+  if (!tool) return null;
+  const plan = tool.install[platform];
+  if (plan) return plan;
+  return {
+    kind: 'manual',
+    url: tool.install.linux?.url || tool.install.darwin?.url || 'https://nodejs.org',
+    note: `No automatic install for platform ${platform}. Install ${tool.name} manually.`,
+  };
+}

package/src/tracer.mjs

@@ -0,0 +1,116 @@
+// tracer.mjs: structured per-run log file. Writes every step + output to ~/.ostup/logs/<run-id>.log.
+// Auto-enabled on every ostup init / brief / export-pro run unless --no-log is passed.
+
+import { existsSync } from 'node:fs';
+import { mkdir, appendFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+let _enabled = true;
+let _logPath = null;
+let _runId = null;
+
+export function disableTracer() {
+  _enabled = false;
+}
+
+export function enableTracer() {
+  _enabled = true;
+}
+
+export function isTracerEnabled() {
+  return _enabled;
+}
+
+export async function startRun({ label = 'run' } = {}) {
+  if (!_enabled) return null;
+  _runId = `${label}-${new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19)}`;
+  const dir = join(homedir(), '.ostup', 'logs');
+  await mkdir(dir, { recursive: true });
+  _logPath = join(dir, `${_runId}.log`);
+  await appendFile(_logPath, `# ostup run ${_runId}\n# started: ${new Date().toISOString()}\n# cwd: ${process.cwd()}\n# argv: ${process.argv.slice(2).join(' ')}\n\n`);
+  return _logPath;
+}
+
+export async function trace(category, message) {
+  if (!_enabled || !_logPath) return;
+  const stamp = new Date().toISOString();
+  const line = `[${stamp}] [${category}] ${message}\n`;
+  try {
+    await appendFile(_logPath, line);
+  } catch {
+    // Logging must never crash the main flow.
+  }
+}
+
+export async function traceStep({ step, cmd, args = [], stdout = '', stderr = '', exitCode = 0, durationMs = 0 }) {
+  if (!_enabled || !_logPath) return;
+  const display = `${cmd} ${(args || []).join(' ')}`.trim();
+  const stdoutTail = (stdout || '').toString().split('\n').slice(-30).join('\n');
+  const stderrTail = (stderr || '').toString().split('\n').slice(-30).join('\n');
+  const lines = [
+    `## step ${step} | exit=${exitCode} | ${durationMs}ms`,
+    `  cmd: ${display}`,
+  ];
+  if (stdoutTail.trim()) {
+    lines.push(`  stdout (last 30 lines):`);
+    for (const l of stdoutTail.split('\n')) lines.push(`    ${l}`);
+  }
+  if (stderrTail.trim()) {
+    lines.push(`  stderr (last 30 lines):`);
+    for (const l of stderrTail.split('\n')) lines.push(`    ${l}`);
+  }
+  lines.push('');
+  try {
+    await appendFile(_logPath, lines.join('\n'));
+  } catch {
+    // ignore
+  }
+}
+
+export async function traceError(category, err) {
+  if (!_enabled || !_logPath) return;
+  const stamp = new Date().toISOString();
+  const lines = [
+    `## ERROR [${stamp}] [${category}]`,
+    `  message: ${err?.message || err}`,
+    `  code:    ${err?.code || '(none)'}`,
+  ];
+  if (err?.cause) {
+    lines.push(`  cause:`);
+    const causeStr = (err.cause.message || String(err.cause)).split('\n');
+    for (const l of causeStr.slice(0, 20)) lines.push(`    ${l}`);
+  }
+  if (err?.stack) {
+    lines.push(`  stack (first 10 lines):`);
+    for (const l of err.stack.split('\n').slice(0, 10)) lines.push(`    ${l}`);
+  }
+  lines.push('');
+  try {
+    await appendFile(_logPath, lines.join('\n'));
+  } catch {
+    // ignore
+  }
+}
+
+export async function endRun({ ok = true } = {}) {
+  if (!_enabled || !_logPath) return null;
+  const stamp = new Date().toISOString();
+  try {
+    await appendFile(_logPath, `\n# ended: ${stamp}\n# status: ${ok ? 'ok' : 'failed'}\n`);
+  } catch {
+    // ignore
+  }
+  const path = _logPath;
+  _logPath = null;
+  _runId = null;
+  return path;
+}
+
+export function getLogPath() {
+  return _logPath;
+}
+
+export function getRunId() {
+  return _runId;
+}