@mettlecast/domain-cli 0.2.0

package/src/commands/create-project.ts

@@ -0,0 +1,367 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import { createInterface } from 'node:readline';
+import { Readable } from 'node:stream';
+import { execSync } from 'node:child_process';
+import * as tar from 'tar';
+import { cliLogger } from '../utils/logger.js';
+import {
+  fetchVersionsJson,
+  fetchModulesJson,
+  fetchModuleTarball,
+  type S3ModuleEntry,
+} from '../utils/s3-fetch.js';
+import { computeChecksumString } from '../utils/checksum.js';
+import { applyTokens, buildTokenContext } from '../utils/token-substitution.js';
+import { injectHeader } from '../utils/header-inject.js';
+import {
+  createManifest,
+  writeManifest,
+  upsertManifestFile,
+  type TibManifest,
+} from '../utils/manifest.js';
+import { writeScaffoldConfig, type ScaffoldConfig, type ModuleId, type EnvironmentsConfig } from '../utils/scaffold-config.js';
+
+const SCAFFOLD_BUCKET = 'mc-scaffold';
+
+export interface CreateProjectOptions {
+  name: string;
+  outDir?: string;
+}
+
+// ── Prompts ────────────────────────────────────────────────────────────────────
+
+async function prompt(rl: ReturnType<typeof createInterface>, question: string): Promise<string> {
+  return new Promise((res) => rl.question(question, res));
+}
+
+async function promptDefault(
+  rl: ReturnType<typeof createInterface>,
+  question: string,
+  defaultVal: string
+): Promise<string> {
+  const answer = await prompt(rl, `${question} [${defaultVal}]: `);
+  return answer.trim() || defaultVal;
+}
+
+async function promptYesNo(
+  rl: ReturnType<typeof createInterface>,
+  question: string,
+  defaultYes = true
+): Promise<boolean> {
+  const hint = defaultYes ? 'Y/n' : 'y/N';
+  const answer = await prompt(rl, `${question} [${hint}]: `);
+  const trimmed = answer.trim().toLowerCase();
+  if (!trimmed) return defaultYes;
+  return trimmed === 'y' || trimmed === 'yes';
+}
+
+// ── Topological sort ───────────────────────────────────────────────────────────
+
+function topoSort(modules: S3ModuleEntry[], selected: Set<string>): S3ModuleEntry[] {
+  const byId = new Map(modules.map((m) => [m.id, m]));
+  const result: S3ModuleEntry[] = [];
+  const visited = new Set<string>();
+
+  function visit(id: string): void {
+    if (visited.has(id)) return;
+    visited.add(id);
+    const mod = byId.get(id);
+    if (!mod) return;
+    for (const dep of mod.dependencies) {
+      if (selected.has(dep)) visit(dep);
+    }
+    result.push(mod);
+  }
+
+  // Always core first, then backend-lambda, then rest
+  const priorityOrder = ['core', 'backend-lambda'];
+  for (const id of priorityOrder) {
+    if (selected.has(id)) visit(id);
+  }
+  for (const id of selected) {
+    visit(id);
+  }
+
+  return result;
+}
+
+// ── Tarball parsing (tar npm package) ─────────────────────────────────────────
+
+interface TarEntry {
+  path: string;
+  content: Buffer;
+}
+
+interface TarballManifestEntry {
+  path: string;
+  sha256: string;
+  isTemplate: boolean;
+  installedAs?: string;
+  policy?: 'owned' | 'tracked' | 'seed';
+}
+
+async function parseTarball(buf: Buffer): Promise<TarEntry[]> {
+  const entries: TarEntry[] = [];
+
+  await new Promise<void>((resolve, reject) => {
+    const parser = new tar.Parser({
+      gzip: true,
+      onentry(entry: tar.ReadEntry) {
+        if (entry.type !== 'File') {
+          entry.resume();
+          return;
+        }
+
+        const chunks: Buffer[] = [];
+        entry.on('data', (chunk: Buffer) => {
+          chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk as ArrayBuffer));
+        });
+        entry.on('end', () => {
+          entries.push({ path: entry.path, content: Buffer.concat(chunks) });
+        });
+        entry.on('error', reject);
+      },
+    });
+
+    parser.on('finish', resolve);
+    parser.on('error', reject);
+
+    const readable = Readable.from(buf);
+    readable.pipe(parser);
+  });
+
+  return entries;
+}
+
+function getTarEntry(entries: TarEntry[], targetPath: string): TarEntry | undefined {
+  // Strip leading ./ or component prefix from tarball paths
+  return entries.find((e) => {
+    const normalized = e.path.replace(/^\.\//, '').replace(/^[^/]+\//, '');
+    return normalized === targetPath || e.path === targetPath || e.path.endsWith(`/${targetPath}`);
+  });
+}
+
+// ── Main ───────────────────────────────────────────────────────────────────────
+
+export async function runCreateProject(opts: CreateProjectOptions): Promise<void> {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+
+  try {
+    // 1. Collect project details
+    console.log('\nTIB scaffold — create new project\n');
+
+    const projectName = await promptDefault(rl, 'Project name', opts.name || 'my-project');
+    const awsRegion = await promptDefault(rl, 'AWS region', 'eu-north-1');
+    const awsAccountId = await promptDefault(rl, 'AWS account ID', '');
+    const includeDatabase = await promptYesNo(rl, 'Include database (Aurora)?', false);
+    const includeAuth = await promptYesNo(rl, 'Include authentication (Cognito)?', false);
+    const includeFrontend = await promptYesNo(rl, 'Include frontend?', false);
+    const includeFlows = await promptYesNo(rl, 'Include flows?', false);
+    const adminEmail = includeAuth
+      ? await promptDefault(rl, 'Admin email', '')
+      : undefined;
+
+    // Optional custom domain for prod (bare domain, no scheme/path/port)
+    const BARE_DOMAIN_RE = /^[a-z0-9.-]+\.[a-z]{2,}$/;
+    let prodUrl = '';
+    if (includeFrontend) {
+      const raw = await promptDefault(rl, 'Production dashboard URL (optional — skip for CloudFront-default)', '');
+      if (raw && !BARE_DOMAIN_RE.test(raw.trim())) {
+        console.warn('[tib] Invalid domain format — must be a bare domain like "app.acme.com". Skipping.');
+      } else {
+        prodUrl = raw.trim();
+      }
+    }
+
+    const defaultOutDir = opts.outDir ? resolve(opts.outDir) : resolve(process.cwd(), projectName);
+    const outputDirRaw = await promptDefault(rl, 'Output directory', defaultOutDir);
+    const outputDir = resolve(outputDirRaw);
+
+    // 2. Fetch versions.json
+    console.log('\nFetching scaffold versions...');
+    const versionsJson = await fetchVersionsJson(SCAFFOLD_BUCKET);
+    const scaffoldVersion = await promptDefault(rl, 'Scaffold version', versionsJson.latest);
+
+    rl.close();
+
+    // 3. Fetch modules.json
+    console.log(`\nFetching modules for scaffold@${scaffoldVersion}...`);
+    const modulesJson = await fetchModulesJson(SCAFFOLD_BUCKET, scaffoldVersion);
+
+    // 4. Resolve module selection
+    const selectedIds = new Set<string>(['core', 'backend-lambda']);
+    if (includeDatabase) selectedIds.add('db-aurora');
+    if (includeAuth) selectedIds.add('auth-cognito');
+    if (includeFrontend) selectedIds.add('frontend');
+    if (includeFlows) selectedIds.add('flows');
+
+    // Expand dependencies
+    const moduleMap = new Map(modulesJson.modules.map((m) => [m.id, m]));
+    let changed = true;
+    while (changed) {
+      changed = false;
+      for (const id of [...selectedIds]) {
+        const mod = moduleMap.get(id);
+        if (!mod) continue;
+        for (const dep of mod.dependencies) {
+          if (!selectedIds.has(dep)) {
+            selectedIds.add(dep);
+            changed = true;
+          }
+        }
+      }
+    }
+
+    const orderedModules = topoSort(modulesJson.modules, selectedIds);
+
+    // 5. Prepare output directory
+    await mkdir(outputDir, { recursive: true });
+    await mkdir(join(outputDir, '.tib'), { recursive: true });
+
+    // 6. Get CLI version from package.json
+    let cliVersion = '0.0.0';
+    try {
+      const { createRequire } = await import('node:module');
+      const require = createRequire(import.meta.url);
+      const pkgJson = require('../../package.json') as { version: string };
+      cliVersion = pkgJson.version;
+    } catch {
+      // ignore — fallback to 0.0.0
+    }
+
+    // 7. Build token context
+    const tokenCtx = buildTokenContext(
+      { projectName, awsRegion, awsAccountId, adminEmail },
+      scaffoldVersion,
+      cliVersion
+    );
+
+    // 8. Create manifest
+    const manifest: TibManifest = createManifest(
+      scaffoldVersion,
+      projectName,
+      awsRegion,
+      [...selectedIds]
+    );
+
+    // 9. Process each module in topological order
+    for (const mod of orderedModules) {
+      console.log(`  Installing module: ${mod.id}@${mod.version}...`);
+
+      const tarBuf = await fetchModuleTarball(
+        SCAFFOLD_BUCKET,
+        scaffoldVersion,
+        mod.tarball,
+        mod.sha256
+      );
+
+      const tarEntries = await parseTarball(tarBuf);
+
+      // Extract MANIFEST.json from tarball
+      const manifestEntry = getTarEntry(tarEntries, 'MANIFEST.json');
+      if (!manifestEntry) {
+        cliLogger.warn({ moduleId: mod.id }, 'No MANIFEST.json in tarball — skipping');
+        continue;
+      }
+
+      const tarManifest = JSON.parse(manifestEntry.content.toString('utf-8')) as TarballManifestEntry[];
+
+      // installPrefix for modules like 'frontend'
+      const modMeta = moduleMap.get(mod.id);
+      const installPrefix: string = (modMeta as (S3ModuleEntry & { installPrefix?: string }) | undefined)?.installPrefix ?? '';
+
+      for (const fileEntry of tarManifest) {
+        const tarEntry = getTarEntry(tarEntries, fileEntry.path);
+        if (!tarEntry) {
+          cliLogger.warn({ moduleId: mod.id, path: fileEntry.path }, 'File listed in MANIFEST.json not found in tarball');
+          continue;
+        }
+
+        // Determine install path
+        let installPath = fileEntry.installedAs ?? fileEntry.path;
+        // Strip .tpl extension
+        if (installPath.endsWith('.tpl')) {
+          installPath = installPath.slice(0, -4);
+        }
+        // Apply installPrefix
+        if (installPrefix) {
+          installPath = `${installPrefix}/${installPath}`;
+        }
+
+        // Process content
+        let content = tarEntry.content.toString('utf-8');
+
+        // Token substitution for template files
+        if (fileEntry.isTemplate) {
+          content = applyTokens(content, tokenCtx);
+        }
+
+        // Inject scaffold header
+        content = injectHeader(content, installPath, mod.id, mod.version);
+
+        // Write file
+        const destPath = join(outputDir, installPath);
+        const parentParts = installPath.split('/').slice(0, -1);
+        if (parentParts.length > 0) {
+          await mkdir(join(outputDir, ...parentParts), { recursive: true });
+        }
+        await writeFile(destPath, content, 'utf-8');
+
+        // Track in manifest (SHA-256 of written content)
+        const sha256 = computeChecksumString(content);
+        upsertManifestFile(manifest, {
+          path: installPath,
+          module: mod.id,
+          moduleVersion: mod.version,
+          sha256,
+          wasTemplate: fileEntry.isTemplate,
+          installedAt: new Date().toISOString(),
+          policy: fileEntry.policy ?? 'tracked',
+        });
+      }
+    }
+
+    // 10. Write .mc/scaffold-config.json
+    const environments: EnvironmentsConfig | undefined = prodUrl
+      ? { prod: { dashboardUrl: prodUrl } }
+      : undefined;
+
+    const scaffoldConfig: ScaffoldConfig = {
+      scaffoldVersion,
+      enabledModules: [...selectedIds] as ModuleId[],
+      projectName,
+      awsRegion,
+      awsAccountId,
+      adminEmail,
+      domainIds: [],
+      flowIds: [],
+      scaffoldBucket: SCAFFOLD_BUCKET,
+      ...(environments ? { environments } : {}),
+    };
+    await writeScaffoldConfig(outputDir, scaffoldConfig);
+
+    // 11. Write .mc/manifest.json
+    await writeManifest(outputDir, manifest);
+
+    // 12. Git init + initial commit
+    console.log('\nInitialising git repository...');
+    execSync(`git -C "${outputDir}" init`, { stdio: 'pipe' });
+    execSync(`git -C "${outputDir}" add -A`, { stdio: 'pipe' });
+    execSync(
+      `git -C "${outputDir}" commit -m "chore: initial scaffold from mc-scaffold@${scaffoldVersion}"`,
+      { stdio: 'pipe' }
+    );
+
+    cliLogger.info({ projectName, outputDir, scaffoldVersion }, 'Project created');
+    console.log(
+      `\nProject "${projectName}" created at ${outputDir}\n\n` +
+      `  Next steps:\n` +
+      `    cd ${outputDir}\n` +
+      `    npm install\n` +
+      `    npm run dev\n`
+    );
+  } finally {
+    rl.close();
+  }
+}

package/src/commands/dev.ts

@@ -0,0 +1,47 @@
+import { resolve } from 'node:path';
+import { buildRegistry } from '../builder/build-registry.js';
+import { createApiServer } from '../server/api-server.js';
+import { cliLogger } from '../utils/logger.js';
+
+/**
+ * Options for the dev command.
+ */
+export interface DevOptions {
+  /** Absolute or relative path to the domain root directory. */
+  domainRoot: string;
+  /** Port for the local HTTP server. Defaults to 3000. */
+  port?: number;
+}
+
+/**
+ * Execute the dev command: build the domain registry and start the local Fastify
+ * HTTP server. Keeps the process running. Shuts down gracefully on SIGINT/SIGTERM.
+ * @param options - DevOptions specifying domain root and optional port.
+ */
+export async function runDev(options: DevOptions): Promise<void> {
+  const domainRoot = resolve(options.domainRoot);
+  const port = options.port ?? 3000;
+
+  cliLogger.info({ domainRoot }, 'Building registry for dev server');
+  const { registry, warnings } = await buildRegistry(domainRoot);
+
+  for (const w of warnings) {
+    cliLogger.warn(w);
+  }
+
+  cliLogger.info(
+    { domain: registry.domain.id, apis: registry.apis.length, port },
+    'Starting local dev server'
+  );
+
+  const server = await createApiServer({ port, registry, domainRoot });
+
+  async function shutdown(): Promise<void> {
+    cliLogger.info('Shutting down dev server');
+    await server.close();
+    process.exit(0);
+  }
+
+  process.on('SIGINT', () => { void shutdown(); });
+  process.on('SIGTERM', () => { void shutdown(); });
+}