@aliwey/bmo 2.0.0

package/scripts/postinstall.js

@@ -0,0 +1,265 @@
+#!/usr/bin/env node
+/**
+ * BMO postinstall — self-contained setup
+ * Runs automatically after: npm install -g @aliwey/bmo
+ *
+ * Steps:
+ *   1. Download & extract embedded Python 3.13 (minimal, to ~/.bmo/python/)
+ *   2. pip install -r requirements.txt into embedded Python
+ *   3. Ensure opencode-ai is installed
+ *   4. Download cloudflared binary to ~/.bmo/bin/
+ *   5. npm install webchat dependencies
+ */
+
+'use strict';
+
+const { execSync, spawnSync } = require('child_process');
+const https = require('https');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { createWriteStream } = require('fs');
+
+const BMO_HOME = process.env.BMO_HOME || path.join(os.homedir(), '.bmo');
+const BMO_BIN  = path.join(BMO_HOME, 'bin');
+const BMO_PY   = path.join(BMO_HOME, 'python');
+const PKG_DIR  = path.join(__dirname, '..');
+
+// ── Python version ───────────────────────────────────────────────────────────
+const PY_VERSION = '3.13.3';
+const PY_URLS = {
+  win32: {
+    x64:  `https://www.python.org/ftp/python/${PY_VERSION}/python-${PY_VERSION}-embed-amd64.zip`,
+    arm64:`https://www.python.org/ftp/python/${PY_VERSION}/python-${PY_VERSION}-embed-arm64.zip`,
+  },
+  darwin: {
+    any: `https://github.com/indygreg/python-build-standalone/releases/download/20250311/cpython-${PY_VERSION}+20250311-aarch64-apple-darwin-install_only_stripped.tar.gz`,
+    x64: `https://github.com/indygreg/python-build-standalone/releases/download/20250311/cpython-${PY_VERSION}+20250311-x86_64-apple-darwin-install_only_stripped.tar.gz`,
+  },
+  linux: {
+    x64:  `https://github.com/indygreg/python-build-standalone/releases/download/20250311/cpython-${PY_VERSION}+20250311-x86_64-unknown-linux-gnu-install_only_stripped.tar.gz`,
+    arm64:`https://github.com/indygreg/python-build-standalone/releases/download/20250311/cpython-${PY_VERSION}+20250311-aarch64-unknown-linux-gnu-install_only_stripped.tar.gz`,
+  }
+};
+
+// ── Cloudflared version ──────────────────────────────────────────────────────
+const CF_VERSION = '2025.4.2';
+const CF_URLS = {
+  win32:  `https://github.com/cloudflare/cloudflared/releases/download/${CF_VERSION}/cloudflared-windows-amd64.exe`,
+  darwin: `https://github.com/cloudflare/cloudflared/releases/download/${CF_VERSION}/cloudflared-darwin-amd64`,
+  linux:  `https://github.com/cloudflare/cloudflared/releases/download/${CF_VERSION}/cloudflared-linux-amd64`,
+};
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+const step = (n, msg) => console.log(`\n[${n}/5] ${msg}`);
+const ok   = msg => console.log(`  ✅ ${msg}`);
+const warn = msg => console.log(`  ⚠️  ${msg}`);
+const err  = msg => console.error(`  ❌ ${msg}`);
+
+function mkdirp(p) { fs.mkdirSync(p, { recursive: true }); }
+
+function download(url, dest) {
+  return new Promise((resolve, reject) => {
+    const file = createWriteStream(dest);
+    const get = (u) => https.get(u, res => {
+      if (res.statusCode === 301 || res.statusCode === 302) return get(res.headers.location);
+      if (res.statusCode !== 200) return reject(new Error(`HTTP ${res.statusCode} from ${u}`));
+      res.pipe(file);
+      file.on('finish', () => file.close(resolve));
+    }).on('error', reject);
+    get(url);
+  });
+}
+
+function run(cmd, opts = {}) {
+  const r = spawnSync(cmd, { shell: true, stdio: 'inherit', ...opts });
+  if (r.status !== 0) throw new Error(`Command failed: ${cmd}`);
+}
+
+function hasPython() {
+  for (const py of ['python3', 'python']) {
+    try {
+      const r = spawnSync(py, ['--version'], { encoding: 'utf8', stdio: 'pipe' });
+      if (r.status === 0) {
+        const ver = (r.stdout || r.stderr || '').match(/(\d+)\.(\d+)/);
+        if (ver && (parseInt(ver[1]) > 3 || (parseInt(ver[1]) === 3 && parseInt(ver[2]) >= 11))) {
+          return py;
+        }
+      }
+    } catch {}
+  }
+  return null;
+}
+
+// ── Step 1: Python ───────────────────────────────────────────────────────────
+
+async function installPython() {
+  step(1, `Setting up Python ${PY_VERSION} (embedded, minimal)...`);
+
+  // Check if already installed in BMO_HOME
+  const embeddedExe = process.platform === 'win32'
+    ? path.join(BMO_PY, 'python.exe')
+    : path.join(BMO_PY, 'bin', 'python3');
+
+  if (fs.existsSync(embeddedExe)) {
+    ok(`Embedded Python already at ${BMO_PY}`);
+    return embeddedExe;
+  }
+
+  // Check system Python (3.11+)
+  const sysPy = hasPython();
+  if (sysPy) {
+    ok(`Using system Python: ${sysPy}`);
+    return sysPy;
+  }
+
+  // Download embedded Python
+  mkdirp(BMO_PY);
+  const plat = process.platform;
+  const arch = process.arch;
+  let url;
+
+  if (plat === 'win32') {
+    url = arch === 'arm64' ? PY_URLS.win32.arm64 : PY_URLS.win32.x64;
+  } else if (plat === 'darwin') {
+    url = arch === 'arm64' ? PY_URLS.darwin.any : PY_URLS.darwin.x64;
+  } else {
+    url = arch === 'arm64' ? PY_URLS.linux.arm64 : PY_URLS.linux.x64;
+  }
+
+  console.log(`  Downloading Python from: ${url}`);
+  const archiveName = url.split('/').pop();
+  const archivePath = path.join(BMO_HOME, archiveName);
+  await download(url, archivePath);
+
+  // Extract
+  if (archiveName.endsWith('.zip')) {
+    run(`powershell -Command "Expand-Archive -Path '${archivePath}' -DestinationPath '${BMO_PY}' -Force"`);
+  } else {
+    run(`tar -xzf "${archivePath}" -C "${BMO_PY}" --strip-components=1`);
+  }
+  fs.unlinkSync(archivePath);
+
+  ok(`Python ${PY_VERSION} installed at ${BMO_PY}`);
+  return embeddedExe;
+}
+
+// ── Step 2: pip install ───────────────────────────────────────────────────────
+
+function installPipDeps(pythonExe) {
+  step(2, 'Installing Python dependencies (pip)...');
+  const reqFile = path.join(PKG_DIR, 'requirements.txt');
+  try {
+    // Ensure pip is available
+    run(`"${pythonExe}" -m ensurepip --upgrade`);
+    run(`"${pythonExe}" -m pip install --upgrade pip --quiet`);
+    run(`"${pythonExe}" -m pip install -r "${reqFile}" --quiet`);
+    ok('Python dependencies installed');
+  } catch (e) {
+    warn(`pip install failed: ${e.message}`);
+    warn('You may need to run: pip install -r requirements.txt manually');
+  }
+}
+
+// ── Step 3: opencode-ai ──────────────────────────────────────────────────────
+
+function ensureOpenCode() {
+  step(3, 'Checking opencode-ai...');
+  try {
+    execSync('opencode --version', { stdio: 'ignore' });
+    ok('opencode-ai already installed');
+  } catch {
+    console.log('  Installing opencode-ai...');
+    try {
+      run('npm install -g opencode-ai');
+      ok('opencode-ai installed');
+    } catch {
+      warn('Could not install opencode-ai automatically.');
+      warn('Run manually: npm install -g opencode-ai');
+    }
+  }
+}
+
+// ── Step 4: cloudflared ──────────────────────────────────────────────────────
+
+async function installCloudflared() {
+  step(4, 'Setting up cloudflared...');
+  mkdirp(BMO_BIN);
+
+  const plat = process.platform;
+  const cfExe = plat === 'win32'
+    ? path.join(BMO_BIN, 'cloudflared.exe')
+    : path.join(BMO_BIN, 'cloudflared');
+
+  if (fs.existsSync(cfExe)) {
+    ok('cloudflared already at ' + cfExe);
+    return;
+  }
+
+  // Check system cloudflared
+  try {
+    execSync('cloudflared --version', { stdio: 'ignore' });
+    ok('Using system cloudflared');
+    return;
+  } catch {}
+
+  const url = CF_URLS[plat] || CF_URLS.linux;
+  console.log(`  Downloading cloudflared from: ${url}`);
+  try {
+    await download(url, cfExe);
+    if (plat !== 'win32') fs.chmodSync(cfExe, 0o755);
+    ok('cloudflared installed at ' + cfExe);
+  } catch (e) {
+    warn(`cloudflared download failed: ${e.message}`);
+    warn('Install manually: https://developers.cloudflare.com/cloudflared/downloads/');
+  }
+}
+
+// ── Step 5: webchat node_modules ─────────────────────────────────────────────
+
+function installWebchatDeps() {
+  step(5, 'Installing webchat dependencies...');
+  const webchatDir = path.join(PKG_DIR, 'webchat');
+  if (!fs.existsSync(path.join(webchatDir, 'package.json'))) {
+    warn('webchat/package.json not found, skipping');
+    return;
+  }
+  try {
+    run(`npm install --prefix "${webchatDir}" --quiet`);
+    ok('webchat dependencies installed');
+  } catch (e) {
+    warn(`webchat npm install failed: ${e.message}`);
+  }
+}
+
+// ── Main ─────────────────────────────────────────────────────────────────────
+
+(async () => {
+  console.log('\n╭──────────────────────────────────────────╮');
+  console.log('│  BMO Installer — @aliwey/bmo              │');
+  console.log('╰──────────────────────────────────────────╯\n');
+
+  mkdirp(BMO_HOME);
+  mkdirp(BMO_BIN);
+
+  try {
+    const pythonExe = await installPython();
+    installPipDeps(pythonExe);
+    ensureOpenCode();
+    await installCloudflared();
+    installWebchatDeps();
+
+    console.log('\n╭──────────────────────────────────────────╮');
+    console.log('│  ✅ BMO installed successfully!            │');
+    console.log('│                                          │');
+    console.log('│  Next step:                              │');
+    console.log('│    bmo init   ← configure your bot       │');
+    console.log('│    bmo        ← start BMO                │');
+    console.log('╰──────────────────────────────────────────╯\n');
+  } catch (e) {
+    err(`Installation failed: ${e.message}`);
+    console.log('\nRun `bmo init` to retry configuration, or check the docs.');
+    process.exit(1);
+  }
+})();

package/scripts/relay_cmd.js

@@ -0,0 +1,276 @@
+#!/usr/bin/env node
+/**
+ * bmo relay [--private] [--stop]
+ *
+ * --private  Start relay + cloudflared but don't register with BFP Registry
+ * --stop     Stop relay and deregister from BFP Registry
+ */
+
+'use strict';
+
+const { spawn, execSync, spawnSync } = require('child_process');
+const net   = require('net');
+const https = require('https');
+const http  = require('http');
+const fs    = require('fs');
+const path  = require('path');
+const os    = require('os');
+
+const BMO_HOME   = process.env.BMO_HOME || path.join(os.homedir(), '.bmo');
+const BMO_BIN    = path.join(BMO_HOME, 'bin');
+const PKG_DIR    = path.join(__dirname, '..');
+const TASKS_FILE = path.join(BMO_HOME, 'data', 'background_tasks.json');
+const RELAY_PORT = parseInt(process.env.BFP_RELAY_PORT || '9753');
+const REGISTRY_URL = process.env.BFP_REGISTRY_URL || 'https://bfp-registry.aliwey.workers.dev';
+
+const isPrivate  = process.argv.includes('--private');
+const isStop     = process.argv.includes('--stop');
+
+function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
+
+function loadTasks() {
+  try { return JSON.parse(fs.readFileSync(TASKS_FILE, 'utf8')); } catch { return {}; }
+}
+
+function saveTasks(tasks) {
+  fs.mkdirSync(path.dirname(TASKS_FILE), { recursive: true });
+  fs.writeFileSync(TASKS_FILE, JSON.stringify(tasks, null, 2));
+}
+
+async function isPortOpen(port) {
+  return new Promise(resolve => {
+    const s = net.createConnection({ port, host: '127.0.0.1' });
+    s.setTimeout(500);
+    s.on('connect', () => { s.destroy(); resolve(true); });
+    s.on('timeout', () => { s.destroy(); resolve(false); });
+    s.on('error', () => resolve(false));
+  });
+}
+
+function getCloudflaredExe() {
+  const embedded = process.platform === 'win32'
+    ? path.join(BMO_BIN, 'cloudflared.exe')
+    : path.join(BMO_BIN, 'cloudflared');
+  if (fs.existsSync(embedded)) return embedded;
+  try { execSync('cloudflared --version', { stdio: 'ignore' }); return 'cloudflared'; } catch {}
+  console.error('❌ cloudflared not found. Run: bmo init');
+  process.exit(1);
+}
+
+function getPython() {
+  const embeddedWin  = path.join(BMO_HOME, 'python', 'python.exe');
+  const embeddedUnix = path.join(BMO_HOME, 'python', 'bin', 'python3');
+  if (fs.existsSync(embeddedWin))  return embeddedWin;
+  if (fs.existsSync(embeddedUnix)) return embeddedUnix;
+  for (const cmd of ['python3', 'python']) {
+    try { execSync(`${cmd} --version`, { stdio: 'ignore' }); return cmd; } catch {}
+  }
+  return 'python3';
+}
+
+/** Read DID from bfp identity file */
+function getDID() {
+  const idFile = path.join(BMO_HOME, 'data', 'bfp_identity.json');
+  if (!fs.existsSync(idFile)) {
+    // Try project-local data dir (dev mode)
+    const devFile = path.join(PKG_DIR, 'data', 'bfp_identity.json');
+    if (fs.existsSync(devFile)) return JSON.parse(fs.readFileSync(devFile)).did;
+    return null;
+  }
+  return JSON.parse(fs.readFileSync(idFile)).did;
+}
+
+/** POST to BFP Registry */
+function registryPost(endpoint, body) {
+  return new Promise((resolve, reject) => {
+    const url = new URL(REGISTRY_URL + endpoint);
+    const data = JSON.stringify(body);
+    const opts = {
+      hostname: url.hostname,
+      path: url.pathname + url.search,
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(data) },
+    };
+    const lib = url.protocol === 'https:' ? https : http;
+    const req = lib.request(opts, res => {
+      let body = '';
+      res.on('data', d => body += d);
+      res.on('end', () => resolve({ status: res.statusCode, body }));
+    });
+    req.on('error', reject);
+    req.write(data);
+    req.end();
+  });
+}
+
+/** Parse cloudflared output for ws:// or wss:// tunnel URL */
+function waitForTunnelUrl(proc) {
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => reject(new Error('Tunnel URL timeout')), 30000);
+    const handler = data => {
+      const text = data.toString();
+      // cloudflared prints the https:// URL; BFP needs ws:// equivalent
+      const m = text.match(/https?:\/\/[a-zA-Z0-9\-]+\.trycloudflare\.com/);
+      if (m) {
+        clearTimeout(timeout);
+        const wsUrl = m[0].replace('https://', 'wss://').replace('http://', 'ws://');
+        resolve(wsUrl);
+      }
+    };
+    proc.stdout && proc.stdout.on('data', handler);
+    proc.stderr && proc.stderr.on('data', handler);
+  });
+}
+
+// ── Stop handler ─────────────────────────────────────────────────────────────
+
+async function stopRelay() {
+  console.log('🛑 Stopping BFP relay...');
+  const tasks = loadTasks();
+
+  // Kill processes
+  for (const key of ['bfp_relay_pid', 'bfp_cf_pid']) {
+    const pid = tasks[key];
+    if (pid) {
+      try { process.kill(pid, 'SIGTERM'); } catch {}
+    }
+  }
+
+  // Deregister from registry
+  const did = tasks.bfp_did || getDID();
+  if (did && !isPrivate) {
+    try {
+      await registryPost('/unregister', { did });
+      console.log('✓ Deregistered from BFP Registry');
+    } catch (e) {
+      console.warn('⚠️  Could not deregister:', e.message);
+    }
+  }
+
+  delete tasks.bfp_relay_pid;
+  delete tasks.bfp_cf_pid;
+  delete tasks.bfp_tunnel_url;
+  delete tasks.bfp_did;
+  saveTasks(tasks);
+
+  console.log('✅ BFP relay stopped\n');
+  process.exit(0);
+}
+
+// ── Main ─────────────────────────────────────────────────────────────────────
+
+(async () => {
+  if (isStop) { await stopRelay(); return; }
+
+  // ── Start BFP relay (Python) ────────────────────────────────────────────────
+  if (await isPortOpen(RELAY_PORT)) {
+    const tasks = loadTasks();
+    if (tasks.bfp_tunnel_url) {
+      console.log(`\n🌐 BFP relay already running!`);
+      console.log(`   DID:    ${tasks.bfp_did || 'unknown'}`);
+      console.log(`   Relay:  ${tasks.bfp_tunnel_url}\n`);
+      process.exit(0);
+    }
+  }
+
+  console.log('⏳ Starting BFP relay server...');
+  const python = getPython();
+  const relay = spawn(python, ['-m', 'tools.bfp_relay', '--port', String(RELAY_PORT)], {
+    cwd: PKG_DIR,
+    stdio: ['ignore', 'pipe', 'pipe'],
+    detached: true,
+    env: { ...process.env, BMO_HOME, PYTHONUNBUFFERED: '1' },
+  });
+  relay.unref();
+
+  // Wait for relay to bind
+  for (let i = 0; i < 20; i++) {
+    await sleep(500);
+    if (await isPortOpen(RELAY_PORT)) break;
+    if (i === 19) { console.error('❌ BFP relay failed to start'); process.exit(1); }
+  }
+  console.log(`✓ BFP relay running on port ${RELAY_PORT}`);
+
+  // ── Start cloudflared tunnel ────────────────────────────────────────────────
+  console.log('⏳ Starting cloudflared tunnel...');
+  const cfExe = getCloudflaredExe();
+  const cf = spawn(cfExe, ['tunnel', '--url', `ws://localhost:${RELAY_PORT}`], {
+    stdio: ['ignore', 'pipe', 'pipe'],
+    detached: true,
+  });
+  cf.unref();
+
+  let tunnelUrl;
+  try {
+    tunnelUrl = await waitForTunnelUrl(cf);
+  } catch {
+    console.error('❌ Could not get tunnel URL from cloudflared');
+    relay.kill();
+    process.exit(1);
+  }
+  console.log(`✓ Tunnel active: ${tunnelUrl}`);
+
+  // ── Get DID ─────────────────────────────────────────────────────────────────
+  // Run the bfp_identity module to get (or create) the DID
+  const didResult = spawnSync(python, ['-c',
+    `import sys; sys.path.insert(0, '${PKG_DIR.replace(/\\/g, '\\\\')}'); from core.bfp_identity import get_did; print(get_did())`
+  ], { encoding: 'utf8', env: { ...process.env, BMO_HOME } });
+  const did = (didResult.stdout || '').trim() || getDID();
+
+  // ── Register with BFP Registry ───────────────────────────────────────────────
+  const caps = ['code', 'research', 'files', 'web', 'terminal', 'memory'];
+  if (!isPrivate && did) {
+    try {
+      await registryPost('/register', { did, endpoint: tunnelUrl, caps });
+      console.log(`✓ Registered with BFP Registry (${REGISTRY_URL})`);
+    } catch (e) {
+      console.warn(`⚠️  Registry registration failed: ${e.message}`);
+    }
+  } else if (isPrivate) {
+    console.log('ℹ️  Private mode — skipping registry registration');
+  }
+
+  // Save to task registry
+  const tasks = loadTasks();
+  tasks.bfp_relay_pid = relay.pid;
+  tasks.bfp_cf_pid    = cf.pid;
+  tasks.bfp_tunnel_url = tunnelUrl;
+  tasks.bfp_did       = did;
+  saveTasks(tasks);
+
+  // ── Periodic re-registration (every 30 min) ──────────────────────────────────
+  let refreshTimer;
+  if (!isPrivate && did) {
+    refreshTimer = setInterval(async () => {
+      try {
+        await registryPost('/register', { did, endpoint: tunnelUrl, caps });
+      } catch {}
+    }, 30 * 60 * 1000);
+  }
+
+  console.log('\n╭───────────────────────────────────────────────────────╮');
+  console.log('│  🌐 BMO BFP Relay is ONLINE                           │');
+  console.log(`│  DID:    ${(did || 'unknown').substring(0, 43).padEnd(43)} │`);
+  console.log(`│  Relay:  ${tunnelUrl.padEnd(43)} │`);
+  console.log(`│  Mode:   ${(isPrivate ? 'Private (not in registry)' : 'Public (discoverable)').padEnd(43)} │`);
+  console.log('│                                                       │');
+  console.log('│  Press Ctrl+C to stop and go offline                  │');
+  console.log('╰───────────────────────────────────────────────────────╯\n');
+
+  // Keep process alive, handle graceful shutdown
+  process.stdin.resume();
+  process.on('SIGINT', async () => {
+    if (refreshTimer) clearInterval(refreshTimer);
+    console.log('\n🛑 Shutting down BFP relay...');
+    if (!isPrivate && did) {
+      try { await registryPost('/unregister', { did }); console.log('✓ Deregistered'); } catch {}
+    }
+    try { relay.kill(); } catch {}
+    try { cf.kill(); } catch {}
+    const t = loadTasks();
+    delete t.bfp_relay_pid; delete t.bfp_cf_pid;
+    delete t.bfp_tunnel_url; delete t.bfp_did;
+    saveTasks(t);
+    process.exit(0);
+  });
+})();

package/scripts/web_cmd.js

@@ -0,0 +1,136 @@
+#!/usr/bin/env node
+/**
+ * bmo web — Start webchat + cloudflared tunnel, return public URL.
+ * If already running, return existing URL from task registry.
+ */
+
+'use strict';
+
+const { spawn, execSync } = require('child_process');
+const net  = require('net');
+const fs   = require('fs');
+const path = require('path');
+const os   = require('os');
+const https = require('https');
+
+const BMO_HOME  = process.env.BMO_HOME || path.join(os.homedir(), '.bmo');
+const BMO_BIN   = path.join(BMO_HOME, 'bin');
+const PKG_DIR   = path.join(__dirname, '..');
+const TASKS_FILE = path.join(BMO_HOME, 'data', 'background_tasks.json');
+const WEBCHAT_PORT = parseInt(process.env.PORT || '3456');
+
+function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
+
+async function isPortOpen(port) {
+  return new Promise(resolve => {
+    const s = net.createConnection({ port, host: '127.0.0.1' });
+    s.setTimeout(500);
+    s.on('connect', () => { s.destroy(); resolve(true); });
+    s.on('timeout', () => { s.destroy(); resolve(false); });
+    s.on('error', () => resolve(false));
+  });
+}
+
+function getCloudflaredExe() {
+  const embedded = process.platform === 'win32'
+    ? path.join(BMO_BIN, 'cloudflared.exe')
+    : path.join(BMO_BIN, 'cloudflared');
+  if (fs.existsSync(embedded)) return embedded;
+  try { execSync('cloudflared --version', { stdio: 'ignore' }); return 'cloudflared'; } catch {}
+  console.error('❌ cloudflared not found. Run: bmo init');
+  process.exit(1);
+}
+
+function loadTasks() {
+  try { return JSON.parse(fs.readFileSync(TASKS_FILE, 'utf8')); } catch { return {}; }
+}
+
+function saveTasks(tasks) {
+  fs.mkdirSync(path.dirname(TASKS_FILE), { recursive: true });
+  fs.writeFileSync(TASKS_FILE, JSON.stringify(tasks, null, 2));
+}
+
+/** Parse cloudflared stdout/stderr for the public URL */
+function waitForTunnelUrl(proc) {
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => reject(new Error('Tunnel URL timeout')), 30000);
+    const handler = data => {
+      const text = data.toString();
+      const m = text.match(/https?:\/\/[a-zA-Z0-9\-]+\.trycloudflare\.com/);
+      if (m) { clearTimeout(timeout); resolve(m[0]); }
+    };
+    proc.stdout && proc.stdout.on('data', handler);
+    proc.stderr && proc.stderr.on('data', handler);
+  });
+}
+
+(async () => {
+  // Check if webchat is already running
+  if (await isPortOpen(WEBCHAT_PORT)) {
+    const tasks = loadTasks();
+    const existing = tasks.webchat_tunnel_url;
+    if (existing) {
+      console.log(`\n💬 Webchat already running!`);
+      console.log(`   Local:  http://127.0.0.1:${WEBCHAT_PORT}`);
+      console.log(`   Public: ${existing}\n`);
+      process.exit(0);
+    }
+  }
+
+  // Start webchat server
+  console.log('⏳ Starting webchat server...');
+  const webchatDir = path.join(PKG_DIR, 'webchat');
+  const webchat = spawn('node', ['server.js'], {
+    cwd: webchatDir,
+    stdio: 'ignore',
+    detached: true,
+    env: {
+      ...process.env,
+      PORT: String(WEBCHAT_PORT),
+      BMO_HOME,
+      BMO_DB_PATH: path.join(BMO_HOME, 'data', 'bot.db'),
+    }
+  });
+  webchat.unref();
+
+  // Wait for webchat to be ready
+  for (let i = 0; i < 20; i++) {
+    await sleep(500);
+    if (await isPortOpen(WEBCHAT_PORT)) break;
+    if (i === 19) { console.error('❌ Webchat failed to start'); process.exit(1); }
+  }
+  console.log('✓ Webchat server running on port', WEBCHAT_PORT);
+
+  // Start cloudflared tunnel
+  console.log('⏳ Starting cloudflared tunnel...');
+  const cfExe = getCloudflaredExe();
+  const cf = spawn(cfExe, ['tunnel', '--url', `http://localhost:${WEBCHAT_PORT}`], {
+    stdio: ['ignore', 'pipe', 'pipe'],
+    detached: true,
+  });
+  cf.unref();
+
+  let tunnelUrl;
+  try {
+    tunnelUrl = await waitForTunnelUrl(cf);
+  } catch {
+    console.error('❌ Could not get tunnel URL from cloudflared');
+    process.exit(1);
+  }
+
+  // Save to task registry
+  const tasks = loadTasks();
+  tasks.webchat_pid = webchat.pid;
+  tasks.webchat_cf_pid = cf.pid;
+  tasks.webchat_tunnel_url = tunnelUrl;
+  tasks.webchat_local_url = `http://127.0.0.1:${WEBCHAT_PORT}`;
+  saveTasks(tasks);
+
+  console.log('\n╭────────────────────────────────────────────╮');
+  console.log('│  💬 BMO Webchat is live!                   │');
+  console.log(`│  Local:  http://127.0.0.1:${WEBCHAT_PORT}             │`);
+  console.log(`│  Public: ${tunnelUrl.padEnd(34)} │`);
+  console.log('╰────────────────────────────────────────────╯\n');
+
+  process.exit(0);
+})();