@noobdemon/noob-cli 1.0.5 → 1.0.7

package/bin/noob.js

@@ -7,7 +7,7 @@ import { t } from "../src/i18n.js";
 import { checkLatest, runUpdate, CURRENT } from "../src/update.js";
 
 const argv = process.argv.slice(2);
-const opts = { yolo: false, model: undefined, prompt: undefined };
+const opts = { yolo: false, model: undefined, prompt: undefined, continue: false, resume: false };
 const positional = [];
 
 for (let i = 0; i < argv.length; i++) {
@@ -15,6 +15,9 @@ for (let i = 0; i < argv.length; i++) {
   if (a === "--yolo" || a === "-y") opts.yolo = true;
   else if (a === "--insecure-tls") process.env.NOOB_INSECURE_TLS = "1";
   else if (a === "--model" || a === "-m") opts.model = argv[++i];
+  else if (a === "--continue" || a === "-c") opts.continue = true;
+  else if (a === "--resume" || a === "-r") opts.resume = true;
+  else if (a.startsWith("--resume=")) opts.resume = a.slice("--resume=".length);
   else if (a === "--help" || a === "-h") {
     printHelp();
     process.exit(0);
@@ -90,6 +93,8 @@ Cách dùng:
 Tuỳ chọn:
   -m, --model <id>    chọn mô hình (vd: gateway-claude-opus-4-7)
   -y, --yolo          tự động duyệt sửa file & chạy lệnh (cẩn thận)
+  -c, --continue      tiếp tục phiên gần nhất (resume)
+  -r, --resume[=id]   chọn phiên để tiếp tục (không id = hiện danh sách)
       --insecure-tls  tắt kiểm tra TLS (chỉ cho mạng có proxy chặn TLS)
   -h, --help          hiện trợ giúp
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noobdemon/noob-cli",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "publishConfig": {
     "access": "public"
   },

package/src/i18n.js

@@ -11,6 +11,9 @@ export const t = {
   pressAgainToExit: "nhấn Ctrl+C lần nữa để thoát",
   running: "đang chạy…",
   denied: "đã từ chối",
+  queued: (n, txt) => `⏎ đã xếp hàng [${n}] · gửi khi model xong: ${txt}`,
+  queueCleared: (n) => `(đã xoá ${n} tin đang xếp hàng)`,
+  permRetry: "→ gõ y (đồng ý) · n (từ chối) · a (luôn cho phép)",
 
   // auth
   notLoggedIn:
@@ -51,7 +54,9 @@ export const t = {
   cmdSearch: "/search        bật/tắt chế độ tìm web",
   cmdChat: "/chat          quay lại chế độ chat thường",
   cmdYolo: "/yolo          bật/tắt tự duyệt (hoặc nhấn Shift+Tab)",
-  cmdClear: "/clear /new    xoá ngữ cảnh hội thoại",
+  cmdClear: "/clear /new    xoá ngữ cảnh (mở phiên mới, phiên cũ vẫn resume được)",
+  cmdResume: "/resume [id]   tiếp tục phiên cũ (không id = chọn từ danh sách)",
+  cmdSessions: "/sessions      liệt kê các phiên đã lưu",
   cmdLogin: "/login <key>   đăng nhập bằng API key",
   cmdLogout: "/logout        đăng xuất",
   cmdUsage: "/usage         xem hạn mức key còn lại",
@@ -59,8 +64,8 @@ export const t = {
   cmdVersion: "/version /v    xem version hiện tại + trạng thái yolo",
   cmdExit: "/exit /quit     thoát",
   tip1: "• Mô tả việc cần làm; noob sẽ đọc/sửa file & chạy lệnh giúp bạn.",
-  tip2: "• Thao tác nguy hiểm sẽ hỏi phép, trừ khi bật yolo (Shift+Tab).",
-  tip3: "• Ctrl+C 1 lần = dừng lượt hiện tại, 2 lần = thoát. CLI không tự tắt sau khi xong.",
+  tip2: "• Đang chạy vẫn gõ tiếp được — tin sẽ xếp hàng & tự gửi khi model xong.",
+  tip3: "• Shift+Tab: bật/tắt yolo nhanh. Ctrl+C 1 lần = dừng lượt, 2 lần = thoát.",
 
   // misc
   yoloOn: "⚠ yolo BẬT — tự động duyệt mọi thao tác sửa file & chạy lệnh",
@@ -81,6 +86,17 @@ export const t = {
   maxSteps: "_(đã dừng: chạm giới hạn số bước tool)_",
   toolDenied: "Người dùng từ chối thao tác này. Hãy đổi cách làm hoặc hỏi lại.",
 
+  // sessions (lưu lịch sử + resume)
+  sessionResumed: (id) => `Đã khôi phục phiên ${id}`,
+  sessionNonePrev: "Chưa có phiên nào trước đó — bắt đầu phiên mới.",
+  sessionNotFound: (id) => `Không tìm thấy phiên "${id}".`,
+  sessionEmpty: "Chưa có phiên đã lưu nào.",
+  sessionPickTitle: "Chọn phiên để tiếp tục:",
+  sessionListTitle: "Các phiên đã lưu:",
+  sessionPickPrompt: (n) => `chọn phiên [1-${n}], Enter để bỏ qua › `,
+  sessionPickBad: "lựa chọn không hợp lệ.",
+  sessionResumeHint: "/resume <id>  để tiếp tục một phiên · hoặc chạy: noob -c (phiên gần nhất)",
+
   // update
   cmdUpdate: "/update        cập nhật noob lên bản mới nhất",
   updateFound: (cur, lat) => `🆕 Có bản mới ${lat} (đang dùng ${cur}) — đang tự cập nhật nền…`,

package/src/repl.js

@@ -10,6 +10,7 @@ import { c, banner, modelBadge, renderMarkdown, box } from "./ui.js";
 import { config } from "./config.js";
 import { t } from "./i18n.js";
 import { checkLatest, runUpdate, CURRENT } from "./update.js";
+import * as sessions from "./sessions.js";
 
 export async function startRepl(opts = {}) {
   const state = {
@@ -28,54 +29,108 @@ export async function startRepl(opts = {}) {
     return c.user(nl + t.promptYou) + yolo + c.dim("v" + CURRENT + " › ");
   };
 
-  const rl = readline.createInterface({ input: process.stdin, output: process.stdout, prompt: "" });
-  let closed = false;
-  const queue = []; // lines typed/piped, consumed in order
-  let waiter = null; // resolver awaiting the next line
-
-  rl.on("line", (line) => {
+  // ── Input layer — KHÔNG ĐƯỢC tự tắt ───────────────────────────────────────
+  // Trên Windows CMD, readline có thể phát sự kiện 'close' KHÔNG phải vì người
+  // dùng muốn thoát (console/keypress tranh chấp, hoặc một tiến trình con chạm
+  // vào console). Nếu để 'close' đó kết thúc vòng lặp → CLI "tự động tắt" giữa
+  // chừng (thường ngay sau khi hỏi quyền). Hơn nữa, một khi readline đã đóng,
+  // không còn handle nào giữ stdin → event loop cạn → Node thoát code 0.
+  //
+  // Khắc phục: trên TTY ta DỰNG LẠI readline khi gặp 'close' bất thường và giữ
+  // nguyên reader đang chờ (người dùng chỉ thấy prompt hiện lại). Chỉ dừng thật
+  // khi: /exit, Ctrl+C hai lần, hoặc EOF thật (stdin piped đã cạn / 'close' dồn
+  // dập nghĩa là stdin đã mất).
+  let rl;
+  let closed = false; // đã ngừng đọc vĩnh viễn
+  let exiting = false; // ta chủ động thoát (/exit, Ctrl+C ×2)
+  let lastPrompt = ""; // áp lại sau khi dựng lại interface
+  // Hàng đợi tin nhắn (giống Claude Code): khi model đang chạy, gõ thêm câu hỏi
+  // → xếp vào `pending`; xong turn, main loop tự lấy câu kế tiếp gửi lên. CHỈ
+  // main loop tiêu thụ `pending`. Câu trả lời permission đi qua `waiter` riêng,
+  // nên tin xếp hàng KHÔNG bị nhầm thành câu trả lời "cho phép?".
+  const pending = [];
+  let waiter = null; // resolver đang chờ một dòng tươi (prompt / permission)
+  let closeAt = 0;
+
+  function deliver(line) {
     if (waiter) {
       const w = waiter;
       waiter = null;
       w(line);
-    } else {
-      queue.push(line); // type-ahead / buffered input — never dropped
+      return;
     }
-  });
-  rl.on("close", () => {
+    // Không ai đang hỏi → đây là tin xếp hàng cho lượt kế tiếp.
+    pending.push(line);
+    if (process.stdin.isTTY) console.log(c.dim("  " + t.queued(pending.length, truncate(line, 60))));
+  }
+  function endInput() {
     closed = true;
     if (waiter) {
       const w = waiter;
       waiter = null;
       w(null);
     }
-  });
+  }
+  function buildRl() {
+    const r = readline.createInterface({ input: process.stdin, output: process.stdout, prompt: "" });
+    r.on("line", deliver);
+    r.on("close", () => {
+      if (exiting) return endInput(); // ta chủ động thoát
+      // EOF THẬT: stdin đã end/destroy (Ctrl+Z trên Windows, Ctrl+D trên *nix),
+      // hoặc stdin không phải TTY (piped) đã đọc hết. Chỉ lúc đó mới dừng.
+      if (!process.stdin.isTTY || process.stdin.readableEnded || process.stdin.destroyed) {
+        return endInput();
+      }
+      // 'close' BẤT THƯỜNG trên một TTY còn sống (tranh chấp console khi
+      // paste/đa dòng, tiến trình con, v.v.) → KHÔNG BAO GIỜ thoát. Dựng lại
+      // interface và hiện lại prompt; reader đang chờ vẫn được giữ nguyên. Nếu
+      // close dồn dập thì hoãn 50ms để khỏi quay CPU — nhưng vẫn sống.
+      const now = Date.now();
+      const fast = now - closeAt < 50;
+      closeAt = now;
+      const rebuild = () => {
+        rl = buildRl();
+        if (lastPrompt) {
+          rl.setPrompt(lastPrompt);
+          rl.prompt();
+        }
+      };
+      if (fast) setTimeout(rebuild, 50);
+      else rebuild();
+    });
+    return r;
+  }
+  rl = buildRl();
 
-  // Robust input: every line is captured by the 'line' event (nothing is lost
-  // while a turn is processing) and handed out one at a time. Works for an
-  // interactive TTY and for piped / non-TTY stdin (Git Bash, CI, etc.).
   function nextLine() {
-    if (queue.length) return Promise.resolve(queue.shift());
     if (closed) return Promise.resolve(null);
     return new Promise((res) => (waiter = res));
   }
-  function ask(promptStr) {
-    if (closed && !queue.length) return Promise.resolve(null);
-    rl.setPrompt(promptStr);
+  // Dòng "tươi": dùng cho prompt chính VÀ cho permission. KHÔNG đụng tới
+  // `pending` (hàng đợi tin nhắn) — chỉ main loop mới rút từ `pending`.
+  function ask(prompt) {
+    if (closed) return Promise.resolve(null);
+    lastPrompt = prompt;
+    rl.setPrompt(prompt);
     rl.prompt();
     return nextLine();
   }
 
-  // Shift+Tab — quick yolo toggle.
+  // Shift+Tab — bật/tắt yolo nhanh (best-effort; gắn vào stdin nên sống qua mọi
+  // lần dựng lại rl; bọc try/catch để không bao giờ làm hỏng input).
   if (process.stdin.isTTY) {
-    readline.emitKeypressEvents(process.stdin);
-    process.stdin.on("keypress", (_str, key) => {
-      if (!key || key.name !== "tab" || !key.shift) return;
-      state.yolo = !state.yolo;
-      console.log(state.yolo ? c.err("  " + t.yoloOn) : c.ok("  " + t.yoloOff));
-      rl.setPrompt(promptStr(false)); // cập nhật dòng trạng thái ngay lập tức
-      rl.prompt(true);
-    });
+    try {
+      readline.emitKeypressEvents(process.stdin);
+      process.stdin.on("keypress", (_str, key) => {
+        if (!key || key.name !== "tab" || !key.shift) return;
+        state.yolo = !state.yolo;
+        console.log(state.yolo ? c.err("  " + t.yoloOn) : c.ok("  " + t.yoloOff));
+        rl.setPrompt(promptStr(false)); // cập nhật dòng trạng thái ngay lập tức
+        rl.prompt(true);
+      });
+    } catch {
+      /* không có Shift+Tab cũng được — vẫn dùng /yolo */
+    }
   }
 
   let abort = null; // active turn controller
@@ -84,6 +139,11 @@ export async function startRepl(opts = {}) {
     if (abort) {
       abort.abort();
       abort = null;
+      if (pending.length) {
+        const n = pending.length;
+        pending.length = 0; // ngắt lượt → xoá luôn tin đang xếp hàng
+        console.log(c.dim("  " + t.queueCleared(n)));
+      }
       console.log(c.err("\n  ✗ " + t.interrupted));
       return; // the main loop will redraw the prompt
     }
@@ -111,6 +171,69 @@ export async function startRepl(opts = {}) {
     if (!closed) rl.prompt(true);
   });
 
+  // ── phiên (session): lưu lịch sử + resume giống Claude Code ───────────────
+  let session = null;
+  const persist = () => {
+    if (!session || !state.history.length) return; // đừng lưu phiên rỗng
+    session.history = state.history; // giữ đồng bộ tuyệt đối với history sống
+    session.model = state.model.id;
+    sessions.save(session);
+  };
+  async function restore(s) {
+    session = s;
+    state.history = s.history || [];
+    state.mode = "chat";
+    if (s.model) {
+      const m = findModel(s.model);
+      if (m) state.model = m;
+    }
+    console.log(c.ok("  ✓ " + t.sessionResumed(s.id)));
+    const turns = state.history.filter((m) => m.role === "user");
+    const tail = turns.slice(-5);
+    const base = turns.length - tail.length;
+    tail.forEach((m, i) => console.log(c.dim(`  ${base + i + 1}. `) + truncate(m.content, 70)));
+    console.log("");
+  }
+  async function pickSession() {
+    const items = sessions.list(20);
+    if (!items.length) {
+      console.log(c.dim("  " + t.sessionEmpty) + "\n");
+      return null;
+    }
+    console.log("\n" + chalk.bold("  " + t.sessionPickTitle));
+    items.forEach((s, i) =>
+      console.log(
+        c.accent(`  ${String(i + 1).padStart(2)}. `) +
+          chalk.bold(s.title || "(trống)") +
+          c.dim(`  · ${s.turns} lượt · ${relTime(s.updatedAt)} · ${shortPath(s.cwd)}`),
+      ),
+    );
+    const ans = ((await ask(c.tool("  " + t.sessionPickPrompt(items.length)))) ?? "").trim();
+    if (!ans) return null;
+    const idx = parseInt(ans, 10) - 1;
+    if (Number.isNaN(idx) || idx < 0 || idx >= items.length) {
+      console.log(c.err("  " + t.sessionPickBad) + "\n");
+      return null;
+    }
+    const full = sessions.load(items[idx].id);
+    if (full) await restore(full);
+    return full;
+  }
+  function listSessions() {
+    const items = sessions.list(20);
+    if (!items.length) return console.log(c.dim("  " + t.sessionEmpty));
+    console.log("\n" + chalk.bold("  " + t.sessionListTitle));
+    items.forEach((s) =>
+      console.log(
+        c.dim("  " + s.id.padEnd(20)) +
+          chalk.bold(s.title || "(trống)") +
+          c.dim(`  · ${s.turns} lượt · ${relTime(s.updatedAt)}`),
+      ),
+    );
+    console.log(c.dim("\n  " + t.sessionResumeHint) + "\n");
+  }
+  const startFresh = () => (session = sessions.newSession({ cwd: process.cwd(), model: state.model.id }));
+
   banner();
   printStatus(state);
   if (!config.apiKey) console.log("\n" + c.tool("  " + t.notLoggedIn) + "\n");
@@ -128,16 +251,45 @@ export async function startRepl(opts = {}) {
       .catch(() => {});
   }
 
+  // Khôi phục phiên theo cờ dòng lệnh, hoặc mở phiên mới.
+  if (opts.continue) {
+    const s = sessions.latest();
+    if (s) await restore(s);
+    else {
+      startFresh();
+      console.log(c.dim("  " + t.sessionNonePrev) + "\n");
+    }
+  } else if (opts.resume === true) {
+    if (!(await pickSession())) startFresh();
+  } else if (typeof opts.resume === "string") {
+    const s = sessions.load(opts.resume);
+    if (s) await restore(s);
+    else {
+      console.log(c.err("  " + t.sessionNotFound(opts.resume)) + "\n");
+      startFresh();
+    }
+  } else {
+    startFresh();
+  }
+
   if (opts.prompt) {
     console.log(c.user(t.promptYou) + c.dim("› ") + opts.prompt);
     await handle(opts.prompt);
+    persist();
   }
 
   // Main loop — runs until /exit, double Ctrl+C, or EOF. Never exits after a task.
   while (true) {
-    const raw = await ask(promptStr());
-    if (raw == null) break; // stdin fully closed and drained
-    const input = raw.trim();
+    let input;
+    if (pending.length) {
+      // Có tin xếp hàng → tự gửi câu kế tiếp (không chờ gõ).
+      input = (pending.shift() ?? "").trim();
+      if (process.stdin.isTTY && input) console.log(promptStr() + input);
+    } else {
+      const raw = await ask(promptStr());
+      if (raw == null) break; // stdin fully closed and drained
+      input = raw.trim();
+    }
     if (!input) continue;
     // Bọc cả lượt: một lỗi trong xử lý lệnh/agent không được phép thoát ra
     // ngoài vòng lặp (sẽ rơi vào .catch ở bin/noob.js → process.exit(1) =
@@ -149,10 +301,12 @@ export async function startRepl(opts = {}) {
         continue;
       }
       await handle(input);
+      persist(); // lưu sau mỗi lượt → resume được kể cả khi tắt đột ngột
     } catch (err) {
       printError(err);
     }
   }
+  exiting = true;
   rl.close();
   process.exit(0);
 
@@ -228,11 +382,9 @@ export async function startRepl(opts = {}) {
     else if (name === "edit_file") preview(`- ${truncate(input.old_string)}\n+ ${truncate(input.new_string)}`, input.path);
 
     if (DESTRUCTIVE.has(name) && !state.yolo && !state.autoApprove.has(name)) {
-      const a = ((await ask(c.tool("  cho phép? ") + c.dim("[y] có / [n] không / [a] luôn " + name + " › "))) ?? "n")
-        .trim()
-        .toLowerCase();
+      const a = await askPermission(name);
       if (a === "a") state.autoApprove.add(name);
-      else if (a !== "y" && a !== "") {
+      else if (a === "n") {
         console.log(c.err("  " + t.denied));
         return { allow: false };
       }
@@ -251,6 +403,27 @@ export async function startRepl(opts = {}) {
     }
   }
 
+  // Đọc câu trả lời cho phép một cách CHẮC CHẮN. Chỉ chấp nhận y/n/a (hoặc
+  // Enter = đồng ý). Nếu nhận một dòng lạ & dài — gần như chắc là một tin nhắn
+  // bị paste/gõ nhầm vào đúng lúc prompt hiện ra (đây là thủ phạm làm hỏng &
+  // "tự tắt" trước đây) — thì KHÔNG coi là từ chối: xếp nó vào hàng đợi tin
+  // nhắn rồi HỎI LẠI. Nhờ vậy không thao tác nào bị quyết định bởi rác.
+  async function askPermission(name) {
+    while (true) {
+      const raw = await ask(c.tool("  cho phép? ") + c.dim("[y] có / [n] không / [a] luôn " + name + " › "));
+      if (raw == null) return "n"; // stdin đóng thật
+      const a = raw.trim().toLowerCase();
+      if (a === "" || a === "y" || a === "yes" || a === "có") return "y";
+      if (a === "n" || a === "no" || a === "không") return "n";
+      if (a === "a" || a === "always" || a === "luôn") return "a";
+      if (raw.trim().length > 3) {
+        pending.push(raw); // tin nhắn lạc → xếp hàng, gửi sau khi xong lượt
+        console.log(c.dim("  " + t.queued(pending.length, truncate(raw, 60))));
+      }
+      console.log(c.dim("  " + t.permRetry));
+    }
+  }
+
   // ── slash commands ─────────────────────────────────────────────────────
   async function command(input) {
     const [cmd, ...rest] = input.slice(1).split(/\s+/);
@@ -296,12 +469,32 @@ export async function startRepl(opts = {}) {
         break;
       case "clear":
       case "new":
+        persist(); // giữ lại phiên cũ trên đĩa
         state.history = [];
+        startFresh(); // phiên mới (phiên cũ vẫn resume được)
         console.clear();
         banner();
         printStatus(state);
         console.log(c.dim("  " + t.ctxCleared + "\n"));
         break;
+      case "resume":
+        if (arg) {
+          const s = sessions.load(arg);
+          if (s) await restore(s);
+          else console.log(c.err("  " + t.sessionNotFound(arg)));
+        } else {
+          await pickSession();
+        }
+        break;
+      case "continue": {
+        const s = sessions.latest();
+        if (s) await restore(s);
+        else console.log(c.dim("  " + t.sessionNonePrev));
+        break;
+      }
+      case "sessions":
+        listSessions();
+        break;
       case "cwd":
         console.log(c.dim("  " + process.cwd()));
         break;
@@ -315,6 +508,8 @@ export async function startRepl(opts = {}) {
       case "exit":
       case "quit":
       case "q":
+        persist();
+        exiting = true;
         console.log(c.dim("  " + t.bye));
         return true;
       default:
@@ -436,6 +631,8 @@ function printHelp() {
         "  " + t.cmdUsage,
         "  " + t.cmdUpdate,
         "  " + t.cmdClear,
+        "  " + t.cmdResume,
+        "  " + t.cmdSessions,
         "  " + t.cmdStatus,
         "  " + t.cmdVersion,
         "  " + t.cmdExit,
@@ -466,6 +663,15 @@ const shortCwd = () => {
   const p = process.cwd();
   return p.length > 48 ? "…" + p.slice(-47) : p;
 };
+const shortPath = (p = "") => (p.length > 30 ? "…" + p.slice(-29) : p);
+const relTime = (ts) => {
+  const m = Math.round((Date.now() - ts) / 60000);
+  if (m < 1) return "vừa xong";
+  if (m < 60) return m + " phút trước";
+  const h = Math.round(m / 60);
+  if (h < 24) return h + " giờ trước";
+  return Math.round(h / 24) + " ngày trước";
+};
 const firstLine = (s) => (s.split("\n")[0] || "").slice(0, 100);
 const truncate = (s = "", n = 120) => (s.length > n ? s.slice(0, n) + "…" : s).replace(/\n/g, "⏎");
 const fmtTime = (iso) => {

package/src/sessions.js

@@ -0,0 +1,109 @@
+// Lưu & khôi phục lịch sử hội thoại (giống --continue / --resume của Claude Code).
+// Mỗi phiên là một file JSON trong ~/.noob/sessions/. Ghi sau mỗi lượt nên có rớt
+// mạng / tắt máy vẫn resume được.
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+
+const DIR = path.join(os.homedir(), ".noob", "sessions");
+
+function ensure() {
+  try {
+    fs.mkdirSync(DIR, { recursive: true });
+  } catch {
+    /* best effort */
+  }
+}
+
+function genId() {
+  const d = new Date();
+  const p = (n) => String(n).padStart(2, "0");
+  const stamp = `${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}-${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}`;
+  return `${stamp}-${Math.random().toString(36).slice(2, 6)}`;
+}
+
+function titleFrom(history = []) {
+  const first = history.find((m) => m.role === "user");
+  if (!first) return "";
+  return String(first.content).replace(/\s+/g, " ").trim().slice(0, 60);
+}
+
+export function newSession({ cwd, model } = {}) {
+  const now = Date.now();
+  return {
+    id: genId(),
+    createdAt: now,
+    updatedAt: now,
+    cwd: cwd || process.cwd(),
+    model: model || "",
+    title: "",
+    history: [],
+  };
+}
+
+export function save(session) {
+  if (!session || !session.id) return false;
+  ensure();
+  session.updatedAt = Date.now();
+  if (!session.title) session.title = titleFrom(session.history);
+  try {
+    fs.writeFileSync(path.join(DIR, session.id + ".json"), JSON.stringify(session), "utf8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function load(id) {
+  if (!id) return null;
+  try {
+    return JSON.parse(fs.readFileSync(path.join(DIR, id + ".json"), "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+/** Tóm tắt nhẹ (không tải toàn bộ history vào view), sắp xếp mới nhất trước. */
+export function list(limit = 30) {
+  ensure();
+  let files;
+  try {
+    files = fs.readdirSync(DIR).filter((f) => f.endsWith(".json"));
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const f of files) {
+    try {
+      const s = JSON.parse(fs.readFileSync(path.join(DIR, f), "utf8"));
+      out.push({
+        id: s.id,
+        updatedAt: s.updatedAt || s.createdAt || 0,
+        cwd: s.cwd || "",
+        model: s.model || "",
+        title: s.title || titleFrom(s.history || []),
+        turns: (s.history || []).filter((m) => m.role === "user").length,
+      });
+    } catch {
+      /* bỏ qua file hỏng */
+    }
+  }
+  out.sort((a, b) => b.updatedAt - a.updatedAt);
+  return out.slice(0, limit);
+}
+
+export function latest() {
+  const l = list(1);
+  return l.length ? load(l[0].id) : null;
+}
+
+export function remove(id) {
+  try {
+    fs.unlinkSync(path.join(DIR, id + ".json"));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export const sessionsDir = DIR;

package/src/tools.js

@@ -119,7 +119,10 @@ export const TOOLS = {
       const isWin = process.platform === "win32";
       const shell = isWin ? "powershell.exe" : "/bin/bash";
       const args = isWin ? ["-NoProfile", "-NonInteractive", "-Command", command] : ["-c", command];
-      const child = spawn(shell, args, { cwd: cwd() });
+      // stdin: "ignore" — tiến trình con KHÔNG được chạm vào console/stdin của
+      // CLI. Nếu để con kế thừa stdin, trên Windows nó có thể làm readline phát
+      // 'close' → CLI tự tắt. Đóng hẳn stdin con để tránh hoàn toàn.
+      const child = spawn(shell, args, { cwd: cwd(), stdio: ["ignore", "pipe", "pipe"] });
       let out = "";
       const killer = setTimeout(() => child.kill(), timeout);
       child.stdout.on("data", (d) => (out += d));