bom-pi 0.0.6 → 0.0.8

package/apps/web/server.mjs

@@ -657,7 +657,7 @@ button{width:100%;background:#1f6feb;color:#fff;border:0;border-radius:8px;paddi
   function guessName(){
     const u=navigator.userAgent;
     const os=/iPad/.test(u)?'iPad':/iPhone/.test(u)?'iPhone':/Android/.test(u)?'Android':/Windows/.test(u)?'Windows':/Mac/.test(u)?'Mac':'Device';
-    const br=/Edg\//.test(u)?'Edge':/CriOS|Chrome\//.test(u)?'Chrome':/FxiOS|Firefox\//.test(u)?'Firefox':/Safari\//.test(u)?'Safari':'Browser';
+    const br=/Edg\\//.test(u)?'Edge':/CriOS|Chrome\\//.test(u)?'Chrome':/FxiOS|Firefox\\//.test(u)?'Firefox':/Safari\\//.test(u)?'Safari':'Browser';
     return os+' · '+br;
   }
   if(!code)return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bom-pi",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "type": "module",
   "description": "bom × pi — hệ sinh thái durable cho pi trên nền pi-durable: core daemon + web UI pocket + CLI",
   "engines": {

package/packages/cli/src/bom-pi.mjs

@@ -4,10 +4,12 @@
 //   submit <text...> [--model p/m] | reset [handoff...] | transcript | watch | shutdown
 // Mọi lệnh conversation nhận --cid N (mặc định: conversation active của daemon).
 import { connect } from 'node:net';
-import { join, resolve } from 'node:path';
+import { dirname, join, resolve } from 'node:path';
 import { userInfo, homedir, hostname } from 'node:os';
 import { readFile, writeFile, mkdir, stat } from 'node:fs/promises';
-import { execFile } from 'node:child_process';
+import { openSync } from 'node:fs';
+import { execFile, spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
 import { promisify } from 'node:util';
 import process from 'node:process';
 
@@ -27,6 +29,13 @@ const cid = arg('cid', null); // conversation id cho submit/transcript/reset/wat
 const cidParams = () => (cid ? { conversationId: Number(cid) } : {});
 const cmd = process.argv[2] ?? 'status';
 
+// HTTP loopback của daemon TRÊN MÁY NÀY (Windows / không unix socket)
+const LOCAL_HTTP = `http://127.0.0.1:${arg('port', process.env.BOM_PI_PORT || 8790)}`;
+const dataDir = process.env.BOM_PI_DATA_DIR || join(homedir(), '.local/state/bom-pi');
+const httpTokenPath = join(dataDir, 'http.token');
+// Tự khởi động daemon nền khi CLI cần mà chưa có — trừ lệnh tắt/hỏi trạng thái
+const AUTO_START = cmd !== 'shutdown' && !(cmd === 'daemon' && ['stop', 'status', 'log'].includes(process.argv[3]));
+
 // Remote (thiết bị khác — Windows/phone): pair MỘT lần bằng 'bom-pi pair <code> --url …'
 // ⇒ CLI tự lưu {url, token} vào ~/.bom-pi.json và dùng mãi (env BOM_PI_URL/BOM_PI_TOKEN
 // vẫn đè lên nếu đặt; --url/--token đè lên tất cả). CLI nói chuyện web /rpc thay unix socket.
@@ -47,23 +56,25 @@ if (cmd === '-v' || cmd === '--version' || cmd === 'version') {
   process.exit(0);
 }
 
-// Không thấy daemon: hướng dẫn theo nơi đang chạy — máy chủ (chưa start?) hay
-// thiết bị khác (Windows/phone: bom-core là daemon unix-socket systemd, chưa port).
+// Không thấy daemon: hướng dẫn theo nơi đang chạy — máy này (chưa start?) hay
+// thiết bị khác (pair remote một lần). CLI đã THỬ tự khởi động daemon nền trước khi
+// in cái này — thấy nó nghĩa là auto-start cũng chết (xem log).
 function unreachable(e) {
-  const head = `cannot reach bom-core at ${socketPath}: ${e.message}`;
+  const head = `cannot reach bom-core at ${socketPath} (và ${LOCAL_HTTP}): ${e.message}`;
   if (process.platform === 'win32') {
     return `${head}
 
-  bom-core chạy trên máy chủ Linux (unix socket + systemd) — CLI chưa chạy được trên Windows.
-  Từ máy khác, pair MỘT LẦN bằng CLI (cần code in từ lệnh 'bom-pi pair' chạy TRÊN MÁY CHỦ):
-    bom-pi pair <CODE> --url http://<ip-máy-chủ>:8791
-  xong CLI tự nhớ (lưu ~/.bom-pi.json) — mọi lệnh chạy remote: bom-pi status / sessions …
-  (hoặc dùng WEB đầy đủ: mở http://<ip-máy-chủ>:8791 — pair bằng cùng code đó)`;
+  CLI đã thử tự khởi động daemon nền mà không lên — xem log: ${join(dataDir, 'bom-core.log')}
+  thử chạy tay để thấy lỗi:  bom-core
+  hoặc điều khiển MÁY KHÁC: pair một lần bằng
+    bom-pi pair <CODE> --url http://<ip-máy-khác>:8791`;
   }
   return `${head}
 
   daemon chưa chạy? thử:  systemctl --user start bom-core   (xem trạng thái: bom-pi status)
   chưa cài daemon?:      bom-pi setup
+  chạy tay không systemd?:  bom-pi daemon start
+  log daemon do CLI khởi động:  bom-pi daemon log
   ở THIẾT BỊ KHÁC?:      pair một lần rồi mọi lệnh chạy remote:
                          bom-pi pair <CODE> --url http://<ip-máy-chạy-daemon>:8791`;
 }
@@ -98,8 +109,103 @@ function rpcSocket(method, params) {
     });
     // Daemon chết giữa chừng / đóng connection không trả lời
     conn.on('close', () => settle(fail, new Error('bom-core closed the connection without a reply')));
-    conn.on('error', (e) => settle(fail, new Error(unreachable(e))));
+    conn.on('error', (e) => {
+      const err = new Error(unreachable(e));
+      err.code = e.code; // giữ code (ENOENT/ECONNREFUSED) để dispatcher fallback HTTP
+      settle(fail, err);
+    });
+  });
+}
+
+// HTTP loopback (Windows / nơi không có unix socket): cùng /rpc, bearer http.token
+// của daemon trên MÁY NÀY — token tự sinh lúc daemon khởi động, mode 0600.
+let httpToken = null;
+async function localHttpToken() {
+  if (httpToken !== null) return httpToken;
+  httpToken = (await readFile(httpTokenPath, 'utf8')).trim();
+  return httpToken;
+}
+async function rpcHttp(method, params) {
+  const token = await localHttpToken(); // ENOENT ⇒ không có daemon HTTP ⇒ lỗi unreachable gốc
+  let r;
+  try {
+    r = await fetch(`${LOCAL_HTTP}/rpc`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json', Authorization: `Bearer ${token}` },
+      body: JSON.stringify({ jsonrpc: '2.0', id: 1, method, params: params ?? {} }),
+    });
+  } catch (e) {
+    const err = new Error(`cannot reach bom-core at ${LOCAL_HTTP}: ${e.message}`);
+    err.code = e.code;
+    throw err;
+  }
+  const j = await r.json().catch(() => ({}));
+  if (!r.ok) throw new Error(`bom-core ${r.status}: ${j?.error?.message ?? r.statusText}`);
+  if (j.error) throw new Error(`bom-core error ${j.error.code}: ${j.error.message}`);
+  return j.result;
+}
+
+// ---- Auto-start daemon nền (mô hình "mỗi máy một daemon") ----
+// Bài học log Windows 2026-11-03: daemon foreground chiếm terminal ⇒ Ctrl+C giết daemon
+// giữa chừng ⇒ mọi lệnh sau lỗi. CLI giờ tự đưa daemon lên NỀN (detached, log ra file)
+// khi cần và chưa có — không ai phải giữ terminal.
+const daemonMjsPath = () => resolve(dirname(fileURLToPath(import.meta.url)), '..', '..', '..', 'packages', 'core', 'src', 'daemon.mjs');
+const daemonLogPath = () => join(dataDir, 'bom-core.log');
+let daemonAliveCache = false;
+
+async function daemonAlive() {
+  if (daemonAliveCache) return true;
+  const sockOk = await new Promise((done) => {
+    const c = connect(socketPath);
+    c.once('connect', () => { c.destroy(); done(true); });
+    c.once('error', () => done(false));
+  });
+  if (sockOk) { daemonAliveCache = true; return true; }
+  try {
+    const r = await fetch(`${LOCAL_HTTP}/healthz`, { signal: AbortSignal.timeout(800) });
+    daemonAliveCache = r.ok;
+    return r.ok;
+  } catch { return false; }
+}
+
+async function ensureDaemon() {
+  if (await daemonAlive()) return true;
+  const daemon = daemonMjsPath();
+  try { await stat(daemon); } catch { return false; } // không tìm thấy file daemon — cứ báo unreachable
+  await mkdir(dataDir, { recursive: true });
+  const logFd = openSync(daemonLogPath(), 'a');
+  const args = [daemon];
+  const portArg = process.argv.indexOf('--port');
+  if (portArg >= 0 && process.argv[portArg + 1]) args.push('--port', process.argv[portArg + 1]);
+  const child = spawn(process.execPath, args, {
+    detached: true, // sống sót sau khi CLI exit — Ctrl+C terminal không đụng được
+    stdio: ['ignore', logFd, logFd],
+    windowsHide: true,
+    env: { ...process.env },
   });
+  child.unref();
+  for (let i = 0; i < 80; i++) {
+    await new Promise((r) => setTimeout(r, 250)); // mở storage mất vài giây lần đầu
+    if (await daemonAlive()) return true;
+  }
+  return false;
+}
+
+// Local: ưu tiên unix socket; socket không có (Windows / chạy không socket) → HTTP loopback
+async function rpcLocal(method, params) {
+  try {
+    return await rpcSocket(method, params);
+  } catch (e) {
+    if (e?.code === 'ENOENT' || e?.code === 'ECONNREFUSED') {
+      try { return await rpcHttp(method, params); } catch {
+        // không socket, không HTTP → tự đưa daemon nền lên rồi thử lại lần cuối
+        if (AUTO_START && (await ensureDaemon())) {
+          return await rpcHttp(method, params);
+        }
+      }
+    }
+    throw e;
+  }
 }
 
 const pretty = (o) => console.log(JSON.stringify(o, null, 2));
@@ -120,7 +226,7 @@ async function rpcRemote(method, params) {
   if (!r.ok) throw new Error(`bom-web ${REMOTE_URL} ${r.status}: ${j?.error?.message ?? r.statusText}`);
   return j;
 }
-const rpc = REMOTE_URL ? rpcRemote : rpcSocket;
+const rpc = REMOTE_URL ? rpcRemote : rpcLocal;
 
 // Kiểm protocol sau hello — mọi lệnh đều chạy qua đây
 function checkProtocol(hello) {
@@ -134,11 +240,32 @@ function checkProtocol(hello) {
 // ---- watch: mở 1 connection, subscribe, in transcript live đến khi Ctrl+C ----
 function watch() {
   if (REMOTE_URL) {
-    console.error('watch cần kết nối socket local — từ thiết bị khác hãy mở web (transcript live có sẵn trong UI)');
+    console.error('watch cần kết nối local — từ thiết bị khác hãy mở web (transcript live có sẵn trong UI)');
     process.exit(64);
   }
-  const conn = connect(socketPath);
   let gotReply = false;
+  const onMsg = (msg) => {
+    if (msg.id === 1 && !gotReply) {
+      gotReply = true;
+      if (msg.error) { console.error(`bom-core error ${msg.error.code}: ${msg.error.message}`); process.exit(1); }
+      const { conversationId, seq, snapshot } = msg.result;
+      console.error(`# conversation ${conversationId} @seq ${seq} — Ctrl+C để thoát`);
+      for (const e of snapshot) printEntry(e);
+    } else if (msg.id === null && msg.result && !gotReply) {
+      // dòng result đầu của stream /events (cùng shape reply events.subscribe)
+      gotReply = true;
+      const { conversationId, seq, snapshot } = msg.result;
+      console.error(`# conversation ${conversationId} @seq ${seq} — Ctrl+C để thoát`);
+      for (const e of snapshot) printEntry(e);
+    } else if (msg.method === 'events.update') {
+      const { conversationId, seq, entries } = msg.params;
+      console.error(`--- ${conversationId} seq ${seq}`);
+      for (const e of entries) printEntry(e);
+    } else if (msg.method === 'events.heartbeat') {
+      console.error(`· heartbeat seq ${msg.params.seq}`);
+    }
+  };
+  const conn = connect(socketPath);
   conn.on('connect', () => {
     conn.write(JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'events.subscribe', params: cidParams() }) + '\n');
   });
@@ -147,24 +274,43 @@ function watch() {
       if (!raw.trim()) continue;
       let msg;
       try { msg = JSON.parse(raw); } catch { continue; }
-      if (msg.id === 1 && !gotReply) {
-        gotReply = true;
-        if (msg.error) { console.error(`bom-core error ${msg.error.code}: ${msg.error.message}`); process.exit(1); }
-        const { conversationId, seq, snapshot } = msg.result;
-        console.error(`# conversation ${conversationId} @seq ${seq} — Ctrl+C để thoát`);
-        for (const e of snapshot) printEntry(e);
-      } else if (msg.method === 'events.update') {
-        const { conversationId, seq, entries } = msg.params;
-        console.error(`--- ${conversationId} seq ${seq}`);
-        for (const e of entries) printEntry(e);
-      } else if (msg.method === 'events.heartbeat') {
-        console.error(`· heartbeat seq ${msg.params.seq}`);
-      }
+      onMsg(msg);
     }
   });
-  conn.on('error', (e) => { console.error(unreachable(e)); process.exit(1); });
+  conn.on('error', (e) => {
+    if (e.code === 'ENOENT' || e.code === 'ECONNREFUSED') { watchHttp(onMsg, () => gotReply); return; }
+    console.error(unreachable(e)); process.exit(1);
+  });
   conn.on('close', () => { if (!gotReply) { console.error('bom-core closed the connection without a reply'); process.exit(1); } process.exit(0); });
 }
+
+// Windows / không unix socket: stream /events của HTTP loopback (NDJSON, cùng grammar socket)
+async function watchHttp(onMsg, gotReply) {
+  let token = null;
+  try { token = await localHttpToken(); }
+  catch {
+    if (AUTO_START && (await ensureDaemon())) { try { token = await localHttpToken(); } catch { /* vẫn không có — báo dưới */ } }
+  }
+  if (!token) { console.error(unreachable(new Error('no socket, no http.token'))); process.exit(1); }
+  const q = cid ? `?conversationId=${encodeURIComponent(cid)}` : '';
+  let res;
+  try { res = await fetch(`${LOCAL_HTTP}/events${q}`, { headers: { Authorization: `Bearer ${token}` } }); }
+  catch (e) { console.error(unreachable(e)); process.exit(1); }
+  if (!res.ok) { console.error(`bom-core ${res.status}: watch qua ${LOCAL_HTTP}/events thất bại`); process.exit(1); }
+  let buf = '';
+  for await (const chunk of res.body) {
+    buf += chunk.toString('utf8');
+    let nl;
+    while ((nl = buf.indexOf('\n')) >= 0) {
+      const line = buf.slice(0, nl).trim();
+      buf = buf.slice(nl + 1);
+      if (!line) continue;
+      try { onMsg(JSON.parse(line)); } catch { /* dòng lệch — bỏ */ }
+    }
+  }
+  if (!gotReply()) { console.error('stream /events đóng không có reply'); process.exit(1); }
+  process.exit(0);
+}
 const printEntry = (e) => console.log(`[${e.kind}]${e.role ? ` ${e.role}:` : ''} ${e.text ?? ''}`);
 
 const t0 = Date.now();
@@ -366,6 +512,17 @@ try {
       console.error(`máy này đã pair remote tới ${REMOTE_URL} (config ${CONFIG_PATH}).\n  'bom-pi pair' (in code/QR) là lệnh chạy TRÊN MÁY CHỦ — chạy đó, hoặc gỡ remote: bom-pi unpair.`);
       process.exit(64);
     } else if (!sub2) {
+      // Link pair cần WEB phục vụ trang /pair — máy này chưa chạy web thì mint code vô ích
+      let webUp = false;
+      try { const r = await fetch('http://127.0.0.1:8791/', { redirect: 'manual', signal: AbortSignal.timeout(1200) }); webUp = r.status > 0; } catch { /* web không nghe */ }
+      if (!webUp) {
+        console.error(`máy này chưa chạy web (:8791) — link pair sẽ không mở được ở thiết bị khác.
+
+  chạy web máy này:      bom-web --port 8791    (rồi chạy lại 'bom-pi pair')
+  hoặc GHÉP máy này vào máy khác (máy đã chạy daemon + web):
+                          bom-pi pair <CODE> --url http://<ip-máy-đó>:8791`);
+        process.exit(64);
+      }
       const r = await rpc('pair.code');
       const nets = await import('node:os');
       const lan = Object.values(nets.networkInterfaces() ?? {}).flat()
@@ -419,10 +576,18 @@ try {
     await saveCliConfig({});
     console.log(`đã xoá ${CONFIG_PATH} — CLI quay về local socket.`);
   } else if (cmd === 'setup') {
+    if (process.platform === 'win32') {
+      // Windows không có systemd — daemon chạy foreground; service tự khởi động là việc sau
+      console.log('Windows: mở terminal riêng và chạy  bom-core  (daemon HTTP 127.0.0.1:8790, giữ mở)');
+      console.log('CLI máy này dùng được ngay sau đó:  bom-pi status');
+      console.log('Web UI máy này (tuỳ chọn):  bom-web --port 8791  rồi mở http://127.0.0.1:8791');
+      console.log('Điều khiển máy KHÁC:  bom-pi pair <CODE> --url http://<ip-máy-khác>:8791');
+      process.exit(0);
+    }
     // Sinh systemd user units đúng đường dẫn cài (npm global HOẶC working tree) + enable.
     // root = 3 cấp trên file CLI này: packages/cli/src → gốc package (cả hai kiểu cài đều đúng)
     const { fileURLToPath } = await import('node:url');
-    const root = resolve(fileURLToPath(import.meta.url), '..', '..', '..');
+    const root = resolve(dirname(fileURLToPath(import.meta.url)), '..', '..', '..'); // resolve(file,'..') pop filename — đi từ dirname
     const daemon = resolve(root, 'packages/core/src/daemon.mjs');
     const web = resolve(root, 'apps/web/server.mjs');
     for (const f of [daemon, web]) {
@@ -469,6 +634,23 @@ WantedBy=default.target
     console.log('✓ enabled: bom-core + bom-web (systemd user)');
     console.log('\nTiếp theo:  bom-pi pair  → quét QR trên phone →  bom-pi pair approve <mã ghép>');
     console.log('Log:         journalctl --user -u bom-core -f');
+  } else if (cmd === 'daemon') {
+    // bom-pi daemon [start|stop|status|log] — daemon nền do CLI quản (systemd máy chủ tự lo phần mình)
+    const sub3 = process.argv[3] ?? 'start';
+    if (sub3 === 'start') {
+      if (await ensureDaemon()) console.log(`daemon sống — ${LOCAL_HTTP} · log: ${daemonLogPath()}`);
+      else { console.error(`không đưa được daemon lên sau 20s — xem log: ${daemonLogPath()}`); process.exit(1); }
+    } else if (sub3 === 'stop') {
+      try { pretty(await rpc('shutdown')); console.log('đã gửi shutdown — daemon đóng storage rồi exit'); }
+      catch (e) { console.error('daemon không chạy (hoặc không tắt được):', e.message); process.exit(1); }
+    } else if (sub3 === 'status') {
+      console.log(await daemonAlive() ? 'daemon ĐANG chạy' : 'daemon KHÔNG chạy');
+    } else if (sub3 === 'log') {
+      try { console.log(await readFile(daemonLogPath(), 'utf8')); }
+      catch { console.error(`chưa có log CLI (${daemonLogPath()}) — systemd: journalctl --user -u bom-core`); }
+    } else {
+      console.error('usage: bom-pi daemon [start|stop|status|log]'); process.exit(64);
+    }
   } else if (cmd === 'device') {
     // bom-pi device rm <id>
     const sub2 = process.argv[3];
@@ -552,7 +734,7 @@ WantedBy=default.target
   } else if (cmd === 'shutdown') {
     pretty(await rpc('shutdown'));
   } else {
-    console.error('usage: bom-pi <hello|status|models|agents|sessions|new|use|submit|reset|transcript|approvals|approve|deny|schedules|schedule|unschedule|factory|limits|abort|watch|unpair|version> [--socket PATH] [--cid N] [--url http://host:8791] [--token bom_…]\n       thiết bị khác: bom-pi pair <CODE> --url http://host:8791 — pair một lần, CLI tự nhớ (xem bom-pi version)');
+    console.error('usage: bom-pi <hello|status|models|agents|sessions|new|use|submit|reset|transcript|approvals|approve|deny|schedules|schedule|unschedule|factory|limits|abort|watch|unpair|daemon|version> [--socket PATH] [--cid N] [--url http://host:8791] [--token bom_…]\n       thiết bị khác: bom-pi pair <CODE> --url http://host:8791 — pair một lần, CLI tự nhớ (xem bom-pi version)');
     process.exit(64);
   }
   if (cmd !== 'watch') process.exit(0);

package/packages/core/src/daemon.mjs

@@ -24,10 +24,11 @@
 // kill giữa turn sẽ chạy lại (restartLimit 5). Tools: CodingTools (read/write/edit/bash).
 
 import { connect, createServer } from 'node:net';
+import { createServer as createHttpServer } from 'node:http';
 import { mkdir, readFile, readdir, realpath, rename, rm, stat, writeFile } from 'node:fs/promises';
 import { chmodSync } from 'node:fs';
 import { dirname, join, relative, resolve, sep } from 'node:path';
-import { homedir, userInfo } from 'node:os';
+import { homedir, platform, userInfo } from 'node:os';
 import process from 'node:process';
 import { execFile as execFileCb } from 'node:child_process';
 import { promisify } from 'node:util';
@@ -44,7 +45,11 @@ function arg(name, fallback) {
 
 const runtimeDir = process.env.XDG_RUNTIME_DIR || `/tmp/run-${userInfo().uid}`;
 const socketPath = arg('socket', resolve(runtimeDir, 'bom-pi.sock'));
-const dataDir = arg('data', resolve(homedir(), '.local/state/bom-pi'));
+const dataDir = arg('data', process.env.BOM_PI_DATA_DIR || resolve(homedir(), '.local/state/bom-pi'));
+// HTTP loopback (bước mesh hóa): nền tảng không có unix socket (Windows) vẫn chạy daemon
+// đầy đủ; Linux chạy song song cả hai. Token tự sinh trên chính máy này (http.token 0600).
+const httpPort = Number(arg('port', process.env.BOM_PI_PORT || 8790));
+const httpTokenPath = join(dataDir, 'http.token');
 const defaultCwd = arg('cwd', homedir()); // thư mục làm việc mặc định của agent (đổi qua --cwd)
 const dbPath = resolve(dataDir, 'pi.sqlite');
 const lockPath = join(dataDir, 'bom-core.lock');
@@ -57,6 +62,7 @@ let models = null; // ModelRuntime (pi-coding-agent) — credentials pi thật
 let harness = null;
 let storage = null;
 let server = null;
+let httpServer = null;
 let listening = false;
 let closing = false;
 let signalWhileOpening = false;
@@ -80,6 +86,10 @@ async function shutdown(reason) {
   let failed = false;
   if (heartbeatTimer) clearInterval(heartbeatTimer);
   if (scheduleTimer) clearInterval(scheduleTimer);
+  if (httpServer) {
+    httpServer.close(); // stream /events đang mở không được giữ chân exit
+    httpServer.closeAllConnections?.();
+  }
   for (const [, w] of watches) {
     try { await w.handle.stop(); } catch {}
   }
@@ -2099,6 +2109,12 @@ const methods = {
 const writeMsg = (conn, obj) => conn.write(JSON.stringify(obj) + '\n');
 
 async function handleOne(conn, msg) {
+  // Method đẩy notification phải chạy trên connection dài (socket hoặc /events stream),
+  // không phải POST /rpc một-shot: nhận snapshot rồi mất mọi events sau đó.
+  if (conn.__httpRpc && (String(msg?.method ?? '').startsWith('events.') || msg?.method === 'approvals.subscribe')) {
+    if (msg?.id !== undefined) writeMsg(conn, { jsonrpc: '2.0', id: msg.id, error: { code: -32601, message: `${msg.method} cần stream dài — dùng GET /events (bearer http.token) hoặc unix socket` } });
+    return;
+  }
   // -32600 invalid request: null / không phải object / thiếu jsonrpc 2.0 / method không phải chuỗi
   if (!msg || typeof msg !== 'object' || Array.isArray(msg) || msg.jsonrpc !== '2.0' || typeof msg.method !== 'string') {
     writeMsg(conn, { jsonrpc: '2.0', id: msg?.id ?? null, error: { code: -32600, message: 'invalid request' } });
@@ -2156,26 +2172,117 @@ server = createServer((conn) => {
       handle(conn, line).catch((e) => log('lỗi xử lý request:', e?.message ?? e)); // không để reject giết daemon
     }
   });
-  conn.on('close', () => {
-    approvalConns.delete(conn);
-    // bỏ mọi subscribe của connection này; conversation hết subscriber → stop watch
-    for (const convId of connConvs.get(conn) ?? []) {
-      const w = watches.get(convId);
-      if (!w) continue;
-      w.conns.delete(conn);
-      if (!w.conns.size) {
-        w.handle.stop().catch(() => {});
-        watches.delete(convId);
-      }
-    }
-    connConvs.delete(conn);
-  });
+  conn.on('close', () => dropConn(conn));
   conn.on('error', (e) => log('conn lỗi:', e.message));
 });
 
-await rm(socketPath, { force: true }); // an toàn: probe ở trên đã xác nhận không daemon sống
-await mkdir(dirname(socketPath), { recursive: true, mode: 0o700 });
-await new Promise((res) => server.listen(socketPath, res));
-chmodSync(socketPath, 0o600); // socket chỉ owner nối được
-listening = true;
-log('nghe tại', socketPath, '— protocol', PROTOCOL, '— pid', process.pid);
+// Dọn subscribe của một connection đã đi: dùng cho cả socket thật và conn ảo HTTP
+function dropConn(conn) {
+  approvalConns.delete(conn);
+  // bỏ mọi subscribe của connection này; conversation hết subscriber → stop watch
+  for (const convId of connConvs.get(conn) ?? []) {
+    const w = watches.get(convId);
+    if (!w) continue;
+    w.conns.delete(conn);
+    if (!w.conns.size) {
+      w.handle.stop().catch(() => {});
+      watches.delete(convId);
+    }
+  }
+  connConvs.delete(conn);
+}
+
+if (platform() === 'win32') {
+  // Windows không có unix socket — daemon vẫn đầy đủ qua HTTP loopback bên dưới
+  log('windows: bỏ unix socket, chỉ HTTP loopback 127.0.0.1:' + httpPort);
+} else {
+  await rm(socketPath, { force: true }); // an toàn: probe ở trên đã xác nhận không daemon sống
+  await mkdir(dirname(socketPath), { recursive: true, mode: 0o700 });
+  await new Promise((res) => server.listen(socketPath, res));
+  chmodSync(socketPath, 0o600); // socket chỉ owner nối được
+  listening = true;
+  log('nghe tại', socketPath, '— protocol', PROTOCOL, '— pid', process.pid);
+}
+
+// ---- HTTP loopback: /healthz public, /rpc + /events cần bearer http.token ----
+// Cùng bảng methods và cùng grammar NDJSON với socket; /events là stream dài
+// (dòng result của events.subscribe rồi các notification events.update/heartbeat).
+let httpToken = '';
+try { httpToken = (await readFile(httpTokenPath, 'utf8')).trim(); } catch { /* sinh mới ngay dưới */ }
+if (!/^[A-Za-z0-9_-]{43}$/.test(httpToken)) {
+  httpToken = randomBytes(32).toString('base64url');
+  await writeFile(httpTokenPath, httpToken + '\n', { mode: 0o600 });
+  chmodSync(httpTokenPath, 0o600);
+}
+const httpAuthed = (req) => {
+  const got = Buffer.from(String(req.headers.authorization ?? ''));
+  const want = Buffer.from(`Bearer ${httpToken}`);
+  return got.length === want.length && timingSafeEqual(got, want);
+};
+httpServer = createHttpServer(async (req, res) => {
+  const url = new URL(req.url ?? '/', 'http://127.0.0.1');
+  if (req.method === 'GET' && url.pathname === '/healthz') {
+    res.writeHead(200, { 'content-type': 'application/json' });
+    res.end(JSON.stringify({ ok: true, name: 'bom-core', version: VERSION, protocol: PROTOCOL }));
+    return;
+  }
+  if (!httpAuthed(req)) {
+    res.writeHead(401, { 'content-type': 'application/json' });
+    res.end(JSON.stringify({ jsonrpc: '2.0', id: null, error: { code: -32000, message: 'unauthorized: Authorization: Bearer <token từ http.token>' } }));
+    return;
+  }
+  if (req.method === 'POST' && url.pathname === '/rpc') {
+    const chunks = []; let size = 0;
+    for await (const c of req) {
+      size += c.length;
+      if (size > 1_048_576) { res.writeHead(413); res.end(); return; } // 1 MB — như ws.maxPayload spec tunnel
+      chunks.push(c);
+    }
+    let msg;
+    try { msg = JSON.parse(Buffer.concat(chunks).toString('utf8')); } catch {
+      res.writeHead(200, { 'content-type': 'application/json' });
+      res.end(JSON.stringify({ jsonrpc: '2.0', id: null, error: { code: -32700, message: 'parse error' } }));
+      return;
+    }
+    if (Array.isArray(msg) && msg.length === 0) {
+      res.writeHead(200, { 'content-type': 'application/json' });
+      res.end(JSON.stringify({ jsonrpc: '2.0', id: null, error: { code: -32600, message: 'invalid request: empty batch' } }));
+      return;
+    }
+    const replies = [];
+    const vconn = { __httpRpc: true, write: (s) => { const line = String(s).trim(); if (line) replies.push(JSON.parse(line)); }, on: () => {} };
+    const items = Array.isArray(msg) ? msg : [msg];
+    for (const item of items) await handleOne(vconn, item);
+    dropConn(vconn);
+    res.writeHead(200, { 'content-type': 'application/json' });
+    res.end(JSON.stringify(Array.isArray(msg) ? replies : replies[0] ?? null));
+    return;
+  }
+  if (req.method === 'GET' && url.pathname === '/events') {
+    res.writeHead(200, { 'content-type': 'application/x-ndjson', 'cache-control': 'no-store' });
+    const vconn = { __httpStream: true, write: (s) => res.write(s), on: () => {} };
+    res.on('close', () => dropConn(vconn));
+    try {
+      const convId = url.searchParams.get('conversationId') ?? undefined;
+      const result = await methods.eventsSubscribe({ conversationId: convId }, { conn: vconn, push: (m, p) => writeMsg(vconn, { jsonrpc: '2.0', method: m, params: p ?? {} }) });
+      res.write(JSON.stringify({ jsonrpc: '2.0', id: null, result }) + '\n');
+    } catch (e) {
+      res.write(JSON.stringify({ jsonrpc: '2.0', id: null, error: { code: -32000, message: e?.message ?? String(e) } }) + '\n');
+      res.end();
+    }
+    return;
+  }
+  res.writeHead(404, { 'content-type': 'application/json' });
+  res.end(JSON.stringify({ jsonrpc: '2.0', id: null, error: { code: -32601, message: `not found: ${req.method} ${url.pathname}` } }));
+});
+try {
+  await new Promise((res, rej) => {
+    httpServer.once('error', rej);
+    httpServer.listen(httpPort, '127.0.0.1', () => { httpServer.off('error', rej); res(); });
+  });
+} catch (e) {
+  log(`không nghe được HTTP 127.0.0.1:${httpPort}: ${e.code ?? e.message} — cổng bị chiếm? chạy với --port <port khác>`);
+  if (listening) await rm(socketPath, { force: true }); // dọn socket đã mở, không để lại mồ
+  process.exit(1);
+}
+log('http loopback: 127.0.0.1:' + httpPort, '(/rpc /events /healthz) — token:', httpTokenPath);