@mettlecast/domain-cli 0.2.0

package/src/commands/reseed-page.ts

@@ -0,0 +1,410 @@
+import { mkdir, writeFile, unlink, access } from 'node:fs/promises';
+import { join, resolve, dirname } from 'node:path';
+import { execSync } from 'node:child_process';
+import { createGunzip } from 'node:zlib';
+import { Readable } from 'node:stream';
+import { cliLogger } from '../utils/logger.js';
+import {
+  fetchVersionsJson,
+  fetchModulesJson,
+  fetchModuleTarball,
+  type S3ModuleEntry,
+} from '../utils/s3-fetch.js';
+import { computeChecksumString } from '../utils/checksum.js';
+import { injectHeader } from '../utils/header-inject.js';
+import { readManifest } from '../utils/manifest.js';
+import { readScaffoldConfig } from '../utils/scaffold-config.js';
+
+const SCAFFOLD_BUCKET = 'mc-scaffold';
+
+// ── Tarball types ──────────────────────────────────────────────────────────────
+
+interface TarEntry {
+  path: string;
+  content: Buffer;
+}
+
+interface TarballManifestEntry {
+  path: string;
+  sha256: string;
+  isTemplate: boolean;
+  installedAs?: string;
+}
+
+// ── Seed page categories ───────────────────────────────────────────────────────
+
+const SEED_PAGE_CATEGORIES = ['auth', 'account', 'shell', '_errors'];
+const SEED_LAYOUT_DIR = 'layouts';
+
+export interface ReseedPageOptions {
+  pageName?: string;
+  all?: boolean;
+  projectDir?: string;
+}
+
+// ── Tarball parsing ────────────────────────────────────────────────────────────
+
+async function parseTarball(buf: Buffer): Promise<TarEntry[]> {
+  const decompressed = await new Promise<Buffer>((res, rej) => {
+    const gunzip = createGunzip();
+    const chunks: Buffer[] = [];
+    const input = Readable.from(buf);
+    input.pipe(gunzip);
+    gunzip.on('data', (chunk: Buffer) =>
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk as ArrayBuffer))
+    );
+    gunzip.on('end', () => res(Buffer.concat(chunks)));
+    gunzip.on('error', rej);
+  });
+
+  const entries: TarEntry[] = [];
+  let offset = 0;
+
+  while (offset + 512 <= decompressed.length) {
+    const header = decompressed.slice(offset, offset + 512);
+    if (header.every((b) => b === 0)) break;
+
+    let name = header.slice(0, 100).toString('utf-8').replace(/\0.*/, '');
+    const prefix = header.slice(345, 500).toString('utf-8').replace(/\0.*/, '');
+    if (prefix) name = `${prefix}/${name}`;
+
+    const sizeStr = header.slice(124, 136).toString('utf-8').replace(/\0.*/, '').trim();
+    const size = parseInt(sizeStr, 8) || 0;
+    const typeFlag = header[156];
+    const isRegularFile = typeFlag === 0x30 || typeFlag === 0 || typeFlag === undefined;
+
+    offset += 512;
+
+    if (isRegularFile && name && size > 0) {
+      const content = decompressed.slice(offset, offset + size);
+      entries.push({ path: name, content });
+    }
+
+    offset += Math.ceil(size / 512) * 512;
+  }
+
+  return entries;
+}
+
+function getTarEntry(entries: TarEntry[], targetPath: string): TarEntry | undefined {
+  return entries.find((e) => {
+    const normalized = e.path.replace(/^\.\//, '').replace(/^[^/]+\//, '');
+    return normalized === targetPath || e.path === targetPath || e.path.endsWith(`/${targetPath}`);
+  });
+}
+
+// ── GitHub helpers ─────────────────────────────────────────────────────────────
+
+function detectGitRemote(projectDir: string): { owner: string; repo: string } | null {
+  try {
+    const url = execSync('git remote get-url origin', {
+      cwd: projectDir,
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+
+    const sshMatch = url.match(/git@github\.com:([^/]+)\/([^.]+?)(?:\.git)?$/);
+    if (sshMatch) return { owner: sshMatch[1], repo: sshMatch[2] };
+
+    const httpsMatch = url.match(/github\.com\/([^/]+)\/([^/]+?)(?:\.git)?(?:\/)?$/);
+    if (httpsMatch) return { owner: httpsMatch[1], repo: httpsMatch[2] };
+
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+async function createGitHubPR(
+  owner: string,
+  repo: string,
+  token: string,
+  branch: string,
+  title: string,
+  body: string,
+  labels?: string[]
+): Promise<{ url: string; number: number }> {
+  const url = `https://api.github.com/repos/${owner}/${repo}/pulls`;
+  const res = await fetch(url, {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${token}`,
+      Accept: 'application/vnd.github+json',
+      'Content-Type': 'application/json',
+      'X-GitHub-Api-Version': '2022-11-28',
+    },
+    body: JSON.stringify({
+      title,
+      body,
+      head: branch,
+      base: 'develop',
+      labels,
+    }),
+  });
+
+  if (!res.ok) {
+    const err = await res.text();
+    throw new Error(`GitHub PR creation failed (${res.status}): ${err}`);
+  }
+
+  const data = (await res.json()) as { html_url: string; number: number };
+  return { url: data.html_url, number: data.number };
+}
+
+// ── Seed page fetching ─────────────────────────────────────────────────────────
+
+async function fetchSeedPagesToReseed(
+  tarEntries: TarEntry[],
+  tarManifest: TarballManifestEntry[],
+  pageName?: string
+): Promise<Array<{ path: string; content: string }>> {
+  const results: Array<{ path: string; content: string }> = [];
+
+  if (pageName) {
+    // Single page mode: fetch one specific page
+    for (const fileEntry of tarManifest) {
+      if (fileEntry.path.includes(`/pages/`) && fileEntry.path.includes(`${pageName}.tsx`)) {
+        const tarEntry = getTarEntry(tarEntries, fileEntry.path);
+        if (tarEntry) {
+          let installPath = fileEntry.installedAs ?? fileEntry.path;
+          if (installPath.endsWith('.tpl')) installPath = installPath.slice(0, -4);
+          results.push({
+            path: installPath,
+            content: tarEntry.content.toString('utf-8'),
+          });
+        }
+      }
+    }
+  } else {
+    // Bulk mode (--all): fetch all seed pages
+    for (const fileEntry of tarManifest) {
+      const isSeedPage = isSeedPagePath(fileEntry.path);
+      if (isSeedPage) {
+        const tarEntry = getTarEntry(tarEntries, fileEntry.path);
+        if (tarEntry) {
+          let installPath = fileEntry.installedAs ?? fileEntry.path;
+          if (installPath.endsWith('.tpl')) installPath = installPath.slice(0, -4);
+          results.push({
+            path: installPath,
+            content: tarEntry.content.toString('utf-8'),
+          });
+        }
+      }
+    }
+  }
+
+  return results;
+}
+
+function isSeedPagePath(filePath: string): boolean {
+  const seedPatterns = [
+    /^frontend\/src\/pages\/auth\//,
+    /^frontend\/src\/pages\/account\//,
+    /^frontend\/src\/pages\/shell\//,
+    /^frontend\/src\/pages\/_errors\//,
+    /^frontend\/src\/layouts\//,
+  ];
+  return seedPatterns.some((pattern) => pattern.test(filePath));
+}
+
+// ── Main export ────────────────────────────────────────────────────────────────
+
+export async function runReseedPage(opts: ReseedPageOptions): Promise<void> {
+  const projectDir = resolve(opts.projectDir ?? process.cwd());
+
+  if (!opts.pageName && !opts.all) {
+    throw new Error('Provide a page name or use --all to reseed all seed pages');
+  }
+
+  const mode = opts.all ? 'bulk' : 'single';
+  console.log(`\nTIB Reseed Page (${mode} mode)\n`);
+  console.log(`Project: ${projectDir}\n`);
+
+  // 1. Read manifest + scaffold-config
+  const manifest = await readManifest(projectDir);
+  if (!manifest) {
+    throw new Error(
+      `.mc/manifest.json not found in ${projectDir}. Is this a TIB scaffold project?`
+    );
+  }
+
+  const scaffoldConfig = await readScaffoldConfig(projectDir);
+  const bucket = scaffoldConfig.scaffoldBucket ?? SCAFFOLD_BUCKET;
+
+  // 2. Get latest version
+  const versionsJson = await fetchVersionsJson(bucket);
+  const latestVersion = versionsJson.latest;
+
+  console.log(`Current version : ${manifest.scaffoldVersion}`);
+  console.log(`Latest version  : ${latestVersion}\n`);
+
+  // 3. Fetch frontend module tarball
+  const modulesJson = await fetchModulesJson(bucket, latestVersion);
+  const frontendModule = modulesJson.modules.find((m) => m.id === 'frontend');
+  if (!frontendModule) {
+    throw new Error(`Frontend module not found in modules.json for version ${latestVersion}`);
+  }
+
+  console.log(`Fetching frontend module ${frontendModule.id}@${frontendModule.version}...\n`);
+
+  const tarBuf = await fetchModuleTarball(
+    bucket,
+    latestVersion,
+    frontendModule.tarball,
+    frontendModule.sha256
+  );
+
+  const tarEntries = await parseTarball(tarBuf);
+  const manifestEntry = getTarEntry(tarEntries, 'MANIFEST.json');
+  if (!manifestEntry) {
+    throw new Error('No MANIFEST.json in frontend module tarball');
+  }
+
+  const tarManifest = JSON.parse(
+    manifestEntry.content.toString('utf-8')
+  ) as TarballManifestEntry[];
+
+  // 4. Fetch seed pages to reseed
+  const seedPages = await fetchSeedPagesToReseed(tarEntries, tarManifest, opts.pageName);
+
+  if (seedPages.length === 0) {
+    const msg = opts.pageName
+      ? `No seed page found matching "${opts.pageName}"`
+      : 'No seed pages found to reseed';
+    throw new Error(msg);
+  }
+
+  console.log(`Found ${seedPages.length} seed page(s) to reseed`);
+  seedPages.forEach((p) => {
+    console.log(`  - ${p.path}`);
+  });
+  console.log('');
+
+  // 5. Create git branch for the reseed
+  const branchName = opts.all
+    ? `tib-reseed/all-v${latestVersion}`
+    : `tib-reseed/${opts.pageName}-v${latestVersion}`;
+
+  try {
+    execSync(`git -C "${projectDir}" checkout -b "${branchName}"`, {
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+  } catch {
+    // Branch may already exist
+    try {
+      execSync(`git -C "${projectDir}" checkout "${branchName}"`, {
+        stdio: ['pipe', 'pipe', 'pipe'],
+      });
+    } catch {
+      throw new Error(`Failed to create or checkout branch: ${branchName}`);
+    }
+  }
+
+  // 6. Write seed pages to disk
+  for (const seedPage of seedPages) {
+    const diskPath = join(projectDir, seedPage.path);
+    console.log(`Writing ${seedPage.path}...`);
+    await mkdir(dirname(diskPath), { recursive: true });
+    await writeFile(diskPath, seedPage.content, 'utf-8');
+  }
+
+  // 7. Commit changes
+  execSync(`git -C "${projectDir}" add -A`, { stdio: 'pipe' });
+
+  let hasChanges = false;
+  try {
+    const status = execSync(`git -C "${projectDir}" status --porcelain`, {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+    hasChanges = status.length > 0;
+  } catch {
+    // ignore
+  }
+
+  if (!hasChanges) {
+    console.log('No changes to commit — seed pages are already up to date.\n');
+    return;
+  }
+
+  const commitMsg = opts.all
+    ? `chore: [DESTRUCTIVE] bulk reseed all seed pages to v${latestVersion}`
+    : `chore: [DESTRUCTIVE] reseed ${opts.pageName} to v${latestVersion}`;
+
+  execSync(`git -C "${projectDir}" commit -m "${commitMsg}"`, { stdio: 'pipe' });
+
+  try {
+    execSync(`git -C "${projectDir}" push --set-upstream origin "${branchName}"`, {
+      stdio: 'pipe',
+    });
+  } catch {
+    cliLogger.warn({ branchName }, 'reseed-page: git push failed — skipping PR creation');
+    console.log(`\nCommit created on branch: ${branchName}`);
+    console.log('Note: push failed — create the PR manually.\n');
+    return;
+  }
+
+  // 8. Create GitHub PR
+  const token = process.env['GITHUB_TOKEN'];
+  const remote = detectGitRemote(projectDir);
+
+  if (!token) {
+    console.log(`\nBranch pushed: ${branchName}`);
+    console.log('Set GITHUB_TOKEN env var to create a PR automatically.\n');
+    return;
+  }
+
+  if (!remote) {
+    console.log(`\nBranch pushed: ${branchName}`);
+    console.log('Could not detect GitHub owner/repo from git remote — create the PR manually.\n');
+    return;
+  }
+
+  const prTitle = opts.all
+    ? `[DESTRUCTIVE] Bulk reseed all seed pages to scaffold v${latestVersion}`
+    : `[DESTRUCTIVE] Reseed ${opts.pageName} to scaffold v${latestVersion}`;
+
+  const prBody = buildReseedPagePrBody(
+    opts.pageName ?? 'all pages',
+    latestVersion,
+    seedPages
+  );
+
+  const prResult = await createGitHubPR(
+    remote.owner,
+    remote.repo,
+    token,
+    branchName,
+    prTitle,
+    prBody,
+    ['tib-destructive-reseed']
+  );
+
+  console.log(`\nPR created: ${prResult.url}\n`);
+  cliLogger.info({ prUrl: prResult.url, latestVersion }, 'reseed-page: PR created');
+}
+
+function buildReseedPagePrBody(pageName: string, version: string, pages: Array<{ path: string; content: string }>): string {
+  const lines: string[] = [
+    '## ⚠️ DESTRUCTIVE: Reseed Seed Pages',
+    '',
+    'This PR **overwrites** the following seed page(s) with the latest scaffold version.',
+    'This is a destructive operation — verify changes carefully.',
+    '',
+    '### Seed pages to be overwritten',
+    '',
+  ];
+
+  for (const page of pages) {
+    lines.push(`- \`${page.path}\``);
+  }
+
+  lines.push('');
+  lines.push('### What to do');
+  lines.push('1. Review the file diffs in this PR');
+  lines.push('2. If acceptable, merge this PR');
+  lines.push('3. The seed pages will be reset to their scaffold defaults');
+  lines.push('');
+
+  return lines.join('\n');
+}

package/src/commands/show-dns.ts

@@ -0,0 +1,139 @@
+import { readFile } from 'fs/promises';
+import path from 'path';
+import { cliLogger } from '../utils/logger.js';
+
+export interface ShowDnsOptions {
+  env?: string;
+  projectDir?: string;
+}
+
+interface DnsRecord {
+  type: string;
+  name: string;
+  value: string;
+}
+
+interface EnvDnsInfo {
+  dashboardUrl?: string;
+  status: string;
+  validationRecords: DnsRecord[];
+  routingRecords: DnsRecord[];
+  errorMessage?: string;
+}
+
+function toZoneLine(r: DnsRecord): string {
+  return `${r.name}. 300 IN ${r.type} ${r.value}.`;
+}
+
+/**
+ * tib show-dns [--env dev|staging|prod] [--project-dir <path>]
+ *
+ * Reads the scaffold-config.json and prints DNS records that must be added for
+ * custom domain wiring: certificate validation CNAMEs (step 1) and traffic
+ * routing CNAMEs (step 2).
+ *
+ * For the routing CNAME the CloudFront domain is read from the CDK outputs file
+ * (.mc/cdk-outputs.json) if available; otherwise it is shown as a placeholder.
+ */
+export async function runShowDns(opts: ShowDnsOptions): Promise<void> {
+  const projectDir = opts.projectDir ? path.resolve(opts.projectDir) : process.cwd();
+  const configPath = path.join(projectDir, '.tib', 'scaffold-config.json');
+
+  let config: { environments?: Record<string, { dashboardUrl?: string }> };
+  try {
+    const raw = await readFile(configPath, 'utf-8');
+    config = JSON.parse(raw) as typeof config;
+  } catch {
+    console.error('[tib] Could not read .mc/scaffold-config.json — run from a TIB project root.');
+    process.exit(1);
+  }
+
+  const environments = config.environments ?? {};
+  if (Object.keys(environments).length === 0) {
+    console.log('[tib] No environments configured. Set a custom domain via `tib show-dns` or the Setup tab.');
+    return;
+  }
+
+  // Try to load CDK outputs for routing records
+  let cdkOutputs: Record<string, Record<string, string>> = {};
+  try {
+    const outputsPath = path.join(projectDir, '.tib', 'cdk-outputs.json');
+    const raw = await readFile(outputsPath, 'utf-8');
+    cdkOutputs = JSON.parse(raw) as typeof cdkOutputs;
+  } catch {
+    // No CDK outputs yet — routing CNAMEs will show a placeholder
+  }
+
+  const targetEnvs = opts.env
+    ? [opts.env]
+    : Object.keys(environments);
+
+  for (const env of targetEnvs) {
+    const cfg = environments[env];
+    if (!cfg?.dashboardUrl) {
+      console.log(`\n;; ${env}: no custom domain configured`);
+      continue;
+    }
+
+    const info = await buildEnvDnsInfo(env, cfg.dashboardUrl, cdkOutputs);
+    printEnvDns(env, info);
+  }
+}
+
+async function buildEnvDnsInfo(
+  env: string,
+  dashboardUrl: string,
+  cdkOutputs: Record<string, Record<string, string>>
+): Promise<EnvDnsInfo> {
+  // Look for cert validation records from CDK outputs
+  // Cert validation CNAMEs are emitted by ACM and captured in CDK outputs under the cert resource
+  const certArnOutputKey = `tib-cert-${env}-arn`;
+  const certArn = Object.values(cdkOutputs)
+    .flatMap(stack => Object.entries(stack))
+    .find(([k]) => k === certArnOutputKey)?.[1];
+
+  // Look for the CloudFront distribution domain from CDK outputs
+  const distributionDomainName = Object.values(cdkOutputs)
+    .flatMap(stack => Object.entries(stack))
+    .find(([k]) => k.toLowerCase().includes('distributiondomain') && k.toLowerCase().includes(env))?.[1]
+    ?? `<run cdk synth — distribution domain not yet available>`;
+
+  const validationRecords: DnsRecord[] = certArn
+    // When CDK outputs include validation record overrides, they'd be here.
+    // Without a live describe-certificate call, we surface a placeholder.
+    ? [{ type: 'CNAME', name: `_acm-validation.${dashboardUrl}`, value: `<see ACM console for cert ${certArn}>` }]
+    : [{ type: 'CNAME', name: `_acm-validation.${dashboardUrl}`, value: `<deploy the FrontendCustomDomainStack first>` }];
+
+  const routingRecords: DnsRecord[] = [
+    { type: 'CNAME', name: dashboardUrl, value: distributionDomainName },
+  ];
+
+  return {
+    dashboardUrl,
+    status: certArn ? 'deployed' : 'not_deployed',
+    validationRecords,
+    routingRecords,
+  };
+}
+
+function printEnvDns(env: string, info: EnvDnsInfo): void {
+  console.log(`\n;; ${env} — ${info.dashboardUrl}`);
+
+  if (info.validationRecords.length > 0) {
+    console.log(';; Certificate validation records (add once, shared across deploys)');
+    for (const r of info.validationRecords) {
+      console.log(toZoneLine(r));
+    }
+  }
+
+  if (info.routingRecords.length > 0) {
+    console.log(';; Traffic routing records (update when CloudFront domain changes)');
+    for (const r of info.routingRecords) {
+      console.log(toZoneLine(r));
+    }
+  }
+
+  if (info.errorMessage) {
+    cliLogger.error({ env, errorMessage: info.errorMessage }, 'DNS info error');
+  }
+}