bom-pi 0.0.5 → 0.0.7

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.5",
+  "version": "0.0.7",
   "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

@@ -5,7 +5,7 @@
 // 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 { userInfo } from 'node:os';
+import { userInfo, homedir, hostname } from 'node:os';
 import { readFile, writeFile, mkdir, stat } from 'node:fs/promises';
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
@@ -27,10 +27,18 @@ const cid = arg('cid', null); // conversation id cho submit/transcript/reset/wat
 const cidParams = () => (cid ? { conversationId: Number(cid) } : {});
 const cmd = process.argv[2] ?? 'status';
 
-// Remote (thiết bị khác — Windows/phone đã pair): BOM_PI_URL=http://host:8791 (+ BOM_PI_TOKEN
-// device token bom_… copy sau khi pair qua browser). CLI nói chuyện web /rpc thay unix socket.
-const REMOTE_URL = arg('url', process.env.BOM_PI_URL || null);
-const REMOTE_TOKEN = arg('token', process.env.BOM_PI_TOKEN || null);
+// 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.
+const CONFIG_PATH = join(homedir(), '.bom-pi.json');
+let cliConfig = {};
+try { cliConfig = JSON.parse(await readFile(CONFIG_PATH, 'utf8')); } catch { /* chưa pair bao giờ */ }
+async function saveCliConfig(next) {
+  cliConfig = next;
+  await writeFile(CONFIG_PATH, `${JSON.stringify(next, null, 2)}\n`, { mode: 0o600 });
+}
+const REMOTE_URL = arg('url', process.env.BOM_PI_URL || cliConfig.url || null);
+const REMOTE_TOKEN = arg('token', process.env.BOM_PI_TOKEN || cliConfig.token || null);
 
 // -v/--version trước mọi thứ — user kiểm bản nào đang chạy (bài học: máy Windows kẹt bản cũ)
 const VERSION = (await import('../../../package.json', { with: { type: 'json' } })).default.version;
@@ -39,28 +47,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).
 function unreachable(e) {
-  const head = `cannot reach bom-core at ${socketPath}: ${e.message}`;
+  const head = `cannot reach bom-core at ${socketPath} (và http://127.0.0.1:8790): ${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.
-  Hai đường từ máy khác:
-  · WEB (đầy đủ nhất):  mở http://<ip-máy-chạy-daemon>:8791 (hoặc tunnel https://…) rồi pair
-                         bằng code in ra từ lệnh 'bom-pi pair' chạy TRÊN MÁY CHỦ đó.
-  · CLI REMOTE:         pair qua browser trước, copy device token bom_…, rồi đặt:
-                         set BOM_PI_URL=http://<ip>:8791  &  set BOM_PI_TOKEN=bom_…
-                         (PowerShell: $env:BOM_PI_URL=…; $env:BOM_PI_TOKEN=…) rồi chạy bom-pi status`;
+  daemon chưa chạy trên máy này. Mở terminal khác và chạy:  bom-core
+  (giữ cửa sổ mở — daemon HTTP loopback 127.0.0.1:8790; sau này sẽ có service tự khởi động)
+  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
-  ở THIẾT BỊ KHÁC?:      CLI có thể nói chuyện daemon từ xa — pair qua browser trước
-                         (http://<ip-máy-chạy-daemon>:8791), copy device token, rồi:
-                         BOM_PI_URL=http://<ip>:8791 BOM_PI_TOKEN=bom_… bom-pi status`;
+  chạy tay không systemd?:  bom-core
+  ở 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`;
 }
 
 function rpcSocket(method, params) {
@@ -93,24 +98,76 @@ 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.
+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');
+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;
+}
+
+// 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 { /* rơi xuống lỗi socket gốc cho đúng thông điệp */ }
+    }
+    throw e;
+  }
+}
+
 const pretty = (o) => console.log(JSON.stringify(o, null, 2));
 
 // Dispatcher: remote (/rpc qua HTTP) khi BOM_PI_URL đặt — thiết bị khác không có unix socket
 async function rpcRemote(method, params) {
-  const r = await fetch(`${REMOTE_URL.replace(/\/+$/, '')}/rpc`, {
-    method: 'POST',
-    headers: { 'content-type': 'application/json', ...(REMOTE_TOKEN ? { Authorization: `Bearer ${REMOTE_TOKEN}` } : {}) },
-    body: JSON.stringify({ jsonrpc: '2.0', id: 1, method, params: params ?? {} }),
-  });
+  let r;
+  try {
+    r = await fetch(`${REMOTE_URL.replace(/\/+$/, '')}/rpc`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json', ...(REMOTE_TOKEN ? { Authorization: `Bearer ${REMOTE_TOKEN}` } : {}) },
+      body: JSON.stringify({ jsonrpc: '2.0', id: 1, method, params: params ?? {} }),
+    });
+  } catch (e) {
+    throw new Error(`không nối được ${REMOTE_URL}: ${e.message} — kiểm tra URL và web daemon (bom-web) đang chạy ở đó`);
+  }
   const j = await r.json().catch(() => ({}));
   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) {
@@ -124,11 +181,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');
   });
@@ -137,24 +215,39 @@ 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;
+  try { token = await localHttpToken(); } catch { 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();
@@ -317,7 +410,45 @@ try {
     // M8 + security: pairing 2 CHIỀU — thiết bị nhập code (chiều 1) ⇒ enrollment chờ;
     // token chỉ cấp khi duyệt tại máy (chiều 2): pair approve <mã ghép>
     const sub2 = process.argv[3];
-    if (!sub2) {
+    if (/^[A-Z2-7]{8}$/i.test(sub2 ?? '')) {
+      // THIẾT BỊ KHÁC pair từ CLI: code in ra từ máy chủ + URL web của máy chủ đó.
+      // /api/pair/start + /api/pair/poll công khai (code + operator duyệt tự vệ) —
+      // xong CLI TỰ LƯU {url, token} vào ~/.bom-pi.json, các lệnh sau chạy remote luôn.
+      const url = arg('url', REMOTE_URL || process.env.BOM_PI_URL || cliConfig.url || null);
+      if (!url) {
+        console.error('usage: bom-pi pair <code> --url http://<ip-máy-chủ>:8791 [--name tên-máy]\n  (URL là máy CHẠY DAEMON — in từ lệnh \'bom-pi pair\' trên máy đó, vd https://bom.example.io.vn hoặc http://192.168.1.4:8791)');
+        process.exit(64);
+      }
+      const base = url.replace(/\/+$/, '');
+      const name = arg('name', `${hostname() || 'device'} (cli)`);
+      const post = async (path, body) => {
+        const r = await fetch(`${base}${path}`, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(body) });
+        const j = await r.json().catch(() => ({}));
+        if (!r.ok) throw new Error(`${path} ${r.status}: ${j?.error ?? r.statusText}`);
+        return j;
+      };
+      const st = await post('/api/pair/start', { code: sub2.toUpperCase(), name });
+      console.log(`đã gửi — chờ duyệt tại MÁY CHỦ. Ghép mã: ${st.displayId}`);
+      console.log(`(trên máy chủ: bom-pi pair approve ${st.displayId})`);
+      const t0 = Date.now();
+      for (;;) {
+        await new Promise((s) => setTimeout(s, st.pollAfterMs || 1500));
+        const p = await post('/api/pair/poll', { enrollId: st.enrollId });
+        if (p.status === 'approved') {
+          await saveCliConfig({ url: base, token: p.deviceToken, deviceId: p.deviceId, pairedAt: Date.now() });
+          console.log(`\nPAIRED ✓ — đã lưu ${CONFIG_PATH}`);
+          console.log(`mọi lệnh giờ tự chạy tới ${base}: bom-pi status / sessions / submit …`);
+          console.log(`(gỡ: bom-pi unpair)`);
+          process.exit(0);
+        }
+        if (p.status === 'rejected') { console.error('từ chối bởi operator tại máy chủ.'); process.exit(1); }
+        if (Date.now() - t0 > 5 * 60 * 1000) { console.error('hết thời gian chờ duyệt (5 phút) — chạy lại.'); process.exit(1); }
+        process.stdout.write('.');
+      }
+    } else if (!sub2 && REMOTE_URL) {
+      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) {
       const r = await rpc('pair.code');
       const nets = await import('node:os');
       const lan = Object.values(nets.networkInterfaces() ?? {}).flat()
@@ -361,7 +492,24 @@ try {
       console.log(`${d.revokedAtMs ? '○' : '●'} ${d.id}  ${(d.name ?? '?').padEnd(18)} ${d.revokedAtMs ? 'revoked ' + new Date(d.revokedAtMs).toLocaleString() : 'paired ' + when}  hash ${d.tokenHash8}`);
     }
     console.error(`# ${r.devices.filter((d) => !d.revokedAtMs).length} đang sống — thu hồi: bom-pi device rm <id>`);
+  } else if (cmd === 'unpair') {
+    // Gỡ remote khỏi máy này: thu hồi device TẠI MÁY CHỦ (best-effort) rồi xoá config local
+    if (!cliConfig.url || !cliConfig.token) { console.error('# máy này chưa pair remote (không có config)'); process.exit(0); }
+    try {
+      await rpcRemote('devices.remove', { id: cliConfig.deviceId });
+      console.log('đã thu hồi device tại máy chủ.');
+    } catch (e) { console.error(`# không thu hồi được tại máy chủ (${e.message}) — xoá config local thôi.`); }
+    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');
@@ -495,7 +643,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|shutdown|version> [--socket PATH] [--cid N] [--url http://host:8791] [--token bom_…]\n       từ thiết bị khác: BOM_PI_URL + BOM_PI_TOKEN (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|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);