@vibecodetown/mcp-server 1.3.1 → 1.5.0

package/scripts/bundle-native.mjs

@@ -0,0 +1,393 @@
+#!/usr/bin/env node
+/**
+ * bundle-native.mjs — Bundle Vibe PM into standalone CJS files for native distribution.
+ *
+ * Uses esbuild to tree-shake and inline all dependencies into single .cjs files.
+ * Output goes to dist/ directory, ready for platform packaging.
+ *
+ * Usage:
+ *   node scripts/bundle-native.mjs              # bundle all entry points
+ *   node scripts/bundle-native.mjs --skip-tsc   # skip tsc (assume build/ is current)
+ */
+
+import * as esbuild from 'esbuild';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { execSync } from 'node:child_process';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const ROOT = path.resolve(__dirname, '..');
+
+const DIST = path.join(ROOT, 'dist');
+const DIST_BIN = path.join(DIST, 'bin');
+const DIST_DATA = path.join(DIST, 'data');
+
+// Entry points to bundle
+const ENTRY_POINTS = [
+  // ESM entries (use top-level await → must be .mjs)
+  { input: 'build/mcp/index.js', output: 'vibe-pm-server.mjs', name: 'MCP Server', esm: true },
+  { input: 'build/bin/vibe-companion.js', output: 'vibe-companion.mjs', name: 'Companion', esm: true },
+  // CJS entries (no top-level await)
+  { input: 'build/bin/vibe-ci.js', output: 'vibe-ci.cjs', name: 'CLI', esm: false },
+  { input: 'build/bin/vibe-auth.js', output: 'vibe-auth.cjs', name: 'Auth', esm: false },
+  { input: 'build/bin/vibe-dashboard.js', output: 'vibe-dashboard.cjs', name: 'Dashboard', esm: false },
+  { input: 'build/bin/vibe-bitnet-worker.js', output: 'vibe-bitnet-worker.cjs', name: 'BitNet Worker', esm: false },
+  { input: 'build/bin/vibe-mapper-worker.js', output: 'vibe-mapper-worker.cjs', name: 'Mapper Worker', esm: false },
+];
+
+// Modules that cannot be bundled (native addons, optional deps)
+const EXTERNAL = [
+  // Native addons — platform-specific .node files
+  'pg-native',
+  '@mongodb-js/zstd',
+  // Native N-API modules (platform-specific)
+  '@vibecodetown/musu-linux-x64-gnu',
+  '@vibecodetown/musu-darwin-arm64',
+  '@vibecodetown/musu-darwin-x64',
+  '@vibecodetown/musu-win32-x64-msvc',
+  '@rollup/rollup-linux-x64-gnu',
+  '@rollup/rollup-win32-x64-msvc',
+  // Optional heavy deps
+  'puppeteer',
+  'puppeteer-core',
+  'node-notifier',
+  // Node built-ins are handled automatically by platform=node
+];
+
+// Data directories to copy alongside the bundle
+const DATA_DIRS = ['schemas', 'skills', 'templates'];
+
+// ─────────────────────────────────────────────────────────
+
+function log(msg) {
+  console.log(`[bundle-native] ${msg}`);
+}
+
+function cleanDist() {
+  if (fs.existsSync(DIST)) {
+    fs.rmSync(DIST, { recursive: true });
+  }
+  fs.mkdirSync(DIST_BIN, { recursive: true });
+  fs.mkdirSync(DIST_DATA, { recursive: true });
+}
+
+function runTsc() {
+  log('Running tsc...');
+  execSync('node ./node_modules/typescript/bin/tsc', {
+    cwd: ROOT,
+    stdio: 'inherit',
+  });
+  log('tsc complete.');
+}
+
+/**
+ * esbuild plugin to handle import.meta.url patterns in CJS output.
+ *
+ * ESM source files declare:
+ *   const __filename = fileURLToPath(import.meta.url);
+ *   const __dirname = path.dirname(__filename);
+ *
+ * In CJS, __filename and __dirname are already provided by Node.
+ * We remove these declarations to avoid esbuild's variable renaming
+ * creating self-referencing assignments like `var __filename2 = __filename2`.
+ */
+function importMetaPlugin() {
+  return {
+    name: 'import-meta-url',
+    setup(build) {
+      build.onLoad({ filter: /\.js$/ }, async (args) => {
+        let contents = await fs.promises.readFile(args.path, 'utf-8');
+
+        if (!contents.includes('import.meta.url')) {
+          return undefined;
+        }
+
+        let modified = false;
+
+        // Remove: const __filename = fileURLToPath(import.meta.url);
+        const fnPattern = /const __filename\s*=\s*fileURLToPath\(import\.meta\.url\);?\n?/g;
+        if (fnPattern.test(contents)) {
+          contents = contents.replace(fnPattern, '');
+          modified = true;
+        }
+
+        // Remove: const __dirname = path.dirname(__filename);
+        // (and variants like: const __dirname = dirname(__filename);)
+        const dnPattern = /const __dirname\s*=\s*(?:path\.)?dirname\(__filename\);?\n?/g;
+        if (dnPattern.test(contents)) {
+          contents = contents.replace(dnPattern, '');
+          modified = true;
+        }
+
+        // Remove: import { fileURLToPath } from 'node:url';
+        // (only if it was the sole import from node:url)
+        const urlImport = /import\s*\{\s*fileURLToPath\s*\}\s*from\s*['"]node:url['"];?\n?/g;
+        if (urlImport.test(contents)) {
+          contents = contents.replace(urlImport, '');
+          modified = true;
+        }
+
+        // Handle: createRequire(import.meta.url) → require (use CJS native)
+        const crPattern = /(?:const|let|var)\s+\w+\s*=\s*(?:\(\d+,\s*\w+\.)?createRequire\)?\(import\.meta\.url\);?/g;
+        if (crPattern.test(contents)) {
+          // In CJS, require is already available — remove the createRequire call
+          contents = contents.replace(crPattern, '');
+          modified = true;
+        }
+
+        // Replace any remaining import.meta.url with CJS equivalent
+        if (contents.includes('import.meta.url')) {
+          contents = contents.replace(
+            /import\.meta\.url/g,
+            `require("url").pathToFileURL(__filename).href`
+          );
+          modified = true;
+        }
+
+        return modified ? { contents, loader: 'js' } : undefined;
+      });
+    },
+  };
+}
+
+async function bundleEntryPoint(entry) {
+  const inputPath = path.join(ROOT, entry.input);
+  const outputPath = path.join(DIST_BIN, entry.output);
+
+  if (!fs.existsSync(inputPath)) {
+    log(`SKIP ${entry.name}: ${entry.input} not found`);
+    return false;
+  }
+
+  log(`Bundling ${entry.name}: ${entry.input} → ${entry.output}`);
+
+  const isEsm = entry.esm;
+  const format = isEsm ? 'esm' : 'cjs';
+
+  try {
+    const buildOptions = {
+      entryPoints: [inputPath],
+      outfile: outputPath,
+      bundle: true,
+      platform: 'node',
+      target: 'node18',
+      format,
+      external: EXTERNAL,
+      minify: false, // keep readable for debugging
+      sourcemap: false,
+      metafile: true,
+      define: {
+        'process.env.VIBE_BUNDLED': '"true"',
+      },
+      logLevel: 'warning',
+    };
+
+    if (isEsm) {
+      // ESM: inject require shim for CJS deps that use require('process') etc.
+      buildOptions.banner = {
+        js: [
+          `import { createRequire as __bundleCreateRequire } from 'node:module';`,
+          `import { fileURLToPath as __bundleFileURLToPath } from 'node:url';`,
+          `import { dirname as __bundleDirname } from 'node:path';`,
+          `const require = __bundleCreateRequire(import.meta.url);`,
+          `const __filename = __bundleFileURLToPath(import.meta.url);`,
+          `const __dirname = __bundleDirname(__filename);`,
+        ].join('\n'),
+      };
+    } else {
+      // CJS: needs import.meta.url plugin
+      // No shebang — launcher script handles invocation
+      buildOptions.plugins = [importMetaPlugin()];
+    }
+
+    const result = await esbuild.build(buildOptions);
+
+    // Report bundle size
+    const stat = fs.statSync(outputPath);
+    const sizeKB = (stat.size / 1024).toFixed(0);
+    const inputs = Object.keys(result.metafile.inputs).length;
+    log(`  → ${sizeKB} KB (${inputs} modules bundled)`);
+
+    return true;
+  } catch (err) {
+    log(`ERROR bundling ${entry.name}: ${err.message}`);
+
+    // If bundle fails, try with more externals
+    // Some modules may have issues — mark them external and retry
+    if (err.errors) {
+      const problematic = err.errors
+        .filter(e => e.text?.includes('Could not resolve'))
+        .map(e => {
+          const match = e.text.match(/"([^"]+)"/);
+          return match ? match[1] : null;
+        })
+        .filter(Boolean);
+
+      if (problematic.length > 0) {
+        log(`  Retrying with additional externals: ${problematic.join(', ')}`);
+        return bundleWithExternals(entry, inputPath, outputPath, problematic);
+      }
+    }
+    return false;
+  }
+}
+
+async function bundleWithExternals(entry, inputPath, outputPath, additionalExternals) {
+  const isEsm = entry.esm;
+  const format = isEsm ? 'esm' : 'cjs';
+
+  try {
+    const buildOptions = {
+      entryPoints: [inputPath],
+      outfile: outputPath,
+      bundle: true,
+      platform: 'node',
+      target: 'node18',
+      format,
+      external: [...EXTERNAL, ...additionalExternals],
+      minify: false,
+      sourcemap: false,
+      metafile: true,
+      define: {
+        'process.env.VIBE_BUNDLED': '"true"',
+      },
+      logLevel: 'warning',
+    };
+
+    if (!isEsm) {
+      buildOptions.plugins = [importMetaPlugin()];
+    }
+
+    const result = await esbuild.build(buildOptions);
+
+    const stat = fs.statSync(outputPath);
+    const sizeKB = (stat.size / 1024).toFixed(0);
+    log(`  → ${sizeKB} KB (with ${additionalExternals.length} extra externals)`);
+    return true;
+  } catch (err) {
+    log(`  FAILED even with extra externals: ${err.message}`);
+    return false;
+  }
+}
+
+function copyDataDirs() {
+  for (const dir of DATA_DIRS) {
+    const src = path.join(ROOT, dir);
+    const dst = path.join(DIST_DATA, dir);
+
+    if (!fs.existsSync(src)) {
+      log(`SKIP data dir: ${dir} (not found)`);
+      continue;
+    }
+
+    log(`Copying ${dir}/ → dist/data/${dir}/`);
+    fs.cpSync(src, dst, { recursive: true });
+  }
+}
+
+function copyPackageJson() {
+  // Ship a minimal package.json for version detection
+  // getPackageRoot() walks up from __dirname to find package.json
+  const pkg = JSON.parse(fs.readFileSync(path.join(ROOT, 'package.json'), 'utf-8'));
+  const minimal = {
+    name: pkg.name,
+    version: pkg.version,
+    description: pkg.description,
+    type: 'commonjs', // CJS bundle
+  };
+
+  // Place it at dist/ level (parent of dist/bin/) so getPackageRoot() finds it
+  fs.writeFileSync(
+    path.join(DIST, 'package.json'),
+    JSON.stringify(minimal, null, 2)
+  );
+  log(`Created dist/package.json (v${pkg.version})`);
+}
+
+function printSummary(results) {
+  console.log('\n─── Bundle Summary ───');
+  let totalSize = 0;
+  for (const [name, success] of results) {
+    const status = success ? '✅' : '❌';
+    console.log(`  ${status} ${name}`);
+  }
+
+  // Total dist size
+  const distFiles = getAllFiles(DIST);
+  for (const f of distFiles) {
+    totalSize += fs.statSync(f).size;
+  }
+  console.log(`\n  Total dist/ size: ${(totalSize / 1024 / 1024).toFixed(1)} MB`);
+  console.log(`  Files: ${distFiles.length}`);
+  console.log('──────────────────────\n');
+}
+
+function getAllFiles(dir) {
+  const files = [];
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...getAllFiles(full));
+    } else {
+      files.push(full);
+    }
+  }
+  return files;
+}
+
+// ─────────────────────────────────────────────────────────
+
+async function main() {
+  const args = process.argv.slice(2);
+  const skipTsc = args.includes('--skip-tsc');
+
+  log('Starting native bundle...');
+  log(`Root: ${ROOT}`);
+  log(`Output: ${DIST}`);
+
+  // Step 1: Clean
+  cleanDist();
+
+  // Step 2: TypeScript compilation (unless --skip-tsc)
+  if (!skipTsc) {
+    runTsc();
+  } else {
+    log('Skipping tsc (--skip-tsc)');
+    if (!fs.existsSync(path.join(ROOT, 'build'))) {
+      console.error('ERROR: build/ directory not found. Run tsc first or remove --skip-tsc.');
+      process.exit(1);
+    }
+  }
+
+  // Step 3: Bundle each entry point
+  const results = [];
+  for (const entry of ENTRY_POINTS) {
+    const ok = await bundleEntryPoint(entry);
+    results.push([entry.name, ok]);
+  }
+
+  // Step 4: Copy data directories
+  copyDataDirs();
+
+  // Step 5: Create minimal package.json
+  copyPackageJson();
+
+  // Step 6: Summary
+  printSummary(results);
+
+  // Exit with error if any bundle failed
+  const failed = results.filter(([, ok]) => !ok);
+  if (failed.length > 0) {
+    console.error(`${failed.length} bundle(s) failed.`);
+    process.exit(1);
+  }
+
+  log('Done! dist/ is ready for packaging.');
+}
+
+main().catch((err) => {
+  console.error('Fatal error:', err);
+  process.exit(1);
+});

package/scripts/check-hotpath-di.mjs

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+const TARGET_DIRS = ['src/domains', 'src/mcp', 'src/tier'];
+const FORBIDDEN_PATTERNS = [/new\s+BlockStore\s*\(/, /new\s+ChainManager\s*\(/];
+
+function parseRootArg() {
+  const rootIndex = process.argv.indexOf('--root');
+  if (rootIndex >= 0 && process.argv[rootIndex + 1]) {
+    return path.resolve(process.argv[rootIndex + 1]);
+  }
+  return process.cwd();
+}
+
+async function walkTsFiles(dir, out) {
+  let entries = [];
+  try {
+    entries = await fs.readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+
+  for (const entry of entries) {
+    const absPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      await walkTsFiles(absPath, out);
+      continue;
+    }
+    if (!entry.isFile() || !entry.name.endsWith('.ts') || entry.name.endsWith('.test.ts')) {
+      continue;
+    }
+    out.push(absPath);
+  }
+}
+
+async function main() {
+  const root = parseRootArg();
+  const violations = [];
+  const files = [];
+
+  for (const relDir of TARGET_DIRS) {
+    await walkTsFiles(path.join(root, relDir), files);
+  }
+
+  for (const absPath of files) {
+    const relPath = path.relative(root, absPath).replace(/\\/g, '/');
+    const content = await fs.readFile(absPath, 'utf-8');
+    const lines = content.split(/\r?\n/);
+
+    for (let index = 0; index < lines.length; index++) {
+      const line = lines[index];
+      if (FORBIDDEN_PATTERNS.some(regex => regex.test(line))) {
+        violations.push({
+          file: relPath,
+          line: index + 1,
+          text: line.trim(),
+        });
+      }
+    }
+  }
+
+  if (violations.length > 0) {
+    console.error('[hotpath-di] Found direct BlockStore/ChainManager instantiation outside kernel:');
+    for (const issue of violations) {
+      console.error(`- ${issue.file}:${issue.line} ${issue.text}`);
+    }
+    process.exit(1);
+  }
+
+  console.log(`[hotpath-di] PASS (${files.length} files checked)`);
+}
+
+main().catch(err => {
+  console.error('[hotpath-di] ERROR', err);
+  process.exit(1);
+});

package/scripts/check-hotpath-sync-io.mjs

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+const HOTPATH_FILES = [
+  'src/domains/bee/bee_orchestrator.ts',
+  'src/domains/bee/scout_runner.ts',
+  'src/domains/bee/bee_watcher.ts',
+  'src/domains/bee/bee_rechunk.ts',
+  'src/domains/bee/bee_rechunk_incremental.ts',
+  'src/domains/swarm/swarm_dispatcher.ts',
+  'src/domains/swarm/swarm_chain_dispatcher.ts',
+  'src/tier/production_bridge.ts',
+  'src/mcp/tools/bitnet/context.ts',
+  'src/mcp/tools/vibe_pm/workspace_recipe.ts',
+  'src/db_sync/scanner.ts',
+  'src/workers/base/health.ts',
+];
+
+const SYNC_CALL_REGEX =
+  /\b(?:existsSync|readFileSync|writeFileSync|appendFileSync|mkdirSync|rmSync|readdirSync|statSync|unlinkSync|renameSync|openSync|readSync|closeSync)\s*\(/;
+
+const ALLOWED_SYNC_CALLS = {
+  'src/mcp/tools/bitnet/context.ts': [
+    /fs\.existsSync\s*\(\s*getBlockIndexPath\s*\(\s*basePath\s*\)\s*\)/,
+  ],
+  'src/domains/bee/bee_rechunk.ts': [/fs\.readFileSync\s*\(\s*path\.resolve\s*\(\s*basePath\s*,\s*filePath\s*\)/],
+  'src/domains/bee/bee_rechunk_incremental.ts': [
+    /fs\.readFileSync\s*\(\s*path\.resolve\s*\(\s*basePath\s*,\s*filePath\s*\)/,
+  ],
+};
+
+function parseRootArg() {
+  const rootIndex = process.argv.indexOf('--root');
+  if (rootIndex >= 0 && process.argv[rootIndex + 1]) {
+    return path.resolve(process.argv[rootIndex + 1]);
+  }
+  return process.cwd();
+}
+
+async function main() {
+  const root = parseRootArg();
+  const violations = [];
+
+  for (const relPath of HOTPATH_FILES) {
+    const absPath = path.join(root, relPath);
+    let content;
+    try {
+      content = await fs.readFile(absPath, 'utf-8');
+    } catch (err) {
+      violations.push({
+        file: relPath,
+        line: 0,
+        text: `MISSING_FILE (${err instanceof Error ? err.message : String(err)})`,
+      });
+      continue;
+    }
+
+    const lines = content.split(/\r?\n/);
+    for (let index = 0; index < lines.length; index++) {
+      const line = lines[index];
+      if (SYNC_CALL_REGEX.test(line)) {
+        const allowlist = ALLOWED_SYNC_CALLS[relPath] ?? [];
+        if (allowlist.some(regex => regex.test(line))) {
+          continue;
+        }
+        violations.push({
+          file: relPath,
+          line: index + 1,
+          text: line.trim(),
+        });
+      }
+    }
+  }
+
+  if (violations.length > 0) {
+    console.error('[hotpath-sync-io] Found sync I/O usage in guarded hot paths:');
+    for (const issue of violations) {
+      console.error(`- ${issue.file}:${issue.line} ${issue.text}`);
+    }
+    process.exit(1);
+  }
+
+  console.log(`[hotpath-sync-io] PASS (${HOTPATH_FILES.length} files checked)`);
+}
+
+main().catch(err => {
+  console.error('[hotpath-sync-io] ERROR', err);
+  process.exit(1);
+});