@webstir-io/webstir 0.1.1 → 0.1.3

package/scripts/check-package-install.mjs

@@ -0,0 +1,537 @@
+#!/usr/bin/env bun
+
+import os from 'node:os';
+import path from 'node:path';
+import { access, mkdir, mkdtemp, readFile, readdir, rm, writeFile } from 'node:fs/promises';
+import { constants as fsConstants } from 'node:fs';
+
+const scriptRoot = path.dirname(new URL(import.meta.url).pathname);
+const packageRoot = path.resolve(scriptRoot, '..');
+const repoRoot = path.resolve(packageRoot, '..', '..');
+const moduleContractPackageRoot = path.join(repoRoot, 'packages', 'contracts', 'module-contract');
+const testingContractPackageRoot = path.join(repoRoot, 'packages', 'contracts', 'testing-contract');
+const backendPackageRoot = path.join(repoRoot, 'packages', 'tooling', 'webstir-backend');
+const frontendPackageRoot = path.join(repoRoot, 'packages', 'tooling', 'webstir-frontend');
+const testingPackageRoot = path.join(repoRoot, 'packages', 'tooling', 'webstir-testing');
+
+async function main() {
+  const tempRoot = await mkdtemp(path.join(os.tmpdir(), 'webstir-package-install-'));
+  const installRoot = path.join(tempRoot, 'install-root');
+  const workspaceRoot = path.join(tempRoot, 'site');
+  const apiWorkspaceRoot = path.join(tempRoot, 'api-site');
+  const addTestTarget = 'frontend/pages/home/package-install-smoke';
+  const addRouteTarget = 'package-install-accounts';
+  const addJobTarget = 'package-install-nightly';
+  const addRoutePath = '/api/package-install-accounts';
+  const addJobSchedule = '0 0 * * *';
+  const addJobDescription = 'Package install nightly run';
+  const addJobPriority = 5;
+  const addedTestPath = path.join(
+    workspaceRoot,
+    'src',
+    'frontend',
+    'pages',
+    'home',
+    'tests',
+    'package-install-smoke.test.ts',
+  );
+  const addedJobPath = path.join(workspaceRoot, 'src', 'backend', 'jobs', addJobTarget, 'index.ts');
+  const existingTarballs = await listTarballs(packageRoot);
+  const localPackageSpecs = {
+    '@webstir-io/module-contract': `file:${moduleContractPackageRoot}`,
+    '@webstir-io/testing-contract': `file:${testingContractPackageRoot}`,
+    '@webstir-io/webstir-backend': `file:${backendPackageRoot}`,
+    '@webstir-io/webstir-frontend': `file:${frontendPackageRoot}`,
+    '@webstir-io/webstir-testing': `file:${testingPackageRoot}`,
+  };
+  let tarballPath = null;
+  let keepWorkspace = false;
+
+  try {
+    await mkdir(installRoot, { recursive: true });
+    await writeInstallRootManifest(installRoot);
+
+    tarballPath = await packPackageTarball();
+    console.log(`[webstir][install-smoke] tarball ${tarballPath}`);
+
+    await writeInstallRootManifest(installRoot, {
+      webstirTarballPath: tarballPath,
+      localPackageSpecs,
+    });
+    await run(['bun', 'install'], installRoot);
+
+    const cliPath = path.join(installRoot, 'node_modules', '.bin', 'webstir');
+    await assertExists(cliPath, 'installed CLI binary');
+
+    await run([cliPath, 'init', 'full', workspaceRoot], installRoot);
+    await assertPackageManagedBackendScaffold(workspaceRoot, { expectModule: true });
+
+    await assertExists(
+      path.join(workspaceRoot, 'package.json'),
+      'scaffolded workspace package.json',
+    );
+    await assertPublishedDependencySpecs(installRoot, workspaceRoot, [
+      '@webstir-io/webstir-frontend',
+      '@webstir-io/webstir-backend',
+      '@webstir-io/webstir-testing',
+    ]);
+
+    await writeWorkspaceLocalPackageOverrides(workspaceRoot, localPackageSpecs);
+    await run(['bun', 'install'], workspaceRoot);
+    await installLocalBackendPackage(
+      workspaceRoot,
+      localPackageSpecs['@webstir-io/webstir-backend'],
+    );
+    await assertExists(
+      path.join(workspaceRoot, 'node_modules', '.bin', 'webstir-backend-deploy'),
+      'workspace deploy runner binary',
+    );
+    const addTestOutput = await run(
+      [cliPath, 'add-test', addTestTarget, '--workspace', workspaceRoot],
+      workspaceRoot,
+    );
+    if (!addTestOutput.includes('[webstir] add-test complete')) {
+      throw new Error(`Expected add-test summary in output, received:\n${addTestOutput}`);
+    }
+
+    const addRouteOutput = await run(
+      [
+        cliPath,
+        'add-route',
+        addRouteTarget,
+        '--method',
+        'GET',
+        '--path',
+        addRoutePath,
+        '--workspace',
+        workspaceRoot,
+      ],
+      workspaceRoot,
+    );
+    if (!addRouteOutput.includes('[webstir] add-route complete')) {
+      throw new Error(`Expected add-route summary in output, received:\n${addRouteOutput}`);
+    }
+
+    const addJobOutput = await run(
+      [
+        cliPath,
+        'add-job',
+        addJobTarget,
+        '--schedule',
+        addJobSchedule,
+        '--description',
+        addJobDescription,
+        '--priority',
+        String(addJobPriority),
+        '--workspace',
+        workspaceRoot,
+      ],
+      workspaceRoot,
+    );
+    if (!addJobOutput.includes('[webstir] add-job complete')) {
+      throw new Error(`Expected add-job summary in output, received:\n${addJobOutput}`);
+    }
+
+    await assertExists(addedTestPath, 'scaffolded add-test file');
+    await assertFileContains(addedTestPath, "test('sample passes'", 'sample test body');
+    await assertExists(addedJobPath, 'scaffolded add-job file');
+    await assertFileContains(
+      addedJobPath,
+      '// Generated by webstir add-job',
+      'add-job scaffold body',
+    );
+    await assertManifestEntries(workspaceRoot, {
+      routeName: addRouteTarget,
+      routePath: addRoutePath,
+      jobName: addJobTarget,
+      jobSchedule: addJobSchedule,
+      jobDescription: addJobDescription,
+      jobPriority: addJobPriority,
+    });
+
+    await run([cliPath, 'build', '--workspace', workspaceRoot], workspaceRoot);
+
+    await assertExists(
+      path.join(workspaceRoot, 'build', 'backend', 'index.js'),
+      'backend build output',
+    );
+    await assertExists(
+      path.join(workspaceRoot, 'build', 'backend', 'jobs', addJobTarget, 'index.js'),
+      'add-job build output',
+    );
+    await assertExists(path.join(workspaceRoot, 'build', 'frontend'), 'frontend build output');
+    await assertExists(
+      path.join(workspaceRoot, '.webstir', 'backend-outputs.json'),
+      'backend outputs cache',
+    );
+    await assertExists(
+      path.join(workspaceRoot, '.webstir', 'backend-manifest-digest.json'),
+      'backend manifest digest',
+    );
+    await assertExists(
+      path.join(workspaceRoot, '.webstir', 'frontend-manifest.json'),
+      'frontend manifest',
+    );
+
+    const inspectOutput = await run(
+      [cliPath, 'backend-inspect', '--workspace', workspaceRoot],
+      workspaceRoot,
+    );
+    if (!inspectOutput.includes('[webstir] backend-inspect complete')) {
+      throw new Error(`Expected backend-inspect summary in output, received:\n${inspectOutput}`);
+    }
+    if (!inspectOutput.includes(`GET ${addRoutePath} (${addRouteTarget})`)) {
+      throw new Error(
+        `Expected backend-inspect route summary in output, received:\n${inspectOutput}`,
+      );
+    }
+    if (
+      !inspectOutput.includes(
+        `${addJobTarget} (schedule: ${addJobSchedule}, description: ${addJobDescription}, priority: ${addJobPriority})`,
+      )
+    ) {
+      throw new Error(
+        `Expected backend-inspect job summary in output, received:\n${inspectOutput}`,
+      );
+    }
+
+    const doctorOutput = await run(
+      [cliPath, 'doctor', '--workspace', workspaceRoot],
+      workspaceRoot,
+    );
+    if (!doctorOutput.includes('[webstir] doctor complete')) {
+      throw new Error(`Expected doctor summary in output, received:\n${doctorOutput}`);
+    }
+    if (!doctorOutput.includes('healthy: true')) {
+      throw new Error(`Expected healthy doctor status in output, received:\n${doctorOutput}`);
+    }
+    if (!doctorOutput.includes('issues: none')) {
+      throw new Error(`Expected zero doctor issues in output, received:\n${doctorOutput}`);
+    }
+
+    const operationsOutput = await run([cliPath, 'operations', '--json'], workspaceRoot);
+    if (!operationsOutput.includes('"command": "operations"')) {
+      throw new Error(`Expected operations JSON output, received:\n${operationsOutput}`);
+    }
+    if (!operationsOutput.includes('"id": "doctor"')) {
+      throw new Error(
+        `Expected doctor operation in catalog output, received:\n${operationsOutput}`,
+      );
+    }
+
+    const frontendInspectOutput = await run(
+      [cliPath, 'frontend-inspect', '--json', '--workspace', workspaceRoot],
+      workspaceRoot,
+    );
+    if (!frontendInspectOutput.includes('"command": "frontend-inspect"')) {
+      throw new Error(`Expected frontend-inspect JSON output, received:\n${frontendInspectOutput}`);
+    }
+    if (!frontendInspectOutput.includes('"pages"')) {
+      throw new Error(
+        `Expected frontend-inspect page data in output, received:\n${frontendInspectOutput}`,
+      );
+    }
+
+    const inspectOutputJson = await run(
+      [cliPath, 'inspect', '--json', '--workspace', workspaceRoot],
+      workspaceRoot,
+    );
+    if (!inspectOutputJson.includes('"command": "inspect"')) {
+      throw new Error(`Expected inspect JSON output, received:\n${inspectOutputJson}`);
+    }
+    if (!inspectOutputJson.includes('"frontend"')) {
+      throw new Error(`Expected inspect frontend data in output, received:\n${inspectOutputJson}`);
+    }
+    if (!inspectOutputJson.includes('"backend"')) {
+      throw new Error(`Expected inspect backend data in output, received:\n${inspectOutputJson}`);
+    }
+
+    const agentInspectOutput = await run(
+      [cliPath, 'agent', 'inspect', '--json', '--workspace', workspaceRoot],
+      workspaceRoot,
+    );
+    if (!agentInspectOutput.includes('"command": "agent"')) {
+      throw new Error(`Expected agent JSON output, received:\n${agentInspectOutput}`);
+    }
+    if (!agentInspectOutput.includes('"goal": "inspect"')) {
+      throw new Error(`Expected inspect goal in agent output, received:\n${agentInspectOutput}`);
+    }
+    if (!agentInspectOutput.includes('"success": true')) {
+      throw new Error(`Expected successful agent inspect output, received:\n${agentInspectOutput}`);
+    }
+
+    const testOutput = await run(
+      [cliPath, 'test', '--workspace', workspaceRoot, '--runtime', 'frontend'],
+      workspaceRoot,
+    );
+    if (!testOutput.includes('[webstir] test complete')) {
+      throw new Error(`Expected test summary in output, received:\n${testOutput}`);
+    }
+    if (!testOutput.includes('runtime: frontend')) {
+      throw new Error(`Expected frontend runtime summary in output, received:\n${testOutput}`);
+    }
+    if (!testOutput.includes('failed: 0')) {
+      throw new Error(`Expected zero frontend test failures in output, received:\n${testOutput}`);
+    }
+
+    await run([cliPath, 'init', 'api', apiWorkspaceRoot], installRoot);
+    await assertPackageManagedBackendScaffold(apiWorkspaceRoot);
+    await assertPublishedDependencySpecs(installRoot, apiWorkspaceRoot, [
+      '@webstir-io/webstir-backend',
+      '@webstir-io/webstir-testing',
+    ]);
+    await writeWorkspaceLocalPackageOverrides(apiWorkspaceRoot, localPackageSpecs);
+    await run(['bun', 'install'], apiWorkspaceRoot);
+    await installLocalBackendPackage(
+      apiWorkspaceRoot,
+      localPackageSpecs['@webstir-io/webstir-backend'],
+    );
+    await assertExists(
+      path.join(apiWorkspaceRoot, 'node_modules', '.bin', 'webstir-backend-deploy'),
+      'api workspace deploy runner binary',
+    );
+    await run([cliPath, 'build', '--workspace', apiWorkspaceRoot], apiWorkspaceRoot);
+    await assertExists(
+      path.join(apiWorkspaceRoot, 'build', 'backend', 'index.js'),
+      'api backend build output',
+    );
+
+    console.log('[webstir][install-smoke] package install smoke passed');
+  } catch (error) {
+    keepWorkspace = (process.env.WEBSTIR_INSTALL_SMOKE_KEEP ?? '').toLowerCase() === '1';
+    if (keepWorkspace) {
+      console.error(`[webstir][install-smoke] preserving failed workspace at ${tempRoot}`);
+    }
+    throw error;
+  } finally {
+    if (tarballPath) {
+      await cleanupGeneratedTarball(tarballPath, existingTarballs);
+    }
+    if (!keepWorkspace) {
+      await rm(tempRoot, { recursive: true, force: true });
+    }
+  }
+}
+
+async function assertPublishedDependencySpecs(installRoot, workspaceRoot, packageNames) {
+  const workspacePackageJson = JSON.parse(
+    await readFile(path.join(workspaceRoot, 'package.json'), 'utf8'),
+  );
+  const dependencies = workspacePackageJson.dependencies ?? {};
+
+  for (const packageName of packageNames) {
+    const dependencySpec = dependencies[packageName];
+    if (!dependencySpec) {
+      throw new Error(
+        `Expected scaffolded dependency ${packageName} in ${path.join(workspaceRoot, 'package.json')}`,
+      );
+    }
+    if (dependencySpec === 'workspace:*') {
+      throw new Error(`Expected published dependency for ${packageName}, received workspace:*`);
+    }
+
+    const installedVersion = await readInstalledPackageVersion(installRoot, packageName);
+    if (dependencySpec !== `^${installedVersion}`) {
+      throw new Error(
+        `Expected ${packageName} dependency spec ^${installedVersion}, received ${dependencySpec}`,
+      );
+    }
+  }
+}
+
+async function assertManifestEntries(workspaceRoot, expected) {
+  const workspacePackageJson = JSON.parse(
+    await readFile(path.join(workspaceRoot, 'package.json'), 'utf8'),
+  );
+  const moduleManifest = workspacePackageJson.webstir?.moduleManifest ?? {};
+  const routes = Array.isArray(moduleManifest.routes) ? moduleManifest.routes : [];
+  const jobs = Array.isArray(moduleManifest.jobs) ? moduleManifest.jobs : [];
+
+  const route = routes.find((entry) => entry?.name === expected.routeName);
+  if (!route || route.method !== 'GET' || route.path !== expected.routePath) {
+    throw new Error(
+      `Expected backend route manifest entry for ${expected.routeName}, received:\n${JSON.stringify(route, null, 2)}`,
+    );
+  }
+
+  const job = jobs.find((entry) => entry?.name === expected.jobName);
+  if (
+    !job ||
+    job.schedule !== expected.jobSchedule ||
+    job.description !== expected.jobDescription ||
+    job.priority !== expected.jobPriority
+  ) {
+    throw new Error(
+      `Expected backend job manifest entry for ${expected.jobName}, received:\n${JSON.stringify(job, null, 2)}`,
+    );
+  }
+}
+
+async function assertPackageManagedBackendScaffold(workspaceRoot, options = {}) {
+  const backendRoot = path.join(workspaceRoot, 'src', 'backend');
+  const backendIndexPath = path.join(backendRoot, 'index.ts');
+  const backendIndex = await readFile(backendIndexPath, 'utf8');
+
+  if (!backendIndex.includes('createDefaultBunBackendBootstrap')) {
+    throw new Error(`Expected package-managed Bun bootstrap helper in ${backendIndexPath}`);
+  }
+  if (backendIndex.includes('http.createServer')) {
+    throw new Error(`Expected thinner backend entrypoint in ${backendIndexPath}`);
+  }
+
+  await assertMissing(path.join(backendRoot, 'server', 'bun.ts'), 'legacy Bun backend wrapper');
+  await assertMissing(
+    path.join(backendRoot, 'runtime'),
+    'legacy backend runtime wrapper directory',
+  );
+  if (options.expectModule) {
+    await assertExists(path.join(backendRoot, 'module.ts'), 'backend module definition');
+  }
+}
+
+async function installLocalBackendPackage(workspaceRoot, backendPackageSpec) {
+  await run(['bun', 'remove', '@webstir-io/webstir-backend'], workspaceRoot);
+  await run(['bun', 'add', backendPackageSpec], workspaceRoot);
+}
+
+async function writeWorkspaceLocalPackageOverrides(workspaceRoot, localPackageSpecs) {
+  const packageJsonPath = path.join(workspaceRoot, 'package.json');
+  const packageJson = JSON.parse(await readFile(packageJsonPath, 'utf8'));
+  packageJson.overrides = {
+    ...(packageJson.overrides ?? {}),
+    ...localPackageSpecs,
+  };
+  await writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`, 'utf8');
+}
+
+async function writeInstallRootManifest(installRoot, options = {}) {
+  const dependencies = { ...(options.localPackageSpecs ?? {}) };
+  if (options.webstirTarballPath) {
+    dependencies['@webstir-io/webstir'] = options.webstirTarballPath;
+  }
+
+  const packageJson = {
+    name: 'webstir-package-smoke',
+    private: true,
+    ...(Object.keys(dependencies).length > 0 ? { dependencies } : {}),
+    ...(options.localPackageSpecs
+      ? {
+          overrides: options.localPackageSpecs,
+        }
+      : {}),
+  };
+
+  await writeFile(
+    path.join(installRoot, 'package.json'),
+    `${JSON.stringify(packageJson, null, 2)}\n`,
+    'utf8',
+  );
+}
+
+async function packPackageTarball(root = packageRoot) {
+  const output =
+    root === packageRoot
+      ? await run(['bun', 'run', 'pack:local'], root)
+      : await run(['bun', 'pm', 'pack'], root);
+  return resolvePackedTarballPath(output, root);
+}
+
+function resolvePackedTarballPath(output, root) {
+  const tarballPath = output
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter((line) => line.endsWith('.tgz'))
+    .at(-1);
+
+  if (!tarballPath) {
+    throw new Error(`Unable to determine package tarball path from pack output:\n${output}`);
+  }
+
+  return path.resolve(root, tarballPath);
+}
+
+async function readInstalledPackageVersion(installRoot, packageName) {
+  const packageJsonPath = path.join(
+    installRoot,
+    'node_modules',
+    ...packageName.split('/'),
+    'package.json',
+  );
+  const packageJson = JSON.parse(await readFile(packageJsonPath, 'utf8'));
+  if (!packageJson.version) {
+    throw new Error(`Missing version in ${packageJsonPath}`);
+  }
+
+  return packageJson.version;
+}
+
+async function assertExists(targetPath, label) {
+  try {
+    await access(targetPath, fsConstants.F_OK);
+  } catch {
+    throw new Error(`Expected ${label} at ${targetPath}`);
+  }
+}
+
+async function assertFileContains(targetPath, expectedSnippet, label) {
+  const content = await readFile(targetPath, 'utf8');
+  if (!content.includes(expectedSnippet)) {
+    throw new Error(`Expected ${label} in ${targetPath}`);
+  }
+}
+
+async function assertMissing(targetPath, label) {
+  try {
+    await access(targetPath, fsConstants.F_OK);
+  } catch {
+    return;
+  }
+
+  throw new Error(`Expected ${label} to be absent at ${targetPath}`);
+}
+
+async function listTarballs(root) {
+  try {
+    return new Set((await readdir(root)).filter((entry) => entry.endsWith('.tgz')));
+  } catch {
+    return new Set();
+  }
+}
+
+async function cleanupGeneratedTarball(tarballPath, existingTarballs) {
+  const tarballName = path.basename(tarballPath);
+  if (existingTarballs.has(tarballName)) {
+    return;
+  }
+
+  await rm(tarballPath, { force: true });
+}
+
+async function run(command, cwd) {
+  const proc = Bun.spawn({
+    cmd: command,
+    cwd,
+    stdout: 'pipe',
+    stderr: 'pipe',
+    env: process.env,
+  });
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+    proc.exited,
+  ]);
+
+  if (exitCode !== 0) {
+    const detail = [stdout.trim(), stderr.trim()].filter(Boolean).join('\n');
+    throw new Error(
+      `Command failed (${exitCode}): ${command.join(' ')}${detail ? `\n${detail}` : ''}`,
+    );
+  }
+
+  return stdout;
+}
+
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exit(1);
+});