@rennii/deepseek-cli 1.0.0

package/deepseek-cli.js

@@ -0,0 +1,792 @@
+#!/usr/bin/env node
+
+"use strict";
+
+const { execFile } = require("node:child_process");
+const { promisify } = require("node:util");
+const {
+  existsSync,
+  chmodSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  renameSync,
+  writeFileSync,
+} = require("node:fs");
+const { dirname, join } = require("node:path");
+const { randomUUID } = require("node:crypto");
+const readline = require("node:readline/promises");
+
+const execFileAsync = promisify(execFile);
+const APP_DIR = __dirname;
+const BASE_URL = "https://chat.deepseek.com/api/v0";
+const LOGIN_URL = "https://chat.deepseek.com/";
+const DATA_DIR = join(process.env.HOME || process.cwd(), ".deepseek");
+const CONFIG_PATH = join(DATA_DIR, "config.json");
+const AUTH_PATH = join(DATA_DIR, "auth.json");
+const SESSION_DIR = join(DATA_DIR, "sessions");
+const FLAT_SESSION_PATH = join(DATA_DIR, "sessions.json");
+const LEGACY_SESSION_PATH = join(process.env.HOME || process.cwd(), ".local", "share", "deepseek-cli", "sessions.json");
+const MAX_AGENT_STEPS = 25;
+const OUTPUT_TRUNCATE = 4000;
+const COMMAND_TIMEOUT = 120_000;
+const CWD_SENTINEL = "__DEEPSEEK_CWD__";
+
+const RESET = "\x1b[0m";
+const BOLD = "\x1b[1m";
+const DIM = "\x1b[2m";
+const BLUE = "\x1b[38;5;110m";
+const CYAN = "\x1b[38;5;116m";
+const GREEN = "\x1b[38;5;150m";
+const YELLOW = "\x1b[38;5;180m";
+const RED = "\x1b[38;5;174m";
+
+const COMMAND_SUGGESTIONS = [
+  ["/login", "mở trang đăng nhập"],
+  ["/logout", "xóa token đã lưu"],
+  ["/new", "phiên mới"],
+  ["/resume", "mở phiên đã lưu"],
+  ["/agent", "bật/tắt terminal"],
+  ["/clear", "xóa màn hình"],
+  ["/help", "trợ giúp"],
+  ["/exit", "đóng CLI"],
+];
+
+const AGENT_PREAMBLE = [
+  "Bạn đang chạy trong một terminal CLI trên Termux (Android/Linux) và CÓ THỂ chạy lệnh shell trên máy của người dùng.",
+  "Quy tắc:",
+  "- Khi cần chạy lệnh, xuất một khối mã ```bash chứa lệnh. Hệ thống sẽ chạy (sau khi người dùng xác nhận) và gửi lại stdout/stderr/exit code cho bạn ở lượt tiếp theo.",
+  "- DỪNG ngay sau khi xuất khối lệnh, chờ kết quả thật rồi mới tiếp tục. Tuyệt đối không bịa kết quả.",
+  "- Chỉ dùng tag ```bash cho lệnh muốn chạy. Ví dụ minh hoạ không cần chạy thì dùng khối mã không có tag bash/sh/shell.",
+  "- Thư mục làm việc được giữ giữa các lệnh (cd có tác dụng); biến môi trường thì không.",
+  "- Khi đã đủ thông tin, trả lời trực tiếp, không kèm khối bash.",
+].join("\n");
+
+class UserInterrupted extends Error {}
+
+function readJson(path, fallback) {
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return fallback;
+  }
+}
+
+function saveJson(path, value, mode = 0o600) {
+  mkdirSync(dirname(path), { recursive: true });
+  const temporary = `${path}.${process.pid}.${Date.now()}.tmp`;
+  writeFileSync(temporary, `${JSON.stringify(value, null, 2)}\n`, { encoding: "utf8", mode });
+  renameSync(temporary, path);
+  chmodSync(path, mode);
+}
+
+function bootstrapDataDirectory({
+  dataDir = DATA_DIR,
+  legacySessionPath = LEGACY_SESSION_PATH,
+} = {}) {
+  const configPath = join(dataDir, "config.json");
+  const authPath = join(dataDir, "auth.json");
+  const sessionDir = join(dataDir, "sessions");
+  mkdirSync(dataDir, { recursive: true, mode: 0o700 });
+  try { chmodSync(dataDir, 0o700); } catch {}
+  const config = readJson(configPath, {});
+  const auth = readJson(authPath, {});
+  if (!auth.token && config.token) {
+    auth.token = config.token;
+    delete config.token;
+    saveJson(authPath, auth);
+    saveJson(configPath, config);
+  }
+  return {
+    config,
+    configPath,
+    auth,
+    authPath,
+    sessionDir,
+    legacySessionPaths: [join(dataDir, "sessions.json"), legacySessionPath],
+  };
+}
+
+const RUNTIME_DATA = bootstrapDataDirectory();
+
+function resolveToken(runtimeData = RUNTIME_DATA) {
+  return process.env.DEEPSEEK_TOKEN || runtimeData.auth.token || "";
+}
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function newLocalSession() {
+  const timestamp = nowIso();
+  return {
+    id: randomUUID(),
+    title: "Phiên mới",
+    created_at: timestamp,
+    updated_at: timestamp,
+    chat_session_id: null,
+    parent_message_id: null,
+    messages: [],
+  };
+}
+
+function sessionPreview(session, limit = 56) {
+  return String(session.title || "Phiên không tên").replace(/\n/g, " ").slice(0, limit);
+}
+
+function truncateTerminalText(text, limit) {
+  if (limit <= 0) return "";
+  if (text.length <= limit) return text;
+  return limit === 1 ? "…" : `${text.slice(0, limit - 1)}…`;
+}
+
+function sessionPickerLine(session, index, selected, columns) {
+  const marker = index === selected ? `${CYAN}›${RESET}` : " ";
+  const updated = String(session.updated_at || "").slice(0, 19).replace("T", " ");
+  const title = truncateTerminalText(sessionPreview(session, 1000), Math.max(1, columns - updated.length - 4));
+  const color = index === selected ? BOLD : DIM;
+  return `${marker} ${color}${title}${RESET}  ${DIM}${updated}${RESET}`;
+}
+
+function extractCommands(text) {
+  return [...text.matchAll(/```(?:bash|sh|shell)[^\n]*\n([\s\S]*?)```/gi)]
+    .map((match) => match[1].trim())
+    .filter(Boolean);
+}
+
+function formatCommandFeedback(results) {
+  const parts = ["Kết quả các lệnh đã chạy:"];
+  for (const [command, code, output] of results) {
+    if (code === null) {
+      parts.push(`\n$ ${command}\n(người dùng bỏ qua, không chạy)`);
+      continue;
+    }
+    let clipped = output.slice(0, OUTPUT_TRUNCATE);
+    if (output.length > OUTPUT_TRUNCATE) clipped += "\n...(cắt bớt output)";
+    parts.push(`\n$ ${command}\nexit=${code}\n${clipped || "(không có output)"}`);
+  }
+  return parts.join("\n");
+}
+
+function matchingCommands(prefix) {
+  return COMMAND_SUGGESTIONS.filter(([command]) => command.startsWith(prefix.toLowerCase()));
+}
+
+function parseSseEvent(event, state, onDelta) {
+  if (event.response_message_id != null) state.parentMessageId = event.response_message_id;
+  const path = event.p;
+  const value = event.v;
+  if (value && typeof value === "object" && value.response && typeof value.response === "object") {
+    const response = value.response;
+    if (response.message_id != null) state.parentMessageId = response.message_id;
+    state.fragmentTypes = (response.fragments || []).map((fragment) => fragment.type);
+    for (const fragment of response.fragments || []) {
+      if (fragment.type === "RESPONSE" && typeof fragment.content === "string") onDelta(fragment.content);
+    }
+    state.activeFragmentType = state.fragmentTypes.at(-1) || null;
+    return;
+  }
+  if (path === "response/content") state.activeFragmentType = "RESPONSE";
+  else if (typeof path === "string" && /^response\/fragments\/\d+\/content$/.test(path)) {
+    state.activeFragmentType = state.fragmentTypes[Number(path.split("/")[2])] || null;
+  } else if (typeof path === "string" && path.includes("thinking_content")) state.activeFragmentType = "THINK";
+  else if (path != null) return;
+  if (state.activeFragmentType === "RESPONSE" && typeof value === "string") onDelta(value);
+}
+
+class SessionStore {
+  constructor(
+    sessionDir = SESSION_DIR,
+    legacySessionPaths = [FLAT_SESSION_PATH, LEGACY_SESSION_PATH],
+    archiveLegacyPaths = [FLAT_SESSION_PATH],
+  ) {
+    this.sessionDir = sessionDir;
+    this.legacySessionPaths = legacySessionPaths;
+    this.archiveLegacyPaths = new Set(archiveLegacyPaths);
+  }
+
+  load() {
+    this.migrateLegacySessions();
+    if (!existsSync(this.sessionDir)) return [];
+    const sessions = [];
+    for (const path of this.sessionFiles(this.sessionDir)) {
+      const session = readJson(path, null);
+      if (session && typeof session === "object" && !Array.isArray(session)) sessions.push(session);
+    }
+    return sessions.sort((left, right) => String(right.updated_at || "").localeCompare(String(left.updated_at || "")));
+  }
+
+  save(sessions) {
+    if (!Array.isArray(sessions)) throw new Error("Lịch sử phiên không có định dạng danh sách");
+    for (const session of sessions) saveJson(this.sessionPath(session), session);
+  }
+
+  sessionPath(session) {
+    const timestamp = new Date(session.created_at || session.updated_at || nowIso());
+    const date = Number.isNaN(timestamp.getTime()) ? new Date() : timestamp;
+    const year = String(date.getUTCFullYear());
+    const month = String(date.getUTCMonth() + 1).padStart(2, "0");
+    const day = String(date.getUTCDate()).padStart(2, "0");
+    const clock = date.toISOString().replace(/\.\d{3}Z$/, "").replace(/:/g, "-");
+    const id = String(session.id || randomUUID()).replace(/[^a-zA-Z0-9-]/g, "_");
+    return join(this.sessionDir, year, month, day, `session-${clock}-${id}.json`);
+  }
+
+  sessionFiles(directory) {
+    const files = [];
+    for (const entry of readdirSync(directory, { withFileTypes: true })) {
+      const path = join(directory, entry.name);
+      if (entry.isDirectory()) files.push(...this.sessionFiles(path));
+      else if (entry.isFile() && entry.name.endsWith(".json")) files.push(path);
+    }
+    return files;
+  }
+
+  migrateLegacySessions() {
+    for (const legacyPath of this.legacySessionPaths) {
+      if (!existsSync(legacyPath)) continue;
+      const sessions = readJson(legacyPath, null);
+      if (!Array.isArray(sessions)) continue;
+      for (const session of sessions) {
+        if (session && typeof session === "object") {
+          const target = this.sessionPath(session);
+          if (!existsSync(target)) saveJson(target, session);
+        }
+      }
+      if (this.archiveLegacyPaths.has(legacyPath)) {
+        renameSync(legacyPath, `${legacyPath}.migrated`);
+      }
+    }
+  }
+}
+
+class RawReader {
+  constructor(stream = process.stdin) {
+    this.stream = stream;
+    this.queue = [];
+    this.waiter = null;
+    this.onData = (chunk) => {
+      const text = String(chunk);
+      if (this.waiter) {
+        const resolve = this.waiter;
+        this.waiter = null;
+        resolve(text);
+      } else this.queue.push(text);
+    };
+  }
+
+  open() {
+    this.stream.setEncoding("utf8");
+    this.stream.setRawMode?.(true);
+    this.stream.resume();
+    this.stream.on("data", this.onData);
+  }
+
+  close() {
+    this.stream.off("data", this.onData);
+    this.stream.setRawMode?.(false);
+  }
+
+  next(timeout) {
+    if (this.queue.length) return Promise.resolve(this.queue.shift());
+    return new Promise((resolve) => {
+      let timer;
+      this.waiter = (value) => {
+        if (timer) clearTimeout(timer);
+        resolve(value);
+      };
+      if (timeout != null) {
+        timer = setTimeout(() => {
+          if (this.waiter) this.waiter = null;
+          resolve(null);
+        }, timeout);
+      }
+    });
+  }
+}
+
+class TerminalUI {
+  write(text) {
+    process.stdout.write(text);
+  }
+
+  header(session) {
+    console.log(`${BOLD}${BLUE}DeepSeek${RESET} ${DIM}· ${sessionPreview(session, 32)} · /help${RESET}`);
+    console.log(`${DIM}${"─".repeat(48)}${RESET}`);
+  }
+
+  clear(session) {
+    this.write("\x1b[3J\x1b[2J\x1b[H");
+    this.header(session);
+  }
+
+  notice(message) { console.log(`${DIM}${message}${RESET}`); }
+  error(message) { console.log(`${RED}${message}${RESET}`); }
+  assistantStart() { console.log(`\n${BOLD}${GREEN}DeepSeek${RESET}`); }
+  stream(fragment) { this.write(fragment); }
+
+  help() {
+    console.log([
+      `${BOLD}Lệnh${RESET}`,
+      `  ${CYAN}/login${RESET}    Mở trang đăng nhập DeepSeek`,
+      `  ${CYAN}/logout${RESET}   Xóa token DeepSeek đã lưu`,
+      `  ${CYAN}/new${RESET}      Tạo phiên mới`,
+      `  ${CYAN}/resume${RESET}   Chọn phiên đã lưu để tiếp tục`,
+      `  ${CYAN}/agent${RESET}    Bật/tắt chế độ chạy lệnh terminal`,
+      `  ${CYAN}/clear${RESET}    Xóa nội dung khỏi màn hình`,
+      `  ${CYAN}/help${RESET}     Hiện trợ giúp`,
+      `  ${CYAN}/exit${RESET}     Đóng CLI`,
+      `${DIM}Khi bật terminal: DeepSeek đề xuất lệnh, bạn xác nhận [Enter]/s/a/q rồi nó tự đọc kết quả.${RESET}`,
+      `${DIM}Ctrl+C hủy phản hồi đang chạy và đóng CLI.${RESET}`,
+    ].join("\n"));
+  }
+
+  showCommandSuggestions(prefix) {
+    const suggestions = matchingCommands(prefix).map(([command, description]) =>
+      `  ${CYAN}${command.slice(0, prefix.length)}${RESET}${DIM}${command.slice(prefix.length)}${RESET}  ${DIM}${description}${RESET}`,
+    );
+    this.write(`\x1b[s\n\x1b[J${suggestions.join("\n")}\x1b[u`);
+  }
+
+  clearCommandSuggestions() { this.write("\x1b[J"); }
+
+  completeCommand(characters) {
+    const prefix = characters.join("");
+    const matches = matchingCommands(prefix);
+    if (matches.length !== 1 || matches[0][0] === prefix.toLowerCase()) return false;
+    const suffix = matches[0][0].slice(prefix.length);
+    characters.push(...suffix);
+    this.write(`${DIM}${suffix}${RESET}`);
+    this.clearCommandSuggestions();
+    return true;
+  }
+
+  async readPrompt() {
+    if (!process.stdin.isTTY) {
+      const iterator = process.stdin[Symbol.asyncIterator]();
+      const first = await iterator.next();
+      return first.done ? "" : String(first.value).trim();
+    }
+    this.write(`\n${CYAN}› ${RESET}`);
+    const reader = new RawReader();
+    const characters = [];
+    let pending = null;
+    reader.open();
+    try {
+      while (true) {
+        const chunk = pending ?? await reader.next();
+        pending = null;
+        for (let index = 0; index < chunk.length; index += 1) {
+          const character = chunk[index];
+          if (character === "\u0003") throw new UserInterrupted();
+          if (character === "\r" || character === "\n") {
+            if (characters[0] === "/" && !characters.includes("\n") && this.completeCommand(characters)) continue;
+            if (characters[0] === "/") this.clearCommandSuggestions();
+            if (index === chunk.length - 1) {
+              const next = await reader.next(120);
+              if (next == null) {
+                this.write("\n");
+                return characters.join("").trim();
+              }
+              pending = next;
+            }
+            characters.push("\n");
+            this.write("\n");
+            continue;
+          }
+          if (character === "\u007f" || character === "\b") {
+            if (characters.length) {
+              characters.pop();
+              this.write("\b \b");
+            }
+            if (characters[0] === "/" && !characters.includes("\n")) this.showCommandSuggestions(characters.join(""));
+            else if (!characters.length) this.clearCommandSuggestions();
+            continue;
+          }
+          if (character === "\u001b") {
+            while (index + 1 < chunk.length && !/[A-Za-z~]/.test(chunk[index + 1])) index += 1;
+            continue;
+          }
+          if (character >= " ") {
+            characters.push(character);
+            this.write(character);
+            if (characters[0] === "/" && !characters.includes("\n")) this.showCommandSuggestions(characters.join(""));
+          }
+        }
+      }
+    } finally {
+      reader.close();
+    }
+  }
+
+  async readKey() {
+    const reader = new RawReader();
+    reader.open();
+    try {
+      const key = await reader.next();
+      if (key === "\u0003") throw new UserInterrupted();
+      if (key === "\r" || key === "\n") return "ENTER";
+      if (key === "\u001b[A") return "UP";
+      if (key === "\u001b[B") return "DOWN";
+      if (key.startsWith("\u001b")) return "ESC";
+      return key[0] || "";
+    } finally {
+      reader.close();
+    }
+  }
+
+  async confirmCommand(command) {
+    this.write(`\n${BOLD}${YELLOW}⚙ Lệnh đề xuất:${RESET}\n`);
+    for (const line of command.split("\n")) this.write(`  ${CYAN}${line}${RESET}\n`);
+    this.write(`${DIM}[Enter]=chạy  [s]=bỏ qua  [a]=chạy hết  [q]=dừng${RESET} `);
+    if (!process.stdin.isTTY) return "run";
+    const key = await this.readKey();
+    this.write("\n");
+    if (key === "ENTER") return "run";
+    if (key.toLowerCase() === "s") return "skip";
+    if (key.toLowerCase() === "a") return "all";
+    if (key.toLowerCase() === "q") return "quit";
+    return "run";
+  }
+
+  showCommandResult(code, output) {
+    this.write(`${code === 0 ? GREEN : RED}exit=${code}${RESET}\n`);
+    for (const line of output.split("\n")) if (line) this.write(`${DIM}│${RESET} ${line}\n`);
+  }
+
+  renderTranscript(messages) {
+    for (const message of messages) {
+      if (message.role === "user") this.write(`\n${BOLD}${CYAN}Bạn${RESET}\n${message.content}\n`);
+      if (message.role === "assistant") this.write(`\n${BOLD}${GREEN}DeepSeek${RESET}\n${message.content}\n`);
+    }
+  }
+
+  async selectSession(sessions) {
+    if (!sessions.length) {
+      this.notice("Chưa có phiên nào được lưu.");
+      return null;
+    }
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+      sessions.forEach((session, index) => console.log(`${index + 1}. ${sessionPreview(session)}`));
+      const answer = await readline.createInterface({ input: process.stdin, output: process.stdout }).question("Chọn phiên (Enter để hủy): ");
+      const index = Number(answer) - 1;
+      return Number.isInteger(index) && sessions[index] ? sessions[index] : null;
+    }
+    let selected = 0;
+    while (true) {
+      const columns = process.stdout.columns || 80;
+      const visibleRows = Math.max(1, (process.stdout.rows || 24) - 4);
+      const first = Math.min(Math.max(0, selected - visibleRows + 1), Math.max(0, sessions.length - visibleRows));
+      this.write("\x1b[2J\x1b[H");
+      console.log(`${BOLD}${BLUE}Tiếp tục phiên${RESET}`);
+      console.log(`${DIM}↑ ↓ để chọn · Enter để mở · Esc để hủy${RESET}\n`);
+      for (let index = first; index < Math.min(first + visibleRows, sessions.length); index += 1) {
+        console.log(sessionPickerLine(sessions[index], index, selected, columns));
+      }
+      const key = await this.readKey();
+      if (key === "ENTER") return sessions[selected];
+      if (key === "ESC") return null;
+      if (key === "UP") selected = (selected - 1 + sessions.length) % sessions.length;
+      if (key === "DOWN") selected = (selected + 1) % sessions.length;
+      if (/^[1-9]$/.test(key) && Number(key) <= sessions.length) selected = Number(key) - 1;
+    }
+  }
+}
+
+class DeepSeekCLI {
+  constructor(store = new SessionStore(), runtimeData = RUNTIME_DATA) {
+    this.runtimeData = runtimeData;
+    this.token = resolveToken(runtimeData);
+    this.openUrl = (url) => execFileAsync("termux-open-url", [url]);
+    this.store = store;
+    this.ui = new TerminalUI();
+    this.sessionId = null;
+    this.parentMessageId = null;
+    this.persistenceError = null;
+    try { this.savedSessions = this.store.load(); }
+    catch (error) { this.savedSessions = []; this.persistenceError = error.message; }
+    this.activeSession = newLocalSession();
+    this.agentEnabled = true;
+    this.agentPrimed = false;
+    this.agentCwd = process.cwd();
+    this.abortController = null;
+    this.interrupted = false;
+  }
+
+  headers(extra = {}) {
+    return {
+      Authorization: `Bearer ${this.token}`,
+      "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/120.0.0.0",
+      "Content-Type": "application/json",
+      Referer: "https://chat.deepseek.com/",
+      Origin: "https://chat.deepseek.com",
+      Accept: "application/json, text/plain, */*",
+      "x-client-locale": "en_US",
+      "x-client-platform": "web",
+      "x-client-version": "2.0.2",
+      ...extra,
+    };
+  }
+
+  apiMessage(payload) {
+    return payload?.data?.biz_msg || payload?.msg || "Phản hồi API không hợp lệ";
+  }
+
+  async fetch(path, options = {}, timeout = 30_000) {
+    const controller = new AbortController();
+    this.abortController = controller;
+    const timer = setTimeout(() => controller.abort(), timeout);
+    try {
+      return await globalThis.fetch(`${BASE_URL}${path}`, { ...options, signal: controller.signal });
+    } catch (error) {
+      if (error.name === "AbortError" && this.interrupted) throw new UserInterrupted();
+      throw error;
+    } finally {
+      clearTimeout(timer);
+      this.abortController = null;
+    }
+  }
+
+  async createSession() {
+    const response = await this.fetch("/chat_session/create", { method: "POST", headers: this.headers(), body: "{}" });
+    const payload = await response.json();
+    if (!response.ok || payload.code !== 0 || ![null, undefined, 0].includes(payload.data?.biz_code)) throw new Error(this.apiMessage(payload));
+    const sessionId = payload.data?.biz_data?.chat_session?.id;
+    if (!sessionId) throw new Error("API không trả về chat_session.id");
+    this.sessionId = sessionId;
+    this.parentMessageId = null;
+  }
+
+  async getPowResponse() {
+    const response = await this.fetch("/chat/create_pow_challenge", { method: "POST", headers: this.headers(), body: JSON.stringify({ target_path: "/api/v0/chat/completion" }) });
+    const payload = await response.json();
+    const challenge = payload.data?.biz_data?.challenge;
+    if (!response.ok || payload.code !== 0 || ![null, undefined, 0].includes(payload.data?.biz_code) || !challenge) throw new Error(this.apiMessage(payload));
+    const solver = join(APP_DIR, "deepseek_pow_solver.js");
+    const wasm = join(APP_DIR, "sha3_wasm_bg.7b9ca65ddd.wasm");
+    if (!existsSync(solver) || !existsSync(wasm)) throw new Error("Thiếu deepseek_pow_solver.js hoặc sha3_wasm_bg.7b9ca65ddd.wasm");
+    const { stdout } = await execFileAsync(process.execPath, [solver, JSON.stringify(challenge)], { timeout: 30_000 });
+    if (!stdout.trim()) throw new Error("PoW solver không trả về kết quả");
+    return stdout.trim();
+  }
+
+  async parseSse(response, onDelta) {
+    const decoder = new TextDecoder();
+    const state = { parentMessageId: this.parentMessageId, fragmentTypes: [], activeFragmentType: null };
+    const content = [];
+    let buffered = "";
+    const append = (fragment) => { content.push(fragment); onDelta?.(fragment); };
+    for await (const chunk of response.body) {
+      buffered += decoder.decode(chunk, { stream: true });
+      const lines = buffered.split(/\r?\n/);
+      buffered = lines.pop();
+      for (const line of lines) {
+        if (!line.startsWith("data:")) continue;
+        const raw = line.slice(5).trimStart();
+        if (!raw || raw === "[DONE]") continue;
+        try { parseSseEvent(JSON.parse(raw), state, append); } catch {}
+      }
+    }
+    this.parentMessageId = state.parentMessageId;
+    return content.join("");
+  }
+
+  async ask(prompt, onDelta) {
+    try {
+      if (!this.token) return "Thiếu DEEPSEEK_TOKEN.";
+      if (!this.sessionId) await this.createSession();
+      for (let attempt = 0; attempt < 2; attempt += 1) {
+        const pow = await this.getPowResponse();
+        const response = await this.fetch("/chat/completion", {
+          method: "POST",
+          headers: this.headers({ Referer: `https://chat.deepseek.com/a/chat/s/${this.sessionId}`, "x-ds-pow-response": pow }),
+          body: JSON.stringify({ prompt, chat_session_id: this.sessionId, parent_message_id: this.parentMessageId, thinking_enabled: false, search_enabled: false, ref_file_ids: [], model_type: "default" }),
+        }, 120_000);
+        if (response.status === 200 && response.headers.get("content-type")?.includes("text/event-stream")) {
+          return (await this.parseSse(response, onDelta)) || "Lỗi: API không trả về nội dung";
+        }
+        if (response.status === 401) return "Token hết hạn.";
+        if (response.status === 429) return "Đã chạm giới hạn yêu cầu.";
+        const text = await response.text();
+        let payload;
+        try { payload = JSON.parse(text); } catch { return `Lỗi ${response.status}: ${text.slice(0, 200)}`; }
+        const bizCode = payload.data?.biz_code;
+        if (bizCode === 26 && attempt === 0) { this.parentMessageId = null; continue; }
+        if (!response.ok || payload.code !== 0 || ![null, undefined, 0].includes(bizCode)) return `Lỗi API ${bizCode ?? payload.code}: ${this.apiMessage(payload)}`;
+        return payload.content || payload.message || JSON.stringify(payload);
+      }
+    } catch (error) {
+      if (error instanceof UserInterrupted) throw error;
+      return `Lỗi: ${String(error.message || error).slice(0, 300)}`;
+    }
+  }
+
+  persistActiveSession() {
+    if (this.persistenceError) return;
+    Object.assign(this.activeSession, { chat_session_id: this.sessionId, parent_message_id: this.parentMessageId, updated_at: nowIso() });
+    const index = this.savedSessions.findIndex((session) => session.id === this.activeSession.id);
+    if (index >= 0) this.savedSessions[index] = this.activeSession;
+    else this.savedSessions.push(this.activeSession);
+    this.savedSessions.sort((left, right) => String(right.updated_at).localeCompare(String(left.updated_at)));
+    this.store.save(this.savedSessions);
+  }
+
+  async runCommand(command) {
+    const wrapped = `${command}\n__dsk_rc=$?\nprintf '\\n%s%s\\n' '${CWD_SENTINEL}' "$PWD"\nexit $__dsk_rc`;
+    try {
+      const { stdout, stderr } = await execFileAsync("bash", ["-c", wrapped], { cwd: this.agentCwd, timeout: COMMAND_TIMEOUT, maxBuffer: 1_048_576 });
+      return this.commandResult(0, stdout, stderr);
+    } catch (error) {
+      if (error.killed) return [124, `Lệnh vượt quá ${COMMAND_TIMEOUT / 1000}s và bị hủy.`];
+      return this.commandResult(Number.isInteger(error.code) ? error.code : 1, error.stdout || "", error.stderr || error.message || "");
+    }
+  }
+
+  commandResult(code, stdout, stderr) {
+    const kept = [];
+    for (const line of String(stdout).split("\n")) {
+      if (line.startsWith(CWD_SENTINEL)) {
+        const cwd = line.slice(CWD_SENTINEL.length);
+        if (cwd && existsSync(cwd)) this.agentCwd = cwd;
+      } else kept.push(line);
+    }
+    let output = kept.join("\n").replace(/^\n+|\n+$/g, "");
+    if (stderr) output = output ? `${output}\n${stderr}` : stderr;
+    return [code, output.replace(/\n+$/, "")];
+  }
+
+  newSession() {
+    this.activeSession = newLocalSession();
+    this.sessionId = null;
+    this.parentMessageId = null;
+    this.agentPrimed = false;
+  }
+
+  async login() {
+    try {
+      await this.openUrl(LOGIN_URL);
+      this.ui.notice("Đã mở trang đăng nhập DeepSeek.");
+    } catch (error) {
+      this.ui.error(`Không mở được trang đăng nhập: ${error.message || error}`);
+    }
+  }
+
+  logout() {
+    delete this.runtimeData.auth.token;
+    saveJson(this.runtimeData.authPath, this.runtimeData.auth);
+    this.token = "";
+    this.sessionId = null;
+    this.parentMessageId = null;
+    this.agentPrimed = false;
+    this.ui.notice("Đã đăng xuất khỏi CLI.");
+  }
+
+  async resumeSession() {
+    const session = await this.ui.selectSession(this.savedSessions);
+    if (!session) { this.ui.clear(this.activeSession); return; }
+    this.activeSession = session;
+    this.sessionId = session.chat_session_id;
+    this.parentMessageId = session.parent_message_id;
+    this.agentPrimed = false;
+    this.ui.clear(this.activeSession);
+    this.ui.renderTranscript(session.messages || []);
+    this.ui.notice("Đã tiếp tục phiên đã chọn.");
+  }
+
+  async handleCommand(prompt) {
+    const command = prompt.toLowerCase();
+    if (["/exit", "exit", "quit", "q"].includes(command)) return false;
+    if (command === "/login") await this.login();
+    else if (command === "/logout") this.logout();
+    else if (command === "/help") { this.ui.clear(this.activeSession); this.ui.help(); }
+    else if (command === "/clear") this.ui.clear(this.activeSession);
+    else if (command === "/new") { this.newSession(); this.ui.clear(this.activeSession); this.ui.notice("Đã tạo phiên mới."); }
+    else if (command === "/resume") await this.resumeSession();
+    else if (command === "/agent") { this.agentEnabled = !this.agentEnabled; this.ui.notice(`Chế độ terminal: ${this.agentEnabled ? "bật" : "tắt"}`); }
+    else if (command.startsWith("/")) this.ui.error("Lệnh không hợp lệ. Dùng /help để xem danh sách lệnh.");
+    else return null;
+    return true;
+  }
+
+  async sendPrompt(prompt) {
+    this.activeSession.messages.push({ role: "user", content: prompt, created_at: nowIso() });
+    if (this.activeSession.title === "Phiên mới") this.activeSession.title = sessionPreview({ title: prompt });
+    this.persistActiveSession();
+    let sendText = prompt;
+    if (this.agentEnabled && !this.agentPrimed) { sendText = `${AGENT_PREAMBLE}\n\n${prompt}`; this.agentPrimed = true; }
+    for (let step = 0; step < MAX_AGENT_STEPS; step += 1) {
+      let streamed = false;
+      this.ui.assistantStart();
+      const reply = await this.ask(sendText, (fragment) => { streamed = true; this.ui.stream(fragment); });
+      if (streamed) console.log(); else console.log(reply);
+      this.activeSession.messages.push({ role: "assistant", content: reply, created_at: nowIso() });
+      this.persistActiveSession();
+      if (!this.agentEnabled) return;
+      const commands = extractCommands(reply);
+      if (!commands.length) return;
+      let runAll = false;
+      let stopped = false;
+      const results = [];
+      for (const command of commands) {
+        const choice = runAll ? "run" : await this.ui.confirmCommand(command);
+        if (choice === "quit") { stopped = true; break; }
+        if (choice === "skip") { results.push([command, null, ""]); continue; }
+        if (choice === "all") runAll = true;
+        const [code, output] = await this.runCommand(command);
+        this.ui.showCommandResult(code, output);
+        results.push([command, code, output]);
+      }
+      if (stopped || !results.some(([, code]) => code !== null)) return;
+      sendText = formatCommandFeedback(results);
+    }
+    this.ui.notice(`Đã đạt giới hạn ${MAX_AGENT_STEPS} bước agent, dừng.`);
+  }
+
+  async run() {
+    this.newSession();
+    this.ui.clear(this.activeSession);
+    if (this.persistenceError) this.ui.error(`Không thể dùng lịch sử: ${this.persistenceError}`);
+    const onSigint = () => {
+      this.interrupted = true;
+      this.abortController?.abort();
+    };
+    process.on("SIGINT", onSigint);
+    try {
+      while (true) {
+        try {
+          const prompt = await this.ui.readPrompt();
+          if (!prompt) continue;
+          const handled = await this.handleCommand(prompt);
+          if (handled === false) break;
+          if (handled === true) continue;
+          await this.sendPrompt(prompt);
+        } catch (error) {
+          if (error instanceof UserInterrupted) break;
+          this.ui.error(`Lỗi: ${error.message || error}`);
+        }
+      }
+    } finally {
+      process.off("SIGINT", onSigint);
+      console.log(`\n${DIM}Đã đóng DeepSeek CLI.${RESET}`);
+    }
+  }
+}
+
+async function main(argv = process.argv.slice(2)) {
+  const promptIndex = argv.findIndex((value) => value === "-p" || value === "--prompt");
+  const cli = new DeepSeekCLI();
+  if (promptIndex >= 0) {
+    console.log(await cli.ask(argv[promptIndex + 1] || ""));
+    return;
+  }
+  await cli.run();
+}
+
+module.exports = { DATA_DIR, DeepSeekCLI, RUNTIME_DATA, SessionStore, bootstrapDataDirectory, extractCommands, formatCommandFeedback, main, matchingCommands, newLocalSession, parseSseEvent, sessionPickerLine };
+
+if (require.main === module) {
+  main().catch((error) => {
+    process.stderr.write(`Lỗi: ${error.message || error}\n`);
+    process.exitCode = 1;
+  });
+}

package/deepseek_pow_solver.js

@@ -0,0 +1,74 @@
+const fs = require("fs");
+const path = require("path");
+
+let cachedMemory = null;
+let cachedDataView = null;
+
+function uint8Memory(wasm) {
+  if (cachedMemory === null || cachedMemory.buffer !== wasm.memory.buffer) {
+    cachedMemory = new Uint8Array(wasm.memory.buffer);
+  }
+  return cachedMemory;
+}
+
+function dataView(wasm) {
+  if (cachedDataView === null || cachedDataView.buffer !== wasm.memory.buffer) {
+    cachedDataView = new DataView(wasm.memory.buffer);
+  }
+  return cachedDataView;
+}
+
+function writeString(wasm, value) {
+  const encoded = new TextEncoder().encode(value);
+  const pointer = wasm.__wbindgen_export_0(encoded.length, 1) >>> 0;
+  uint8Memory(wasm).set(encoded, pointer);
+  return { pointer, length: encoded.length };
+}
+
+async function main() {
+  const challenge = JSON.parse(process.argv[2]);
+  if (challenge.algorithm !== "DeepSeekHashV1") {
+    throw new Error(`Unsupported PoW algorithm: ${challenge.algorithm}`);
+  }
+
+  const wasmPath = path.join(__dirname, "sha3_wasm_bg.7b9ca65ddd.wasm");
+  const { instance } = await WebAssembly.instantiate(fs.readFileSync(wasmPath), { wbg: {} });
+  const wasm = instance.exports;
+  const prefix = `${challenge.salt}_${challenge.expire_at}_`;
+  const stackPointer = wasm.__wbindgen_add_to_stack_pointer(-16);
+
+  try {
+    const challengeString = writeString(wasm, challenge.challenge);
+    const prefixString = writeString(wasm, prefix);
+    wasm.wasm_solve(
+      stackPointer,
+      challengeString.pointer,
+      challengeString.length,
+      prefixString.pointer,
+      prefixString.length,
+      challenge.difficulty,
+    );
+
+    const status = dataView(wasm).getInt32(stackPointer, true);
+    if (status === 0) {
+      throw new Error("PoW solver không tìm thấy đáp án");
+    }
+
+    const response = {
+      algorithm: challenge.algorithm,
+      challenge: challenge.challenge,
+      salt: challenge.salt,
+      answer: dataView(wasm).getFloat64(stackPointer + 8, true),
+      signature: challenge.signature,
+      target_path: challenge.target_path,
+    };
+    process.stdout.write(Buffer.from(JSON.stringify(response)).toString("base64"));
+  } finally {
+    wasm.__wbindgen_add_to_stack_pointer(16);
+  }
+}
+
+main().catch((error) => {
+  process.stderr.write(error.message);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@rennii/deepseek-cli",
+  "version": "1.0.0",
+  "private": false,
+  "description": "DeepSeek terminal client for Termux",
+  "type": "commonjs",
+  "bin": {
+    "deepseek": "deepseek-cli.js"
+  },
+  "scripts": {
+    "start": "node deepseek-cli.js",
+    "check": "node --check deepseek-cli.js",
+    "test": "node --test test-deepseek-cli.js"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rennii11/deepseek-cli.git"
+  }
+}

package/test-deepseek-cli.js

@@ -0,0 +1,117 @@
+"use strict";
+
+const assert = require("node:assert/strict");
+const { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } = require("node:fs");
+const { tmpdir } = require("node:os");
+const { join } = require("node:path");
+const test = require("node:test");
+const {
+  SessionStore,
+  DeepSeekCLI,
+  extractCommands,
+  formatCommandFeedback,
+  bootstrapDataDirectory,
+  matchingCommands,
+  newLocalSession,
+  parseSseEvent,
+  sessionPickerLine,
+} = require("./deepseek-cli");
+
+test("filters slash commands by typed prefix", () => {
+  assert.deepEqual(matchingCommands("/res").map(([command]) => command), ["/resume"]);
+});
+
+test("login opens the official DeepSeek page", async () => {
+  const directory = mkdtempSync(join(tmpdir(), "deepseek-cli-"));
+  try {
+    const runtimeData = { config: {}, configPath: join(directory, "config.json"), auth: {}, authPath: join(directory, "auth.json") };
+    const cli = new DeepSeekCLI(new SessionStore(join(directory, "sessions"), []), runtimeData);
+    let openedUrl;
+    cli.openUrl = async (url) => { openedUrl = url; };
+    cli.ui = { notice() {}, error() {} };
+    await cli.login();
+    assert.equal(openedUrl, "https://chat.deepseek.com/");
+  } finally {
+    rmSync(directory, { recursive: true, force: true });
+  }
+});
+
+test("logout removes only the saved CLI auth token", () => {
+  const directory = mkdtempSync(join(tmpdir(), "deepseek-cli-"));
+  try {
+    const authPath = join(directory, "auth.json");
+    const runtimeData = { config: { setting: true }, configPath: join(directory, "config.json"), auth: { token: "stored-token" }, authPath };
+    const cli = new DeepSeekCLI(new SessionStore(join(directory, "sessions"), []), runtimeData);
+    cli.ui = { notice() {} };
+    cli.logout();
+    assert.equal(cli.token, "");
+    assert.deepEqual(JSON.parse(readFileSync(authPath, "utf8")), {});
+  } finally {
+    rmSync(directory, { recursive: true, force: true });
+  }
+});
+
+test("migrates a legacy config token into auth.json", () => {
+  const directory = mkdtempSync(join(tmpdir(), "deepseek-cli-"));
+  try {
+    const configPath = join(directory, "config.json");
+    writeFileSync(configPath, '{"token":"legacy-token","setting":true}\n');
+    const data = bootstrapDataDirectory({ dataDir: directory, legacySessionPath: join(directory, "legacy-sessions.json") });
+    assert.deepEqual(JSON.parse(readFileSync(data.authPath, "utf8")), { token: "legacy-token" });
+    assert.deepEqual(JSON.parse(readFileSync(data.configPath, "utf8")), { setting: true });
+  } finally {
+    rmSync(directory, { recursive: true, force: true });
+  }
+});
+
+test("extracts terminal commands and formats their output", () => {
+  assert.deepEqual(extractCommands("```bash\npwd\n```"), ["pwd"]);
+  assert.match(formatCommandFeedback([["pwd", 0, "/tmp"]]), /exit=0/);
+});
+
+test("persists a local session", () => {
+  const directory = mkdtempSync(join(tmpdir(), "deepseek-cli-"));
+  try {
+    const store = new SessionStore(join(directory, "sessions"), []);
+    const session = newLocalSession();
+    session.created_at = "2026-08-30T19:45:10.000Z";
+    session.title = "Kiểm tra phiên";
+    store.save([session]);
+    assert.equal(store.load()[0].title, "Kiểm tra phiên");
+    assert.match(store.sessionPath(session), /sessions\/2026\/08\/30\/session-2026-08-30T19-45-10-/);
+  } finally {
+    rmSync(directory, { recursive: true, force: true });
+  }
+});
+
+test("migrates flat session history into one file per dated session", () => {
+  const directory = mkdtempSync(join(tmpdir(), "deepseek-cli-"));
+  try {
+    const flatPath = join(directory, "sessions.json");
+    writeFileSync(flatPath, '[{"id":"legacy","created_at":"2026-08-30T19:45:10.000Z","updated_at":"2026-08-30T19:45:10.000Z"}]\n');
+    const store = new SessionStore(join(directory, "sessions"), [flatPath], [flatPath]);
+    const sessions = store.load();
+    const perSessionFile = store.sessionPath(sessions[0]);
+    assert.equal(sessions[0].id, "legacy");
+    assert.deepEqual(JSON.parse(readFileSync(perSessionFile, "utf8")).id, "legacy");
+    assert.ok(existsSync(`${flatPath}.migrated`));
+  } finally {
+    rmSync(directory, { recursive: true, force: true });
+  }
+});
+
+test("parses SSE response fragments and tracks parent message", () => {
+  const state = { parentMessageId: null, fragmentTypes: [], activeFragmentType: null };
+  const received = [];
+  parseSseEvent({ response_message_id: "parent", p: "response/content", v: "Xin chào" }, state, (fragment) => received.push(fragment));
+  assert.equal(state.parentMessageId, "parent");
+  assert.deepEqual(received, ["Xin chào"]);
+});
+
+test("session picker lines do not overflow the terminal", () => {
+  const session = newLocalSession();
+  session.title = "Chạy lệnh in ra đúng chữ DEEPSEEK_AGENT_OK rồi cho tôi biết";
+  session.updated_at = "2026-08-30T19:37:17+00:00";
+  const line = sessionPickerLine(session, 0, 0, 40).replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "");
+  assert.ok(line.length <= 40);
+});