thumbgate 1.1.0 → 1.3.0

package/scripts/capture-railway-diagnostics.sh

@@ -0,0 +1,97 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+DIAG_DIR="${1:-railway-diagnostics}"
+LOG_LINES="${RAILWAY_LOG_LINES:-200}"
+HTTP_LOG_LINES="${RAILWAY_HTTP_LOG_LINES:-50}"
+CONNECT_TIMEOUT_SECONDS="${RAILWAY_HEALTHCHECK_CONNECT_TIMEOUT_SECONDS:-5}"
+MAX_TIME_SECONDS="${RAILWAY_HEALTHCHECK_MAX_TIME_SECONDS:-20}"
+
+mkdir -p "$DIAG_DIR"
+
+if ! command -v railway >/dev/null 2>&1; then
+  echo 'Railway CLI is not installed; skipping Railway diagnostics capture.'
+  exit 0
+fi
+
+if [ -z "${RAILWAY_PROJECT_ID:-}" ] || [ -z "${RAILWAY_ENVIRONMENT_ID:-}" ]; then
+  echo 'RAILWAY_PROJECT_ID and RAILWAY_ENVIRONMENT_ID are required for Railway diagnostics.'
+  exit 1
+fi
+
+SERVICE_ARGS=()
+if [ -n "${RAILWAY_SERVICE:-}" ]; then
+  SERVICE_ARGS+=(--service "$RAILWAY_SERVICE")
+fi
+
+ENV_ARGS=(--environment "$RAILWAY_ENVIRONMENT_ID")
+
+run_capture() {
+  local label="$1"
+  local output_path="$2"
+  shift 2
+
+  echo "== ${label} =="
+  if "$@" >"$output_path" 2>"${output_path}.stderr"; then
+    sed -n '1,120p' "$output_path" || true
+    return 0
+  fi
+
+  sed -n '1,120p' "${output_path}.stderr" || true
+  return 1
+}
+
+run_capture \
+  'railway link' \
+  "$DIAG_DIR/link.json" \
+  railway link --project "$RAILWAY_PROJECT_ID" "${ENV_ARGS[@]}" "${SERVICE_ARGS[@]}" --json || true
+
+run_capture \
+  'railway status' \
+  "$DIAG_DIR/status.json" \
+  railway status --json || true
+
+run_capture \
+  'railway service status' \
+  "$DIAG_DIR/service-status.json" \
+  railway service status "${SERVICE_ARGS[@]}" "${ENV_ARGS[@]}" --json || true
+
+run_capture \
+  'railway deployment logs' \
+  "$DIAG_DIR/deployment-logs.jsonl" \
+  railway logs "${SERVICE_ARGS[@]}" "${ENV_ARGS[@]}" --latest --deployment --lines "$LOG_LINES" --json || true
+
+run_capture \
+  'railway build logs' \
+  "$DIAG_DIR/build-logs.jsonl" \
+  railway logs "${SERVICE_ARGS[@]}" "${ENV_ARGS[@]}" --latest --build --lines "$LOG_LINES" --json || true
+
+run_capture \
+  'railway http logs (/health 5xx)' \
+  "$DIAG_DIR/http-health-5xx.jsonl" \
+  railway logs "${SERVICE_ARGS[@]}" "${ENV_ARGS[@]}" --latest --http --path /health --status '>=500' --lines "$HTTP_LOG_LINES" --json || true
+
+run_capture \
+  'railway http logs (all 5xx)' \
+  "$DIAG_DIR/http-5xx.jsonl" \
+  railway logs "${SERVICE_ARGS[@]}" "${ENV_ARGS[@]}" --latest --http --status '>=500' --lines "$HTTP_LOG_LINES" --json || true
+
+HEALTHCHECK_URL="${RAILWAY_HEALTHCHECK_URL:-}"
+if [ -n "$HEALTHCHECK_URL" ]; then
+  echo '== direct health probe =='
+  HEALTH_STATUS="$(
+    curl \
+      --connect-timeout "$CONNECT_TIMEOUT_SECONDS" \
+      --max-time "$MAX_TIME_SECONDS" \
+      -sS \
+      -D "$DIAG_DIR/health-headers.txt" \
+      -o "$DIAG_DIR/health-body.txt" \
+      -w '%{http_code}' \
+      "$HEALTHCHECK_URL" || true
+  )"
+  printf '%s\n' "$HEALTH_STATUS" > "$DIAG_DIR/health-status.txt"
+  echo "Health status: ${HEALTH_STATUS:-<curl_failed>}"
+  if [ -s "$DIAG_DIR/health-body.txt" ]; then
+    sed -n '1,120p' "$DIAG_DIR/health-body.txt" || true
+  fi
+fi

package/scripts/changeset-check.js

@@ -0,0 +1,372 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { execFileSync } = require('node:child_process');
+
+const PROJECT_ROOT = path.join(__dirname, '..');
+const CHANGESET_DIR = path.join(PROJECT_ROOT, '.changeset');
+const DEFAULT_PACKAGE_NAME = 'thumbgate';
+const MIN_SUMMARY_LENGTH = 20;
+const RELEASE_TYPES = new Set(['major', 'minor', 'patch']);
+const RELEASE_RELEVANT_FILES = new Set([
+  'README.md',
+  'package.json',
+  'package-lock.json',
+  'server.json',
+]);
+const RELEASE_RELEVANT_PREFIXES = [
+  '.claude-plugin/',
+  '.cursor-plugin/',
+  '.well-known/',
+  'adapters/',
+  'bin/',
+  'config/',
+  'plugins/',
+  'public/',
+  'scripts/',
+  'src/',
+  'workers/',
+];
+
+function parseArgs(argv = process.argv.slice(2)) {
+  const options = {};
+  for (const arg of argv) {
+    if (arg.startsWith('--base=')) {
+      options.baseRef = arg.slice('--base='.length);
+    } else if (arg.startsWith('--since=')) {
+      options.baseRef = arg.slice('--since='.length);
+    }
+  }
+  return options;
+}
+
+function isChangesetMarkdownFile(relPath) {
+  return relPath.startsWith('.changeset/')
+    && relPath.endsWith('.md')
+    && path.basename(relPath) !== 'README.md';
+}
+
+function isReleaseRelevantFile(relPath) {
+  const normalized = String(relPath || '').trim().replaceAll('\\', '/');
+  if (!normalized || isChangesetMarkdownFile(normalized)) {
+    return false;
+  }
+  if (normalized.startsWith('docs/')
+    || normalized.startsWith('proof/')
+    || normalized.startsWith('tests/')
+    || normalized.startsWith('.github/')) {
+    return false;
+  }
+  if (RELEASE_RELEVANT_FILES.has(normalized)) {
+    return true;
+  }
+  return RELEASE_RELEVANT_PREFIXES.some((prefix) => normalized.startsWith(prefix));
+}
+
+function isVersionedReleaseChangeSet(changedFiles = []) {
+  const normalizedFiles = changedFiles.map((file) => String(file || '').trim().replaceAll('\\', '/'));
+  return normalizedFiles.includes('package.json')
+    && normalizedFiles.includes('CHANGELOG.md')
+    && normalizedFiles.some(isChangesetMarkdownFile);
+}
+
+function splitChangesetDocument(content) {
+  const normalized = String(content || '').replaceAll('\r\n', '\n');
+  const lines = normalized.split('\n');
+  if (lines[0]?.trim() !== '---') {
+    return null;
+  }
+
+  const closingIndex = lines.findIndex((line, index) => index > 0 && line.trim() === '---');
+  if (closingIndex === -1) {
+    return null;
+  }
+
+  return {
+    frontmatterLines: lines.slice(1, closingIndex),
+    summary: lines.slice(closingIndex + 1).join('\n').trim(),
+  };
+}
+
+function stripWrappingQuotes(value) {
+  const text = String(value || '').trim();
+  if (text.length >= 2 && ((text.startsWith('"') && text.endsWith('"')) || (text.startsWith('\'') && text.endsWith('\'')))) {
+    return text.slice(1, -1).trim();
+  }
+  return text;
+}
+
+function parseReleaseLine(line) {
+  const normalized = String(line || '').trim();
+  if (!normalized) {
+    return null;
+  }
+
+  const separatorIndex = normalized.indexOf(':');
+  if (separatorIndex <= 0 || separatorIndex === normalized.length - 1) {
+    return null;
+  }
+
+  const packageName = stripWrappingQuotes(normalized.slice(0, separatorIndex));
+  const releaseType = normalized.slice(separatorIndex + 1).trim();
+  if (!packageName || !RELEASE_TYPES.has(releaseType)) {
+    return null;
+  }
+
+  return {
+    packageName,
+    releaseType,
+  };
+}
+
+function parseChangesetMarkdown(content) {
+  const document = splitChangesetDocument(content);
+  if (!document) {
+    return {
+      releases: {},
+      summary: '',
+      errors: ['missing frontmatter'],
+    };
+  }
+
+  const summary = document.summary;
+  const releases = {};
+  const errors = [];
+  const lines = document.frontmatterLines.map((line) => line.trim()).filter(Boolean);
+
+  for (const line of lines) {
+    const entry = parseReleaseLine(line);
+    if (!entry) {
+      errors.push(`invalid frontmatter line: ${line}`);
+      continue;
+    }
+    releases[entry.packageName] = entry.releaseType;
+  }
+
+  if (!summary) {
+    errors.push('missing summary');
+  } else if (summary.length < MIN_SUMMARY_LENGTH) {
+    errors.push(`summary must be at least ${MIN_SUMMARY_LENGTH} characters`);
+  }
+
+  if (Object.keys(releases).length === 0) {
+    errors.push('missing release entries');
+  }
+
+  return {
+    releases,
+    summary,
+    errors,
+  };
+}
+
+function collectChangesets({
+  dir = CHANGESET_DIR,
+  packageName = DEFAULT_PACKAGE_NAME,
+} = {}) {
+  if (!fs.existsSync(dir)) {
+    return [];
+  }
+
+  return fs.readdirSync(dir)
+    .filter((name) => name.endsWith('.md') && name !== 'README.md')
+    .sort()
+    .map((name) => {
+      const filePath = path.join(dir, name);
+      const parsed = parseChangesetMarkdown(fs.readFileSync(filePath, 'utf8'));
+      const releaseType = parsed.releases[packageName] || null;
+      const errors = [...parsed.errors];
+      if (!releaseType) {
+        errors.push(`missing ${packageName} release entry`);
+      }
+      return {
+        file: path.posix.join('.changeset', name),
+        releaseType,
+        summary: parsed.summary,
+        errors,
+        validForPackage: errors.length === 0,
+      };
+    });
+}
+
+function evaluateChangesetRequirement({
+  changedFiles = [],
+  changesets = [],
+} = {}) {
+  const relevantFiles = changedFiles.filter(isReleaseRelevantFile);
+  const required = relevantFiles.length > 0;
+  const validChangesets = changesets.filter((entry) => entry.validForPackage);
+  const invalidChangesets = changesets.filter((entry) => !entry.validForPackage);
+  const versionedRelease = isVersionedReleaseChangeSet(changedFiles);
+
+  if (!required) {
+    return {
+      ok: true,
+      required: false,
+      relevantFiles,
+      validChangesets,
+      invalidChangesets,
+      reason: 'No release-relevant changes detected. Changeset not required.',
+    };
+  }
+
+  if (validChangesets.length > 0) {
+    return {
+      ok: true,
+      required: true,
+      relevantFiles,
+      validChangesets,
+      invalidChangesets,
+      reason: `Found ${validChangesets.length} valid changeset file(s) for release-relevant changes.`,
+    };
+  }
+
+  if (versionedRelease) {
+    return {
+      ok: true,
+      required: true,
+      relevantFiles,
+      validChangesets,
+      invalidChangesets,
+      reason: 'Release PR already consumed pending changesets into versioned artifacts.',
+    };
+  }
+
+  return {
+    ok: false,
+    required: true,
+    relevantFiles,
+    validChangesets,
+    invalidChangesets,
+    reason: 'Release-relevant changes require at least one valid .changeset entry for thumbgate.',
+  };
+}
+
+function runGitCommand(args, {
+  cwd = PROJECT_ROOT,
+  runner = execFileSync,
+} = {}) {
+  return String(runner('git', args, {
+    cwd,
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+  }) || '').trim();
+}
+
+function resolveBaseRef({
+  args = parseArgs(),
+  env = process.env,
+  cwd = PROJECT_ROOT,
+  runner = execFileSync,
+} = {}) {
+  const explicitBase = String(args.baseRef || '').trim();
+  const baseRef = explicitBase
+    || String(env.CHANGESET_BASE_REF || '').trim()
+    || String(env.GITHUB_BASE_REF || '').trim()
+    || (env.GITHUB_EVENT_NAME === 'merge_group' ? 'origin/main' : '');
+
+  if (!baseRef) {
+    return null;
+  }
+
+  const candidates = [baseRef];
+  if (!baseRef.startsWith('origin/')) {
+    candidates.push(`origin/${baseRef}`);
+  }
+
+  for (const candidate of candidates) {
+    try {
+      runGitCommand(['rev-parse', '--verify', candidate], { cwd, runner });
+      return candidate;
+    } catch {}
+  }
+
+  return candidates.at(-1);
+}
+
+function getChangedFiles({
+  baseRef,
+  cwd = PROJECT_ROOT,
+  runner = execFileSync,
+} = {}) {
+  if (!baseRef) {
+    return [];
+  }
+
+  const mergeBase = runGitCommand(['merge-base', 'HEAD', baseRef], { cwd, runner });
+  const output = runGitCommand(['diff', '--name-only', '--diff-filter=ACDMRTUXB', `${mergeBase}...HEAD`], { cwd, runner });
+  return output ? output.split('\n').map((line) => line.trim()).filter(Boolean) : [];
+}
+
+function formatFailure(result) {
+  const lines = [result.reason, ''];
+  if (result.relevantFiles.length > 0) {
+    lines.push('Release-relevant files:');
+    result.relevantFiles.forEach((file) => lines.push(`- ${file}`));
+    lines.push('');
+  }
+  if (result.invalidChangesets.length > 0) {
+    lines.push('Invalid changesets:');
+    result.invalidChangesets.forEach((entry) => {
+      lines.push(`- ${entry.file}: ${entry.errors.join('; ')}`);
+    });
+    lines.push('');
+  }
+  lines.push('Run `npm run changeset` and add a release note for thumbgate before merging.');
+  return lines.join('\n');
+}
+
+function runCli({
+  cwd = PROJECT_ROOT,
+  env = process.env,
+  runner = execFileSync,
+} = {}) {
+  const baseRef = resolveBaseRef({ env, cwd, runner });
+  if (!baseRef) {
+    const result = {
+      ok: true,
+      skipped: true,
+      reason: 'No base ref detected. Skipping changeset check outside PR or merge-group context.',
+    };
+    console.log(result.reason);
+    return result;
+  }
+
+  const changedFiles = getChangedFiles({ baseRef, cwd, runner });
+  const changesets = collectChangesets();
+  const result = evaluateChangesetRequirement({ changedFiles, changesets });
+  if (result.ok) {
+    console.log(result.reason);
+    return result;
+  }
+
+  console.error(formatFailure(result));
+  process.exitCode = 1;
+  return result;
+}
+
+if (require.main === module) {
+  runCli();
+}
+
+module.exports = {
+  CHANGESET_DIR,
+  DEFAULT_PACKAGE_NAME,
+  MIN_SUMMARY_LENGTH,
+  RELEASE_RELEVANT_FILES,
+  RELEASE_RELEVANT_PREFIXES,
+  collectChangesets,
+  evaluateChangesetRequirement,
+  formatFailure,
+  getChangedFiles,
+  isChangesetMarkdownFile,
+  isReleaseRelevantFile,
+  isVersionedReleaseChangeSet,
+  parseArgs,
+  parseChangesetMarkdown,
+  resolveBaseRef,
+  runCli,
+  runGitCommand,
+};

package/scripts/check-congruence.js

@@ -11,9 +11,8 @@ const fs = require('fs');
 const path = require('path');
 const {
   collectLocalGitHubAboutErrors,
-  compareGitHubAbout,
-  fetchLiveGitHubAbout,
   loadGitHubAboutConfig,
+  verifyLiveGitHubAbout,
 } = require('./github-about');
 const {
   PRODUCTHUNT_URL,
@@ -223,7 +222,7 @@ async function main() {
     'public/index.html must mention the linked feedback session flow'
   );
   check(
-    /unlimited feedback captures/i.test(landingHtml) && /5 lesson searches\/day/i.test(landingHtml),
+    /3 feedback captures\/day/i.test(landingHtml) && /5 lesson searches\/day/i.test(landingHtml),
     'public/index.html must advertise the truthful free-tier capture and lesson-search limits'
   );
   check(
@@ -295,8 +294,12 @@ async function main() {
 
   if (checkLiveGitHubAbout) {
     try {
-      const liveAbout = await fetchLiveGitHubAbout({ root: ROOT, repo: githubAbout.repo });
-      errors.push(...compareGitHubAbout(githubAbout, liveAbout, `Live GitHub About (${githubAbout.repo})`));
+      const liveCheck = await verifyLiveGitHubAbout({
+        expected: githubAbout,
+        repo: githubAbout.repo,
+        root: ROOT,
+      });
+      errors.push(...liveCheck.errors);
     } catch (error) {
       errors.push(`Unable to verify live GitHub About: ${error.message}`);
     }