@noobdemon/noob-cli 1.0.4 → 1.0.6

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.4",
+  "version": "1.0.6",
   "publishConfig": {
     "access": "public"
   },

package/src/i18n.js

@@ -51,7 +51,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",
@@ -81,6 +83,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 = {
@@ -20,53 +21,101 @@ export async function startRepl(opts = {}) {
     yolo: !!opts.yolo,
   };
 
-  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
+  // Prompt = dòng trạng thái sống. Luôn phản ánh yolo + version theo thời gian
+  // thực (vẽ lại mỗi lượt và ngay khi Shift+Tab), nên không cần gõ /status.
+  const promptStr = (lead = true) => {
+    const nl = lead ? "\n" : "";
+    const yolo = state.yolo ? c.err("⚡ yolo ") : "";
+    return c.user(nl + t.promptYou) + yolo + c.dim("v" + CURRENT + " › ");
+  };
 
-  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
+  const queue = []; // lines đã gõ/pipe, dùng theo thứ tự
+  let waiter = null; // resolver đang chờ dòng kế tiếp
+  let closeBurst = 0;
+  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
+      queue.push(line); // type-ahead / buffered — không bao giờ mất
     }
-  });
-  rl.on("close", () => {
+  }
+  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 || !process.stdin.isTTY) return endInput(); // thoát thật
+      const now = Date.now();
+      if (now - closeAt > 1500) {
+        closeAt = now;
+        closeBurst = 0;
+      }
+      if (++closeBurst > 8) return endInput(); // stdin mất thật → khỏi quay vòng
+      // 'close' bất thường: dựng lại interface, hiện lại prompt; reader vẫn chờ.
+      rl = buildRl();
+      if (lastPrompt) {
+        rl.setPrompt(lastPrompt);
+        rl.prompt();
+      }
+    });
+    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) {
+  function ask(prompt) {
     if (closed && !queue.length) return Promise.resolve(null);
-    rl.setPrompt(promptStr);
+    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("\n  " + t.yoloOn) : c.ok("\n  " + t.yoloOff));
-      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
@@ -102,6 +151,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");
@@ -119,14 +231,36 @@ 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(c.user("\n" + t.promptYou) + (state.yolo ? c.err("⚡ ") : "") + c.dim("› "));
+    const raw = await ask(promptStr());
     if (raw == null) break; // stdin fully closed and drained
     const input = raw.trim();
     if (!input) continue;
@@ -140,10 +274,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);
 
@@ -287,12 +423,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;
@@ -306,6 +462,8 @@ export async function startRepl(opts = {}) {
       case "exit":
       case "quit":
       case "q":
+        persist();
+        exiting = true;
         console.log(c.dim("  " + t.bye));
         return true;
       default:
@@ -427,6 +585,8 @@ function printHelp() {
         "  " + t.cmdUsage,
         "  " + t.cmdUpdate,
         "  " + t.cmdClear,
+        "  " + t.cmdResume,
+        "  " + t.cmdSessions,
         "  " + t.cmdStatus,
         "  " + t.cmdVersion,
         "  " + t.cmdExit,
@@ -457,6 +617,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));