@webstir-io/webstir 0.1.1 → 0.1.2

package/scripts/check-standalone-install.mjs

@@ -0,0 +1,221 @@
+#!/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 artifactsRoot = path.join(packageRoot, 'artifacts');
+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-standalone-install-'));
+  const consumerRoot = path.join(tempRoot, 'consumer');
+  const existingArtifacts = await listArtifacts(artifactsRoot);
+  const existingBackendTarballs = await listArtifacts(backendPackageRoot);
+  let tarballPath = null;
+  let backendTarballPath = null;
+  let keepWorkspace = false;
+  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}`,
+  };
+
+  try {
+    await mkdir(consumerRoot, { recursive: true });
+    await writeConsumerManifest(consumerRoot, localPackageSpecs);
+
+    tarballPath = await packStandaloneTarball();
+    console.log(`[webstir][install-smoke] tarball ${tarballPath}`);
+    backendTarballPath = await packPackageTarball(backendPackageRoot);
+    console.log(`[webstir][install-smoke] backend tarball ${backendTarballPath}`);
+
+    await run(['bun', 'add', tarballPath], consumerRoot);
+
+    const cliPath = path.join(consumerRoot, 'node_modules', '.bin', 'webstir');
+    await assertExists(cliPath, 'installed CLI binary');
+
+    await run([cliPath, 'init', 'full', 'site'], consumerRoot);
+
+    const workspaceRoot = path.join(consumerRoot, 'site');
+    await assertExists(
+      path.join(workspaceRoot, 'package.json'),
+      'scaffolded workspace package.json',
+    );
+
+    await writeWorkspaceLocalPackageOverrides(workspaceRoot, localPackageSpecs);
+    await run(['bun', 'install'], workspaceRoot);
+    await installLocalBackendTarball(workspaceRoot, backendTarballPath);
+    await assertExists(
+      path.join(workspaceRoot, 'node_modules', '.bin', 'webstir-backend-deploy'),
+      'workspace deploy runner binary',
+    );
+    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', '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',
+    );
+
+    console.log('[webstir][install-smoke] standalone 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, existingArtifacts);
+    }
+    if (backendTarballPath) {
+      await cleanupGeneratedTarball(backendTarballPath, existingBackendTarballs);
+    }
+    if (!keepWorkspace) {
+      await rm(tempRoot, { recursive: true, force: true });
+    }
+  }
+}
+
+async function packStandaloneTarball() {
+  const output = await run(['bun', 'run', 'pack:standalone'], packageRoot);
+  const tarballPath = output
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter((line) => line.endsWith('-standalone.tgz'))
+    .at(-1);
+
+  if (!tarballPath) {
+    throw new Error(`Unable to determine standalone tarball path from pack output:\n${output}`);
+  }
+
+  return path.resolve(packageRoot, tarballPath);
+}
+
+async function packPackageTarball(root) {
+  const output = await run(['bun', 'pm', 'pack'], 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 installLocalBackendTarball(workspaceRoot, backendTarballPath) {
+  await run(['bun', 'remove', '@webstir-io/webstir-backend'], workspaceRoot);
+  await run(['bun', 'add', backendTarballPath], workspaceRoot);
+}
+
+async function writeConsumerManifest(consumerRoot, localPackageSpecs) {
+  await writeFile(
+    path.join(consumerRoot, 'package.json'),
+    `${JSON.stringify(
+      {
+        name: 'webstir-standalone-smoke',
+        private: true,
+        overrides: localPackageSpecs,
+      },
+      null,
+      2,
+    )}\n`,
+    'utf8',
+  );
+}
+
+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 assertExists(targetPath, label) {
+  try {
+    await access(targetPath, fsConstants.F_OK);
+  } catch {
+    throw new Error(`Expected ${label} at ${targetPath}`);
+  }
+}
+
+async function listArtifacts(root) {
+  try {
+    return new Set(await readdir(root));
+  } catch {
+    return new Set();
+  }
+}
+
+async function cleanupGeneratedTarball(tarballPath, existingArtifacts) {
+  const tarballName = path.basename(tarballPath);
+  if (existingArtifacts.has(tarballName)) {
+    return;
+  }
+
+  await rm(tarballPath, { force: true });
+
+  const remaining = await listArtifacts(artifactsRoot);
+  if (remaining.size === 0) {
+    await rm(artifactsRoot, { recursive: true, 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);
+});

package/scripts/pack-standalone.mjs

@@ -1,8 +1,7 @@
-#!/usr/bin/env node
+#!/usr/bin/env bun
 
 import os from 'node:os';
 import path from 'node:path';
-import { spawnSync } from 'node:child_process';
 import { cp, mkdir, mkdtemp, readFile, rename, rm, writeFile } from 'node:fs/promises';
 
 const scriptRoot = path.dirname(new URL(import.meta.url).pathname);
@@ -12,15 +11,18 @@ const outputRoot = path.join(packageRoot, 'artifacts');
 
 const internalPackages = [
   ['@webstir-io/module-contract', path.join(repoRoot, 'packages', 'contracts', 'module-contract')],
-  ['@webstir-io/testing-contract', path.join(repoRoot, 'packages', 'contracts', 'testing-contract')],
+  [
+    '@webstir-io/testing-contract',
+    path.join(repoRoot, 'packages', 'contracts', 'testing-contract'),
+  ],
   ['@webstir-io/webstir-frontend', path.join(repoRoot, 'packages', 'tooling', 'webstir-frontend')],
   ['@webstir-io/webstir-backend', path.join(repoRoot, 'packages', 'tooling', 'webstir-backend')],
   ['@webstir-io/webstir-testing', path.join(repoRoot, 'packages', 'tooling', 'webstir-testing')],
 ];
 
 async function main() {
-  run('bun', ['run', 'build:deps'], packageRoot);
-  run('node', ['scripts/sync-assets.mjs'], packageRoot);
+  await run(['bun', 'run', 'build:deps'], packageRoot);
+  await run(['node', 'scripts/sync-assets.mjs'], packageRoot);
 
   const tempRoot = await mkdtemp(path.join(os.tmpdir(), 'webstir-standalone-pack-'));
   const tarballRoot = path.join(tempRoot, 'tarballs');
@@ -42,6 +44,7 @@ async function main() {
 
     const packageJson = JSON.parse(await readFile(path.join(packageRoot, 'package.json'), 'utf8'));
     const originalDependencies = { ...packageJson.dependencies };
+    const originalOverrides = packageJson.overrides ? { ...packageJson.overrides } : null;
     packageJson.dependencies = Object.fromEntries(
       Object.entries(originalDependencies).map(([name, version]) => {
         const tarballPath = tarballs.get(name);
@@ -50,19 +53,38 @@ async function main() {
         }
 
         return [name, `file:${path.relative(stageRoot, tarballPath).split(path.sep).join('/')}`];
-      })
+      }),
+    );
+    packageJson.overrides = Object.fromEntries(
+      [...tarballs].map(([name, tarballPath]) => [
+        name,
+        `file:${path.relative(stageRoot, tarballPath).split(path.sep).join('/')}`,
+      ]),
     );
     packageJson.bundledDependencies = Object.keys(packageJson.dependencies);
     packageJson.files = ['assets', 'src', 'README.md'];
     delete packageJson.scripts;
     delete packageJson.devDependencies;
 
-    await writeFile(path.join(stageRoot, 'package.json'), `${JSON.stringify(packageJson, null, 2)}\n`, 'utf8');
+    await writeFile(
+      path.join(stageRoot, 'package.json'),
+      `${JSON.stringify(packageJson, null, 2)}\n`,
+      'utf8',
+    );
 
-    run('bun', ['install'], stageRoot);
+    await run(['bun', 'install'], stageRoot);
     packageJson.dependencies = originalDependencies;
-    await writeFile(path.join(stageRoot, 'package.json'), `${JSON.stringify(packageJson, null, 2)}\n`, 'utf8');
-    const tarballName = run('bun', ['pm', 'pack'], stageRoot)
+    if (originalOverrides) {
+      packageJson.overrides = originalOverrides;
+    } else {
+      delete packageJson.overrides;
+    }
+    await writeFile(
+      path.join(stageRoot, 'package.json'),
+      `${JSON.stringify(packageJson, null, 2)}\n`,
+      'utf8',
+    );
+    const tarballName = (await run(['bun', 'pm', 'pack'], stageRoot))
       .split(/\r?\n/)
       .map((line) => line.trim())
       .filter((line) => line.endsWith('.tgz'))
@@ -74,6 +96,7 @@ async function main() {
 
     const standaloneName = tarballName.replace(/\.tgz$/, '-standalone.tgz');
     const destination = path.join(outputRoot, standaloneName);
+    await mkdir(path.dirname(destination), { recursive: true });
     await rm(destination, { force: true });
     await rename(path.join(stageRoot, tarballName), destination);
     console.log(destination);
@@ -83,7 +106,7 @@ async function main() {
 }
 
 async function packPackage(cwd, outputDir) {
-  const tarballName = run('bun', ['pm', 'pack'], cwd)
+  const tarballName = (await run(['bun', 'pm', 'pack'], cwd))
     .split(/\r?\n/)
     .map((line) => line.trim())
     .filter((line) => line.endsWith('.tgz'))
@@ -99,26 +122,27 @@ async function packPackage(cwd, outputDir) {
   return destination;
 }
 
-function run(command, args, cwd) {
-  const result = spawnSync(command, args, {
-    cwd,
-    stdio: ['ignore', 'pipe', 'pipe'],
-    encoding: 'utf8',
-    env: process.env,
-  });
+async function run(command, cwd) {
+  const [program, ...args] = command;
 
-  if (result.stdout) {
-    process.stdout.write(result.stdout);
-  }
-  if (result.stderr) {
-    process.stderr.write(result.stderr);
-  }
+  try {
+    return await Bun.$.cwd(cwd)`${program} ${args}`.text();
+  } catch (error) {
+    const exitCode =
+      typeof error === 'object' &&
+      error !== null &&
+      'exitCode' in error &&
+      typeof error.exitCode === 'number'
+        ? error.exitCode
+        : null;
+    if (exitCode === null) {
+      throw error;
+    }
 
-  if (result.status !== 0) {
-    throw new Error(`Command failed (${result.status ?? 'unknown'}): ${command} ${args.join(' ')}`);
+    throw new Error(`Command failed (${exitCode}): ${program} ${args.join(' ')}`, {
+      cause: error,
+    });
   }
-
-  return result.stdout ?? '';
 }
 
 main().catch((error) => {

package/scripts/publish.sh

@@ -0,0 +1,9 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+ROOT_DIR="$(cd "${SCRIPT_DIR}/.." && pwd)"
+MONOREPO_ROOT="$(git -C "$ROOT_DIR" rev-parse --show-toplevel)"
+
+exec bun "$MONOREPO_ROOT/tools/release-package.mjs" --package-dir "$ROOT_DIR" "$@"

package/scripts/run-tests.mjs

@@ -0,0 +1,99 @@
+import { readdirSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const packageRoot = path.resolve(__dirname, '..');
+const testsDir = path.join(packageRoot, 'tests');
+
+const browserTestFile = 'tests/progressive-enhancement.browser.integration.test.ts';
+const watchBrowserTestFiles = [
+  'tests/runtime-boundary.integration.test.ts',
+  'tests/bun-first-spa.integration.test.ts',
+  'tests/ssg-watch.integration.test.ts',
+  'tests/full-watch.integration.test.ts',
+];
+const publishModeFilter = 'publish mode';
+const watchModeFilter = 'watch mode';
+
+export function listCoreTestFiles() {
+  return readdirSync(testsDir)
+    .filter((file) => file.endsWith('.ts'))
+    .filter((file) => file !== path.basename(browserTestFile))
+    .filter((file) => !watchBrowserTestFiles.includes(path.posix.join('tests', file)))
+    .sort()
+    .map((file) => path.posix.join('tests', file));
+}
+
+export function buildTestPlan(mode) {
+  const coreTests = {
+    label: 'core orchestrator tests',
+    args: ['test', '--bail=1', ...listCoreTestFiles()],
+  };
+  const publishBrowserTests = {
+    label: 'browser publish proofs',
+    args: ['test', '--bail=1', browserTestFile, '-t', publishModeFilter],
+  };
+  const integrationWatchBrowserTests = {
+    label: 'browser watch integration proofs',
+    args: ['test', '--bail=1', ...watchBrowserTestFiles],
+  };
+  const watchBrowserTests = {
+    label: 'browser watch proofs',
+    args: ['test', '--bail=1', browserTestFile, '-t', watchModeFilter],
+  };
+  const requiredPlan = [
+    coreTests,
+    publishBrowserTests,
+    integrationWatchBrowserTests,
+    watchBrowserTests,
+  ];
+
+  switch (mode) {
+    case 'required':
+      return requiredPlan;
+    case 'publish-browser':
+      return [publishBrowserTests];
+    case 'watch-browser':
+      return [integrationWatchBrowserTests, watchBrowserTests];
+    case 'all':
+    case 'with-watch-browser':
+      return requiredPlan;
+    default:
+      throw new Error(
+        `Unknown orchestrator test mode "${mode}". Expected one of: required, publish-browser, watch-browser, with-watch-browser.`,
+      );
+  }
+}
+
+function runStep(step) {
+  const result = spawnSync('bun', step.args, {
+    cwd: packageRoot,
+    stdio: 'inherit',
+    env: process.env,
+  });
+
+  if (result.status !== 0) {
+    process.exit(result.status ?? 1);
+  }
+}
+
+function isCliInvocation() {
+  const entrypoint = process.argv[1];
+  if (!entrypoint) {
+    return false;
+  }
+
+  return path.resolve(entrypoint) === fileURLToPath(import.meta.url);
+}
+
+if (isCliInvocation()) {
+  const mode = process.argv[2] ?? 'required';
+  const plan = buildTestPlan(mode);
+
+  for (const step of plan) {
+    console.log(`[webstir][tests] ${step.label}`);
+    runStep(step);
+  }
+}