bom-pi 0.0.6 → 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.6",
+  "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

@@ -47,23 +47,23 @@ 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.
-  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 đó)`;
+  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
+  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`;
 }
@@ -98,10 +98,57 @@ 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
@@ -120,7 +167,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 +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');
   });
@@ -147,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();
@@ -419,6 +502,14 @@ 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');

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);