@webstir-io/webstir-backend 0.1.15 → 0.1.16

package/scripts/publish.sh

@@ -2,98 +2,8 @@
 
 set -euo pipefail
 
-usage() {
-  cat <<'EOF'
-Usage: scripts/publish.sh <patch|minor|major|x.y.z> [--no-push]
-
-Examples:
-  scripts/publish.sh patch
-  scripts/publish.sh 0.1.0
-
-The script requires a clean git worktree.
-
-By default, the script pushes the version bump commit and tag. To skip pushing,
-pass --no-push or set PUBLISH_NO_PUSH=1.
-EOF
-  exit 1
-}
-
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 ROOT_DIR="$(cd "${SCRIPT_DIR}/.." && pwd)"
+MONOREPO_ROOT="$(git -C "$ROOT_DIR" rev-parse --show-toplevel)"
 
-main() {
-  if [[ $# -lt 1 ]]; then
-    echo "error: version bump argument missing" >&2
-    usage
-  fi
-
-  local bump="$1"; shift || true
-  local no_push="false"
-
-  while [[ $# -gt 0 ]]; do
-    case "$1" in
-      --no-push)
-        no_push="true"
-        ;;
-      *)
-        echo "error: unknown option '$1'" >&2
-        usage
-        ;;
-    esac
-    shift || true
-  done
-
-  if [[ ! $bump =~ ^(patch|minor|major)$ && ! $bump =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
-    echo "error: invalid bump '$bump'" >&2
-    usage
-  fi
-
-  ensure_clean_git
-
-  cd "$ROOT_DIR"
-
-  echo "› npm version $bump"
-  npm version "$bump" -m "v%s"
-
-  echo "› npm install --package-lock-only"
-  npm install --package-lock-only
-
-  echo "› npm run clean"
-  npm run clean
-
-  echo "› npm run build"
-  npm run build
-
-  echo "› npm test"
-  npm test
-
-  echo "› npm run smoke"
-  npm run smoke
-
-  echo "› Skipping direct npm publish; pushing commit+tag will trigger the release workflow."
-
-  if [[ "$no_push" == "true" || "${PUBLISH_NO_PUSH:-}" =~ ^([Yy][Ee][Ss]|[Yy]|1|true)$ ]]; then
-    echo "› Skipping git push (no-push)."
-    echo "  To publish upstream later, run: git push && git push --tags"
-    return 0
-  fi
-
-  echo "› git push"
-  git push
-  echo "› git push --tags"
-  git push --tags
-}
-
-ensure_clean_git() {
-  cd "$ROOT_DIR"
-  if ! git diff --quiet --ignore-submodules HEAD; then
-    echo "error: git worktree has uncommitted changes" >&2
-    exit 1
-  fi
-  if ! git diff --quiet --cached --ignore-submodules; then
-    echo "error: git index has staged changes" >&2
-    exit 1
-  fi
-}
-
-main "$@"
+exec bun "$MONOREPO_ROOT/tools/release-package.mjs" --package-dir "$ROOT_DIR" "$@"

package/scripts/smoke.mjs

@@ -1,7 +1,7 @@
 import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
-import { fileURLToPath } from 'node:url';
+import { fileURLToPath, pathToFileURL } from 'node:url';
 import { spawn } from 'node:child_process';
 import { backendProvider } from '../dist/index.js';
 import { CONTRACT_VERSION } from '@webstir-io/module-contract';
@@ -12,6 +12,11 @@ function getLocalBinPath() {
   return path.join(pkgRoot, 'node_modules', '.bin');
 }
 
+function getPackageRoot() {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  return path.resolve(here, '..');
+}
+
 async function ensureDir(dir) {
   await fs.mkdir(dir, { recursive: true });
 }
@@ -23,17 +28,236 @@ async function copyFile(src, dest) {
 
 async function installPackages(workspace, packages, options = { dev: false }) {
   if (!packages || packages.length === 0) return;
-  const args = ['install', '--silent', ...packages];
+  const args = ['add', '--silent', ...packages];
   if (options.dev) {
     args.push('-D');
   }
   await new Promise((resolve, reject) => {
-    const child = spawn('npm', args, { cwd: workspace, stdio: 'ignore' });
+    const child = spawn('bun', args, { cwd: workspace, stdio: 'ignore' });
     child.on('error', reject);
-    child.on('close', (code) => (code === 0 ? resolve() : reject(new Error(`npm install failed (${code})`))));
+    child.on('close', (code) =>
+      code === 0 ? resolve() : reject(new Error(`bun add failed (${code})`)),
+    );
   });
 }
 
+async function pathExists(target) {
+  try {
+    await fs.access(target);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function runBunProbe(script, { cwd, env }) {
+  return await new Promise((resolve, reject) => {
+    const child = spawn('bun', ['--eval', script], {
+      cwd,
+      env: {
+        ...process.env,
+        ...env,
+      },
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    let stdout = '';
+    let stderr = '';
+    child.stdout.on('data', (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr.on('data', (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on('error', reject);
+    child.on('close', (code) => {
+      if (code !== 0) {
+        reject(new Error(`bun probe failed (${code}).\nstdout:\n${stdout}\nstderr:\n${stderr}`));
+        return;
+      }
+      const line = stdout
+        .split(/\r?\n/)
+        .map((value) => value.trim())
+        .find((value) => value.startsWith('{'));
+      if (!line) {
+        reject(new Error(`bun probe did not emit JSON.\nstdout:\n${stdout}\nstderr:\n${stderr}`));
+        return;
+      }
+      resolve(JSON.parse(line));
+    });
+  });
+}
+
+async function linkWorkspaceNodeModules(workspace) {
+  const packageRoot = getPackageRoot();
+  const source = path.join(packageRoot, 'node_modules');
+  const target = path.join(workspace, 'node_modules');
+  await fs.mkdir(target, { recursive: true });
+
+  const entries = await fs.readdir(source, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.name === '@webstir-io') {
+      continue;
+    }
+    await createSymlinkIfMissing(
+      path.join(source, entry.name),
+      path.join(target, entry.name),
+      entry.isDirectory() ? 'dir' : 'file',
+    );
+  }
+
+  const scopeSource = path.join(source, '@webstir-io');
+  const scopeTarget = path.join(target, '@webstir-io');
+  await fs.mkdir(scopeTarget, { recursive: true });
+  const scopeEntries = await fs.readdir(scopeSource, { withFileTypes: true });
+  for (const entry of scopeEntries) {
+    await createSymlinkIfMissing(
+      path.join(scopeSource, entry.name),
+      path.join(scopeTarget, entry.name),
+      entry.isDirectory() ? 'dir' : 'file',
+    );
+  }
+
+  await createSymlinkIfMissing(packageRoot, path.join(scopeTarget, 'webstir-backend'), 'dir');
+}
+
+async function createSymlinkIfMissing(source, target, type) {
+  try {
+    await fs.symlink(source, target, type);
+  } catch (error) {
+    if (error && typeof error === 'object' && 'code' in error && error.code === 'EEXIST') {
+      return;
+    }
+    throw error;
+  }
+}
+
+async function runTemplateSqliteProbes(workspace) {
+  const alternateCwd = await fs.mkdtemp(
+    path.join(os.tmpdir(), 'webstir-backend-smoke-sqlite-cwd-'),
+  );
+  const sessionStoreUrl = JSON.stringify(
+    pathToFileURL(path.join(workspace, 'src', 'backend', 'session', 'store.ts')).href,
+  );
+  const runtimeSessionUrl = JSON.stringify(
+    pathToFileURL(path.join(getPackageRoot(), 'dist', 'runtime', 'session.js')).href,
+  );
+  const dbConnectionUrl = JSON.stringify(
+    pathToFileURL(path.join(workspace, 'src', 'backend', 'db', 'connection.ts')).href,
+  );
+
+  const sessionProbe = `
+    const [{ sessionStore }, { prepareSessionState }] = await Promise.all([
+      import(${sessionStoreUrl}),
+      import(${runtimeSessionUrl})
+    ]);
+
+    const config = {
+      secret: 'smoke-session-secret',
+      cookieName: 'webstir_session',
+      secure: false,
+      maxAgeSeconds: 60
+    };
+    const loginRoute = {
+      form: {
+        session: { write: true },
+        flash: {
+          publish: [{ key: 'signed-in', level: 'success', when: 'success' }]
+        }
+      }
+    };
+    const accountRoute = {
+      session: { mode: 'optional' },
+      flash: { consume: ['signed-in'] }
+    };
+    const created = prepareSessionState({
+      cookies: '',
+      route: loginRoute,
+      config,
+      store: sessionStore
+    });
+    const createdCommit = created.commit({
+      session: {
+        userId: 'ada@example.com'
+      },
+      route: loginRoute,
+      result: {
+        status: 303,
+        redirect: { location: '/session/account' }
+      }
+    });
+    const cookie = String(createdCommit.setCookie).split(';')[0];
+    const read = prepareSessionState({
+      cookies: cookie,
+      route: accountRoute,
+      config,
+      store: sessionStore
+    });
+    console.log(JSON.stringify({
+      userId: read.session?.userId ?? null,
+      flash: read.flash.map((message) => ({ key: message.key, level: message.level }))
+    }));
+  `;
+
+  const dbProbe = `
+    const { createDatabaseClient } = await import(${dbConnectionUrl});
+    const db = await createDatabaseClient();
+    await db.execute('CREATE TABLE IF NOT EXISTS smoke_items (id TEXT PRIMARY KEY, value TEXT NOT NULL)');
+    await db.execute('DELETE FROM smoke_items');
+    await db.execute('INSERT INTO smoke_items (id, value) VALUES (?, ?)', ['row-1', 'Ada']);
+    const rows = await db.query('SELECT value FROM smoke_items WHERE id = ?', ['row-1']);
+    const databases = await db.query('PRAGMA database_list');
+    const main = databases.find((row) => row.name === 'main');
+    console.log(JSON.stringify({ target: main?.file ?? null, value: rows[0]?.value ?? null }));
+    await db.close();
+  `;
+
+  const sessionResult = await runBunProbe(sessionProbe, {
+    cwd: alternateCwd,
+    env: {
+      WORKSPACE_ROOT: '   ',
+      WEBSTIR_WORKSPACE_ROOT: workspace,
+      SESSION_STORE_DRIVER: 'sqlite',
+      SESSION_STORE_URL: 'file:./data/smoke-session.sqlite',
+    },
+  });
+  console.info('[smoke] sqlite session probe:', sessionResult);
+  if (sessionResult.userId !== 'ada@example.com') {
+    throw new Error(
+      `[smoke] sqlite session probe returned unexpected userId ${sessionResult.userId}`,
+    );
+  }
+  if (!(await pathExists(path.join(workspace, 'data', 'smoke-session.sqlite')))) {
+    throw new Error(
+      '[smoke] sqlite session probe did not create the workspace-root session database',
+    );
+  }
+  if (await pathExists(path.join(alternateCwd, 'data', 'smoke-session.sqlite'))) {
+    throw new Error(
+      '[smoke] sqlite session probe wrote to the probe cwd instead of the workspace root',
+    );
+  }
+
+  const dbResult = await runBunProbe(dbProbe, {
+    cwd: alternateCwd,
+    env: {
+      WORKSPACE_ROOT: '   ',
+      WEBSTIR_WORKSPACE_ROOT: workspace,
+      DATABASE_URL: 'file:./data/smoke-db.sqlite',
+    },
+  });
+  console.info('[smoke] sqlite db probe:', dbResult);
+  if (dbResult.value !== 'Ada') {
+    throw new Error(`[smoke] sqlite db probe returned unexpected value ${dbResult.value}`);
+  }
+  if (!(await pathExists(path.join(workspace, 'data', 'smoke-db.sqlite')))) {
+    throw new Error('[smoke] sqlite db probe did not create the workspace-root database');
+  }
+  if (await pathExists(path.join(alternateCwd, 'data', 'smoke-db.sqlite'))) {
+    throw new Error('[smoke] sqlite db probe wrote to the probe cwd instead of the workspace root');
+  }
+}
+
 async function main() {
   const workspace = await fs.mkdtemp(path.join(os.tmpdir(), 'webstir-backend-smoke-'));
   const assets = await backendProvider.getScaffoldAssets();
@@ -41,7 +265,7 @@ async function main() {
     assets.map(async (asset) => {
       const target = path.join(workspace, asset.targetPath);
       await copyFile(asset.sourcePath, target);
-    })
+    }),
   );
 
   const backendTsconfigPath = path.join(workspace, 'src', 'backend', 'tsconfig.json');
@@ -51,7 +275,11 @@ async function main() {
     if (backendTsconfig?.compilerOptions) {
       delete backendTsconfig.compilerOptions.types;
     }
-    await fs.writeFile(backendTsconfigPath, `${JSON.stringify(backendTsconfig, null, 2)}\n`, 'utf8');
+    await fs.writeFile(
+      backendTsconfigPath,
+      `${JSON.stringify(backendTsconfig, null, 2)}\n`,
+      'utf8',
+    );
   } catch (error) {
     console.warn('[smoke] failed to adjust backend tsconfig:', error);
   }
@@ -70,24 +298,15 @@ async function main() {
         kind: 'backend',
         capabilities: [],
         routes: [],
-        views: []
-      }
-    }
+        views: [],
+      },
+    },
   };
   await fs.writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`, 'utf8');
 
-  await installPackages(workspace, ['pino', 'better-sqlite3']);
+  await installPackages(workspace, ['pino']);
 
-  if (process.env.WEBSTIR_BACKEND_SMOKE_FASTIFY !== 'skip') {
-    // Add optional Fastify dependency so the scaffold type-checks if present
-    try {
-      await installPackages(workspace, ['fastify', '@types/node@^20'], { dev: true });
-    } catch (err) {
-      console.warn('[smoke] skipping Fastify install:', err);
-    }
-  } else {
-    console.info('[smoke] fastify install skipped by WEBSTIR_BACKEND_SMOKE_FASTIFY=skip');
-  }
+  await linkWorkspaceNodeModules(workspace);
 
   const rootTsconfigPath = path.join(workspace, 'tsconfig.json');
   const rootTsconfig = {
@@ -99,8 +318,8 @@ async function main() {
       strict: true,
       isolatedModules: true,
       esModuleInterop: true,
-      skipLibCheck: true
-    }
+      skipLibCheck: true,
+    },
   };
   await fs.writeFile(rootTsconfigPath, `${JSON.stringify(rootTsconfig, null, 2)}\n`, 'utf8');
 
@@ -108,131 +327,87 @@ async function main() {
     PATH: `${getLocalBinPath()}${path.delimiter}${process.env.PATH ?? ''}`,
     WEBSTIR_BACKEND_TYPECHECK: 'skip',
     // Exercise provider diagnostic filtering: suppress info by default
-    WEBSTIR_BACKEND_LOG_LEVEL: 'warn'
+    WEBSTIR_BACKEND_LOG_LEVEL: 'warn',
   };
 
   console.info('[smoke] build mode');
   const buildResult = await backendProvider.build({
     workspaceRoot: workspace,
     env: { ...envBase, WEBSTIR_MODULE_MODE: 'build' },
-    incremental: false
+    incremental: false,
   });
   const buildEntries = buildResult.manifest.entryPoints;
   const buildFunctions = buildEntries.filter((p) => p.startsWith('functions/')).length;
   const buildJobs = buildEntries.filter((p) => p.startsWith('jobs/')).length;
-  const buildServer = buildEntries.filter((p) => p === 'index.js' || /(^|\/)index\.js$/.test(p) && !/^(functions|jobs)\//.test(p)).length;
+  const buildServer = buildEntries.filter(
+    (p) => p === 'index.js' || (/(^|\/)index\.js$/.test(p) && !/^(functions|jobs)\//.test(p)),
+  ).length;
   console.info('[smoke] build entryPoints:', buildEntries);
-  console.info('[smoke] build entry counts:', { server: buildServer, functions: buildFunctions, jobs: buildJobs });
+  console.info('[smoke] build entry counts:', {
+    server: buildServer,
+    functions: buildFunctions,
+    jobs: buildJobs,
+  });
   if (buildFunctions < 1 || buildJobs < 1) {
-    throw new Error(`[smoke] expected scaffold to include functions and jobs (got functions=${buildFunctions}, jobs=${buildJobs})`);
+    throw new Error(
+      `[smoke] expected scaffold to include functions and jobs (got functions=${buildFunctions}, jobs=${buildJobs})`,
+    );
   }
   const buildModule = buildResult.manifest.module ?? {};
   console.info('[smoke] build routes/views summary:', {
     routes: Array.isArray(buildModule.routes) ? buildModule.routes.length : 0,
-    views: Array.isArray(buildModule.views) ? buildModule.views.length : 0
+    views: Array.isArray(buildModule.views) ? buildModule.views.length : 0,
   });
-  console.info('[smoke] build diagnostics (>=warn):', buildResult.manifest.diagnostics.map((d) => d.message));
+  console.info(
+    '[smoke] build diagnostics (>=warn):',
+    buildResult.manifest.diagnostics.map((d) => d.message),
+  );
+  console.info('[smoke] sqlite template probes');
+  await runTemplateSqliteProbes(workspace);
 
   console.info('[smoke] publish mode');
   const publishResult = await backendProvider.build({
     workspaceRoot: workspace,
     // Intentionally clear PATH so `tsc` is not found; provider will warn and continue
     env: { ...envBase, WEBSTIR_MODULE_MODE: 'publish', PATH: '' },
-    incremental: false
+    incremental: false,
   });
   const publishEntries = publishResult.manifest.entryPoints;
   const publishFunctions = publishEntries.filter((p) => p.startsWith('functions/')).length;
   const publishJobs = publishEntries.filter((p) => p.startsWith('jobs/')).length;
-  const publishServer = publishEntries.filter((p) => p === 'index.js' || /(^|\/)index\.js$/.test(p) && !/^(functions|jobs)\//.test(p)).length;
+  const publishServer = publishEntries.filter(
+    (p) => p === 'index.js' || (/(^|\/)index\.js$/.test(p) && !/^(functions|jobs)\//.test(p)),
+  ).length;
   console.info('[smoke] publish entryPoints:', publishEntries);
-  console.info('[smoke] publish entry counts:', { server: publishServer, functions: publishFunctions, jobs: publishJobs });
+  console.info('[smoke] publish entry counts:', {
+    server: publishServer,
+    functions: publishFunctions,
+    jobs: publishJobs,
+  });
   if (publishFunctions < 1 || publishJobs < 1) {
-    throw new Error(`[smoke] expected scaffold to include functions and jobs after publish (got functions=${publishFunctions}, jobs=${publishJobs})`);
+    throw new Error(
+      `[smoke] expected scaffold to include functions and jobs after publish (got functions=${publishFunctions}, jobs=${publishJobs})`,
+    );
   }
   const publishModule = publishResult.manifest.module ?? {};
   console.info('[smoke] publish routes/views summary:', {
     routes: Array.isArray(publishModule.routes) ? publishModule.routes.length : 0,
-    views: Array.isArray(publishModule.views) ? publishModule.views.length : 0
+    views: Array.isArray(publishModule.views) ? publishModule.views.length : 0,
   });
   const publishDiagnostics = publishResult.manifest.diagnostics
     .map((d) => ({ ...d, message: d.message.trim() }))
     .filter((d) => d.severity !== 'info');
-  const unexpectedPublishDiagnostics = publishDiagnostics.filter((d) => !/TypeScript compiler \(tsc\) not found|Type checking failed/.test(d.message));
+  const unexpectedPublishDiagnostics = publishDiagnostics.filter(
+    (d) => !/TypeScript compiler \(tsc\) not found|Type checking failed/.test(d.message),
+  );
   if (unexpectedPublishDiagnostics.length > 0) {
-    console.info('[smoke] publish diagnostics (non-info):', unexpectedPublishDiagnostics.map((d) => d.message));
-  }
-
-  if (process.env.WEBSTIR_BACKEND_SMOKE_FASTIFY !== 'skip') {
-    // Fastify scaffold type-check (no run): ensure tsc sees server/fastify.ts
-    console.info('[smoke] fastify type-check');
-    const typecheckResult = await backendProvider.build({
-      workspaceRoot: workspace,
-      env: { PATH: envBase.PATH, WEBSTIR_BACKEND_LOG_LEVEL: 'warn', WEBSTIR_MODULE_MODE: 'build', WEBSTIR_BACKEND_TYPECHECK: 'skip' },
-      incremental: false
-    });
-    const typecheckErrors = typecheckResult.manifest.diagnostics.filter((d) => d.severity === 'error');
-    if (typecheckErrors.length > 0) {
-      throw new Error(`[smoke] fastify type-check reported errors: ${typecheckErrors.map((d) => d.message).join('; ')}`);
-    }
-
-    // Optionally run server and hit /api/health
-    if (process.env.WEBSTIR_BACKEND_SMOKE_FASTIFY_RUN !== 'skip') {
-      console.info('[smoke] fastify run + health check');
-      const port = 47891;
-      const child = spawn(process.execPath, ['build/backend/server/fastify.js'], {
-        cwd: workspace,
-        stdio: ['ignore', 'pipe', 'pipe'],
-        env: { ...process.env, PORT: String(port) }
-      });
-
-      let ready = false;
-      const outChunks = [];
-      child.stdout.on('data', (c) => {
-        const s = c.toString();
-        outChunks.push(s);
-        if (!ready && s.includes('API server running')) {
-          ready = true;
-          (async () => {
-            try {
-              const res = await fetch(`http://127.0.0.1:${port}/api/health`);
-              if (!res.ok) throw new Error(`health returned ${res.status}`);
-              const json = await res.json();
-              if (!json || json.ok !== true) throw new Error('health payload invalid');
-            } catch (err) {
-              console.error('[smoke] fastify health check failed:', err);
-              child.kill();
-              throw err;
-            } finally {
-              child.kill();
-            }
-          })().catch((err) => {
-            console.error(err);
-            process.exitCode = 1;
-          });
-        }
-      });
-
-      await new Promise((resolve) => {
-        const timer = setTimeout(() => {
-          if (!ready) {
-            console.error('[smoke] fastify did not reach readiness');
-            child.kill();
-          }
-          resolve(null);
-        }, 8000);
-        child.on('close', () => {
-          clearTimeout(timer);
-          resolve(null);
-        });
-      });
-    } else {
-      console.info('[smoke] fastify run skipped by WEBSTIR_BACKEND_SMOKE_FASTIFY_RUN=skip');
-    }
-  } else {
-    console.info('[smoke] fastify type-check skipped by WEBSTIR_BACKEND_SMOKE_FASTIFY=skip');
+    console.info(
+      '[smoke] publish diagnostics (non-info):',
+      unexpectedPublishDiagnostics.map((d) => d.message),
+    );
   }
 
-  console.info('[smoke] completed: build ✔ publish ✔ fastify ✔');
+  console.info('[smoke] completed: build ✔ publish ✔');
 }
 
 main().catch((err) => {

package/scripts/update-contract.sh

@@ -22,6 +22,8 @@ EOF
 
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 ROOT_DIR="$(cd "${SCRIPT_DIR}/.." && pwd)"
+MONOREPO_ROOT="$(git -C "$ROOT_DIR" rev-parse --show-toplevel)"
+PACKAGE_NAME="$(node -p "require('./package.json').name" 2>/dev/null)"
 
 has_script() {
   local script_name="$1"
@@ -85,33 +87,33 @@ main() {
   echo "› Setting @webstir-io/module-contract to $spec"
   npm pkg set "dependencies.@webstir-io/module-contract=$spec"
 
-  echo "› npm install (refresh lockfile)"
+  echo "› bun install (refresh workspace lockfile)"
   if [[ "$fast" == "true" ]]; then
-    npm install --package-lock-only --no-audit --no-fund --ignore-scripts
+    bun install --cwd "$MONOREPO_ROOT" --filter "$PACKAGE_NAME" --lockfile-only
   else
-    npm install --no-audit --no-fund
+    bun install --cwd "$MONOREPO_ROOT" --filter "$PACKAGE_NAME"
   fi
 
   # Clarify versions in logs to avoid confusion with backend package version
   local backend_ver
   backend_ver="$(node -p "require('./package.json').version" 2>/dev/null || echo 'unknown')"
   local installed_contract
-  installed_contract="$(npm ls @webstir-io/module-contract --json 2>/dev/null | node -e "let d='';process.stdin.on('data',c=>d+=c).on('end',()=>{try{const j=JSON.parse(d);const v=(j.dependencies&&j.dependencies['@webstir-io/module-contract']&&j.dependencies['@webstir-io/module-contract'].version)||'';console.log(v||'unknown')}catch{console.log('unknown')}})")"
+  installed_contract="$(node -p "try { require('@webstir-io/module-contract/package.json').version } catch { 'unknown' }" 2>/dev/null || echo 'unknown')"
   echo "› Backend package: @webstir-io/webstir-backend@${backend_ver}"
   echo "› Contract installed: @webstir-io/module-contract@${installed_contract}"
 
   if [[ "$fast" != "true" ]]; then
-    echo "› npm run build"
-    npm run build
+    echo "› bun run build"
+    bun run build
 
     if has_script test; then
-      echo "› npm test"
-      npm test
+      echo "› bun run test"
+      bun run test
     fi
 
     if has_script smoke; then
-      echo "› npm run smoke"
-      npm run smoke
+      echo "› bun run smoke"
+      bun run smoke
     fi
   fi