jinzd-ai-cli 0.4.307 → 0.4.309

package/dist/{chunk-RYQBBEMM.js → chunk-4PR5AVJ5.js}

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 import {
   atomicWriteFileSync
-} from "./chunk-IW3Q7AE5.js";
+} from "./chunk-BMLQPSHP.js";
 
 // src/web/auth.ts
-import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, copyFileSync } from "fs";
+import { existsSync, readFileSync, mkdirSync, readdirSync, openSync, closeSync, unlinkSync } from "fs";
 import { isAbsolute, join, relative } from "path";
-import { createHmac, randomBytes, timingSafeEqual, pbkdf2Sync } from "crypto";
+import { createHmac, randomBytes, timingSafeEqual, pbkdf2Sync, pbkdf2 } from "crypto";
 var USERS_FILE = "users.json";
 var TOKEN_EXPIRY_HOURS = 24;
 var TOKEN_EXPIRY_MS = TOKEN_EXPIRY_HOURS * 3600 * 1e3;
@@ -21,6 +21,7 @@ var AuthManager = class {
   usersFile;
   baseDir;
   db;
+  loadedRaw;
   constructor(baseDir) {
     this.baseDir = baseDir;
     this.usersFile = join(baseDir, USERS_FILE);
@@ -29,6 +30,7 @@ var AuthManager = class {
   // ── Public API ─────────────────────────────────────────────────
   /** Check if any users exist (first-run detection) */
   hasUsers() {
+    this.refresh();
     return this.db.users.length > 0;
   }
   /** Check if auth is enabled (has users.json with at least 1 user) */
@@ -37,6 +39,18 @@ var AuthManager = class {
   }
   /** Register a new user. Returns error string or null on success. */
   register(username, password) {
+    return this.registerPrepared(username, password);
+  }
+  async registerAsync(username, password) {
+    if (typeof username !== "string" || typeof password !== "string" || password.length > 1024) return "Invalid username or password";
+    if (!/^[a-z0-9_-]{2,32}$/i.test(username.trim()) || password.length < 4) return "Invalid username or password";
+    const salt = randomBytes(16).toString("hex");
+    const hash = await hashPasswordAsync(password, salt);
+    return this.registerPrepared(username, password, { salt, hash });
+  }
+  registerPrepared(username, password, prepared) {
+    this.refresh();
+    if (typeof username !== "string" || typeof password !== "string" || password.length > 1024) return "Invalid username or password";
     username = username.trim().toLowerCase();
     if (!username || username.length < 2 || username.length > 32) {
       return "Username must be 2-32 characters";
@@ -50,11 +64,12 @@ var AuthManager = class {
     if (this.db.users.find((u) => u.username === username)) {
       return "Username already exists";
     }
-    const salt = randomBytes(16).toString("hex");
-    const passwordHash = this.hashPassword(password, salt);
+    const salt = prepared?.salt ?? randomBytes(16).toString("hex");
+    const passwordHash = prepared?.hash ?? this.hashPassword(password, salt);
     const dataDir = join(USERS_DIR, username);
     const fullDataDir = join(this.baseDir, dataDir);
-    mkdirSync(join(fullDataDir, "history"), { recursive: true });
+    mkdirSync(fullDataDir, { recursive: true, mode: 448 });
+    mkdirSync(join(fullDataDir, "history"), { recursive: true, mode: 448 });
     const user = {
       username,
       passwordHash,
@@ -77,6 +92,8 @@ var AuthManager = class {
    * resets the counter.
    */
   login(username, password) {
+    this.refresh();
+    if (!validCredentials(username, password)) return null;
     username = username.trim().toLowerCase();
     const lockState = this.getLockState(username);
     if (lockState.locked) return null;
@@ -100,19 +117,51 @@ var AuthManager = class {
       user.hashVersion = 2;
       this.save();
     }
-    loginAttempts.delete(username);
+    loginAttempts.delete(this.attemptKey(username));
     return this.createToken(username);
   }
   /**
    * Returns current lockout state for a username and lazily expires it.
    * Exposed (read-only) for tests and the `aicli user` CLI status output.
    */
+  async loginAsync(username, password) {
+    this.refresh();
+    if (!validCredentials(username, password)) return null;
+    username = username.trim().toLowerCase();
+    if (this.getLockState(username).locked) return null;
+    const user = this.db.users.find((u) => u.username === username);
+    if (!user) {
+      this.recordFailedLogin(username);
+      return null;
+    }
+    const snapshot = JSON.stringify(user);
+    const legacy = !user.hashVersion || user.hashVersion < 2;
+    const hash = legacy ? this.hashPasswordLegacy(password, user.salt) : await hashPasswordAsync(password, user.salt);
+    const salt = legacy ? randomBytes(16).toString("hex") : user.salt;
+    const upgraded = legacy ? await hashPasswordAsync(password, salt) : hash;
+    this.refresh();
+    const current = this.db.users.find((u) => u.username === username);
+    if (!current || JSON.stringify(current) !== snapshot || this.getLockState(username).locked) return null;
+    const a = Buffer.from(hash), b = Buffer.from(current.passwordHash);
+    if (a.length !== b.length || !timingSafeEqual(a, b)) {
+      this.recordFailedLogin(username);
+      return null;
+    }
+    if (legacy) {
+      current.salt = salt;
+      current.passwordHash = upgraded;
+      current.hashVersion = 2;
+      this.save();
+    }
+    loginAttempts.delete(this.attemptKey(username));
+    return this.createToken(username);
+  }
   getLockState(username) {
     username = username.trim().toLowerCase();
-    const state = loginAttempts.get(username);
+    const state = loginAttempts.get(this.attemptKey(username));
     if (!state) return { locked: false, remainingMs: 0, fails: 0 };
-    if (state.lockedUntil > 0 && Date.now() >= state.lockedUntil) {
-      loginAttempts.delete(username);
+    if (Date.now() >= state.expiresAt) {
+      loginAttempts.delete(this.attemptKey(username));
       return { locked: false, remainingMs: 0, fails: 0 };
     }
     if (state.lockedUntil > 0) {
@@ -120,8 +169,15 @@ var AuthManager = class {
     }
     return { locked: false, remainingMs: 0, fails: state.fails };
   }
+  attemptKey(username) {
+    return this.usersFile + "\0" + username;
+  }
   recordFailedLogin(username) {
-    const state = loginAttempts.get(username) ?? { fails: 0, lockedUntil: 0 };
+    username = this.attemptKey(username);
+    const now = Date.now();
+    for (const [key, value] of loginAttempts) if (value.expiresAt <= now) loginAttempts.delete(key);
+    if (!loginAttempts.has(username) && loginAttempts.size >= 1e4) loginAttempts.delete(loginAttempts.keys().next().value);
+    const state = loginAttempts.get(username) ?? { fails: 0, lockedUntil: 0, expiresAt: now + LOGIN_LOCKOUT_MS };
     state.fails += 1;
     if (state.fails >= LOGIN_MAX_FAILS) {
       state.lockedUntil = Date.now() + LOGIN_LOCKOUT_MS;
@@ -131,6 +187,8 @@ var AuthManager = class {
   /** Verify a token. Returns username or null. */
   verifyToken(token) {
     try {
+      this.refresh();
+      if (typeof token !== "string" || token.length > 4096) return null;
       const parts = token.split(".");
       if (parts.length !== 2) return null;
       const [payloadB64, signature] = parts;
@@ -141,7 +199,7 @@ var AuthManager = class {
       const payload = JSON.parse(
         Buffer.from(payloadB64, "base64url").toString("utf-8")
       );
-      if (Date.now() > payload.exp) return null;
+      if (!Number.isFinite(payload.exp) || Date.now() >= payload.exp) return null;
       const user = this.db.users.find((u) => u.username === payload.username);
       if (!user) return null;
       if (user.tokensRevokedBefore && (!payload.iat || payload.iat < user.tokensRevokedBefore)) {
@@ -158,6 +216,7 @@ var AuthManager = class {
    * v0.4.114). Returns true if the user existed.
    */
   logoutAll(username) {
+    this.refresh();
     username = username.trim().toLowerCase();
     const user = this.db.users.find((u) => u.username === username);
     if (!user) return false;
@@ -167,16 +226,19 @@ var AuthManager = class {
   }
   /** Get user's data directory (absolute path) */
   getUserDataDir(username) {
+    this.refresh();
     const user = this.db.users.find((u) => u.username === username);
     if (!user) throw new Error(`User not found: ${username}`);
     return join(this.baseDir, user.dataDir);
   }
   /** List all usernames */
   listUsers() {
+    this.refresh();
     return this.db.users.map((u) => u.username);
   }
   /** Delete a user. Returns error string or null on success. */
   deleteUser(username) {
+    this.refresh();
     username = username.trim().toLowerCase();
     const idx = this.db.users.findIndex((u) => u.username === username);
     if (idx === -1) return `User '${username}' not found`;
@@ -186,10 +248,11 @@ var AuthManager = class {
   }
   /** Reset a user's password. Returns error string or null on success. */
   resetPassword(username, newPassword) {
+    this.refresh();
     username = username.trim().toLowerCase();
     const user = this.db.users.find((u) => u.username === username);
     if (!user) return `User '${username}' not found`;
-    if (!newPassword || newPassword.length < 4) {
+    if (typeof newPassword !== "string" || newPassword.length > 1024 || newPassword.length < 4) {
       return "Password must be at least 4 characters";
     }
     const salt = randomBytes(16).toString("hex");
@@ -209,7 +272,7 @@ var AuthManager = class {
     if (existsSync(globalConfig)) {
       try {
         const content = readFileSync(globalConfig, "utf-8");
-        writeFileSync(join(userDir, "config.json"), content, "utf-8");
+        atomicWriteFileSync(join(userDir, "config.json"), content, { mode: 384 });
       } catch {
       }
     }
@@ -217,7 +280,7 @@ var AuthManager = class {
     if (existsSync(globalMemory)) {
       try {
         const content = readFileSync(globalMemory, "utf-8");
-        writeFileSync(join(userDir, "memory.md"), content, "utf-8");
+        atomicWriteFileSync(join(userDir, "memory.md"), content, { mode: 384 });
       } catch {
       }
     }
@@ -228,7 +291,7 @@ var AuthManager = class {
         const userHistory = join(userDir, "history");
         for (const f of files) {
           try {
-            copyFileSync(join(globalHistory, f), join(userHistory, f));
+            atomicWriteFileSync(join(userHistory, f), readFileSync(join(globalHistory, f), "utf8"), { mode: 384 });
           } catch {
           }
         }
@@ -238,13 +301,22 @@ var AuthManager = class {
     return null;
   }
   // ── Private methods ────────────────────────────────────────────
+  refresh() {
+    const raw = readFileSync(this.usersFile, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!this.isValidUsersDB(parsed)) throw new Error("Authentication database is invalid; access refused");
+    this.db = parsed;
+    this.loadedRaw = raw;
+  }
   loadOrCreate() {
     if (existsSync(this.usersFile)) {
       try {
-        const parsed = JSON.parse(readFileSync(this.usersFile, "utf-8"));
+        const raw = readFileSync(this.usersFile, "utf-8");
+        const parsed = JSON.parse(raw);
         if (!this.isValidUsersDB(parsed)) {
           throw new Error("database structure is invalid");
         }
+        this.loadedRaw = raw;
         return parsed;
       } catch (err) {
         const detail = err instanceof Error ? err.message : String(err);
@@ -287,8 +359,19 @@ var AuthManager = class {
     this.saveDB(this.db);
   }
   saveDB(db) {
-    mkdirSync(this.baseDir, { recursive: true });
-    atomicWriteFileSync(this.usersFile, JSON.stringify(db, null, 2));
+    mkdirSync(this.baseDir, { recursive: true, mode: 448 });
+    const lock = this.usersFile + ".lock";
+    const fd = openSync(lock, "wx", 384);
+    try {
+      const current = existsSync(this.usersFile) ? readFileSync(this.usersFile, "utf8") : void 0;
+      if (current !== this.loadedRaw) throw new Error("Authentication database changed concurrently; retry the operation");
+      const raw = JSON.stringify(db, null, 2);
+      atomicWriteFileSync(this.usersFile, raw, { mode: 384 });
+      this.loadedRaw = raw;
+    } finally {
+      closeSync(fd);
+      unlinkSync(lock);
+    }
   }
   /** Legacy hash — kept only for migrating old users (v0.2.x) */
   hashPasswordLegacy(password, salt) {
@@ -312,6 +395,19 @@ var AuthManager = class {
     return createHmac("sha256", this.db.secret).update(data).digest("base64url");
   }
 };
+function validCredentials(username, password) {
+  return typeof username === "string" && /^[a-z0-9_-]{2,32}$/i.test(username.trim()) && typeof password === "string" && password.length > 0 && password.length <= 1024;
+}
+var activeHashes = 0;
+async function hashPasswordAsync(password, salt) {
+  if (activeHashes >= 4) throw new Error("Authentication capacity reached; try again later");
+  activeHashes++;
+  try {
+    return await new Promise((resolve, reject) => pbkdf2(password, salt, 1e5, 64, "sha512", (error, hash) => error ? reject(error) : resolve(hash.toString("hex"))));
+  } finally {
+    activeHashes--;
+  }
+}
 
 export {
   TOKEN_EXPIRY_MS,

package/dist/{chunk-GHWZVPUV.js → chunk-6JHACXB3.js}

@@ -6,18 +6,20 @@ import {
 } from "./chunk-KHYD3WXE.js";
 import {
   getIndexMtimeMap
-} from "./chunk-NYNSYLFY.js";
+} from "./chunk-JL44HGZC.js";
 import {
   redactString
 } from "./chunk-3FEZSLGI.js";
 import {
   atomicWriteFileSync
-} from "./chunk-IW3Q7AE5.js";
+} from "./chunk-BMLQPSHP.js";
+import {
+  getExecutionConfigDir
+} from "./chunk-SXIJLSVF.js";
 
 // src/memory/chat-index.ts
 import fs from "fs";
 import path from "path";
-import os from "os";
 import crypto from "crypto";
 var MEMORY_DIR_NAME = "memory-index";
 var CHUNKS_FILE = "chunks.json";
@@ -26,7 +28,7 @@ var VEC_MAGIC = 1094929750;
 var VEC_VERSION = 1;
 var VEC_HEADER_BYTES = 16;
 function memoryIndexDir() {
-  return path.join(os.homedir(), ".aicli", MEMORY_DIR_NAME);
+  return path.join(getExecutionConfigDir(), MEMORY_DIR_NAME);
 }
 function chunksPath() {
   return path.join(memoryIndexDir(), CHUNKS_FILE);
@@ -35,7 +37,7 @@ function vectorsPath() {
   return path.join(memoryIndexDir(), VECTORS_FILE);
 }
 function historyDir() {
-  return path.join(os.homedir(), ".aicli", "history");
+  return path.join(getExecutionConfigDir(), "history");
 }
 var MAX_CHUNK_CHARS = 1200;
 var MIN_CHUNK_CHARS = 40;

package/dist/{chunk-IUVDZVZ4.js → chunk-AXTLYOA7.js}

@@ -6,13 +6,13 @@ import {
   safeDate,
   searchCandidates,
   updateSessionInIndex
-} from "./chunk-NYNSYLFY.js";
+} from "./chunk-JL44HGZC.js";
 import {
   redactJson
 } from "./chunk-3FEZSLGI.js";
 import {
-  atomicWriteFileSync
-} from "./chunk-IW3Q7AE5.js";
+  atomicWriteFile
+} from "./chunk-BMLQPSHP.js";
 
 // src/session/session-manager.ts
 import { readFileSync, existsSync, mkdirSync, readdirSync, unlinkSync, statSync } from "fs";
@@ -616,26 +616,33 @@ var SessionManager = class {
   }
   /** P1-PERF-03: `force` 跳过脏检查（用于进程退出、fork 等必须落盘场景） */
   async save(force = false) {
-    if (!this._current) return;
-    if (this._current.messages.length === 0) return;
-    if (!force && !this._current.dirty) return;
+    const session = this._current;
+    if (!session) return;
+    if (session.messages.length === 0) return;
+    if (!force && !session.dirty) return;
     mkdirSync(this.historyDir, { recursive: true });
-    const filePath = join(this.historyDir, `${this._current.id}.json`);
-    const raw = this._current.toJSON();
+    const filePath = join(this.historyDir, `${session.id}.json`);
+    const raw = session.toJSON();
     const opts = this.redactOptionsForSave();
     const { value: payload, hits } = redactJson(raw, opts);
     this.lastRedactionHits = hits.length;
-    atomicWriteFileSync(filePath, JSON.stringify(payload, null, 2));
-    this._current.dirty = false;
+    const serialized = JSON.stringify(payload, null, 2);
+    session.dirty = false;
+    try {
+      await atomicWriteFile(filePath, serialized, { mode: 384 });
+    } catch (error) {
+      session.dirty = true;
+      throw error;
+    }
     try {
       updateSessionInIndex(this.historyDir, {
-        id: this._current.id,
-        provider: this._current.provider,
-        model: this._current.model,
-        title: this._current.title,
-        messageCount: this._current.messages.length,
-        created: this._current.created,
-        updated: this._current.updated
+        id: session.id,
+        provider: session.provider,
+        model: session.model,
+        title: session.title,
+        messageCount: session.messages.length,
+        created: session.created,
+        updated: session.updated
       }, filePath);
     } catch {
     }

package/dist/{chunk-XJOK5353.js → chunk-B3MPYI4E.js}

@@ -2,12 +2,12 @@
 import {
   loadIndex,
   symbolFingerprint
-} from "./chunk-WQ3OMEC4.js";
+} from "./chunk-M6HLYG33.js";
 import {
   loadVectorStore,
   saveVectorStore,
   searchVectorStore
-} from "./chunk-NRSYBKWA.js";
+} from "./chunk-C7CKDFJS.js";
 import {
   EMBEDDING_DIM,
   embed,

package/dist/chunk-BMLQPSHP.js

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+
+// src/core/atomic-write.ts
+import fs from "fs";
+import { randomUUID } from "crypto";
+import { setTimeout as delay } from "timers/promises";
+function modeFor(target, options) {
+  if (options.mode !== void 0) return options.mode;
+  try {
+    return fs.statSync(target).mode & 511;
+  } catch {
+    return 384;
+  }
+}
+function atomicWriteFileSync(target, data, options = {}) {
+  const tmp = `${target}.${process.pid}.${randomUUID()}.tmp`;
+  try {
+    fs.writeFileSync(tmp, data, { flag: "wx", mode: modeFor(target, options) });
+    fs.renameSync(tmp, target);
+  } finally {
+    try {
+      fs.unlinkSync(tmp);
+    } catch {
+    }
+  }
+}
+var pending = /* @__PURE__ */ new Map();
+async function atomicWriteFile(target, data, options = {}) {
+  const previous = pending.get(target) ?? Promise.resolve();
+  const operation = previous.catch(() => {
+  }).then(async () => {
+    const tmp = `${target}.${process.pid}.${randomUUID()}.tmp`;
+    try {
+      let mode = options.mode ?? 384;
+      if (options.mode === void 0) {
+        try {
+          mode = (await fs.promises.stat(target)).mode & 511;
+        } catch {
+        }
+      }
+      await fs.promises.writeFile(tmp, data, { flag: "wx", mode });
+      for (let attempt = 0; ; attempt++) {
+        try {
+          await fs.promises.rename(tmp, target);
+          break;
+        } catch (error) {
+          if (attempt >= 10 || !["EPERM", "EBUSY", "EACCES"].includes(error.code ?? "")) throw error;
+          await delay(5 * (attempt + 1));
+        }
+      }
+    } finally {
+      try {
+        await fs.promises.unlink(tmp);
+      } catch {
+      }
+    }
+  });
+  pending.set(target, operation);
+  try {
+    await operation;
+  } finally {
+    if (pending.get(target) === operation) pending.delete(target);
+  }
+}
+
+export {
+  atomicWriteFileSync,
+  atomicWriteFile
+};

package/dist/{chunk-NRSYBKWA.js → chunk-C7CKDFJS.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-KHYD3WXE.js";
 import {
   atomicWriteFileSync
-} from "./chunk-IW3Q7AE5.js";
+} from "./chunk-BMLQPSHP.js";
 
 // src/symbols/vector-store.ts
 import fs from "fs";

package/dist/{chunk-SJFZPS65.js → chunk-EAVX3RLD.js}

@@ -1,5 +1,5 @@
 // src/core/constants.ts
-var VERSION = "0.4.307";
+var VERSION = "0.4.309";
 var APP_NAME = "ai-cli";
 var CONFIG_DIR_NAME = ".aicli";
 var CONFIG_FILE_NAME = "config.json";

package/dist/{chunk-VXEF2SWG.js → chunk-EHMMBIZT.js}

@@ -3,7 +3,7 @@ import {
   detectsHallucinatedFileOp,
   parseToolCallArguments,
   schemaToJsonSchema
-} from "./chunk-MI4SFZGX.js";
+} from "./chunk-RMEJR3AW.js";
 import {
   AuthError,
   ProviderError,
@@ -12,7 +12,7 @@ import {
 } from "./chunk-TU3L3PW7.js";
 import {
   atomicWriteFileSync
-} from "./chunk-IW3Q7AE5.js";
+} from "./chunk-BMLQPSHP.js";
 
 // src/providers/claude.ts
 import Anthropic from "@anthropic-ai/sdk";
@@ -1670,30 +1670,34 @@ var DeepSeekProvider = class extends OpenAICompatibleProvider {
   info = {
     id: "deepseek",
     displayName: "DeepSeek",
-    defaultModel: "deepseek-v4-flash",
+    defaultModel: "deepseek-flash",
     apiKeyEnvVar: "AICLI_API_KEY_DEEPSEEK",
     requiresApiKey: true,
     baseUrl: this.defaultBaseUrl,
     models: [
-      // ── V4 family (2026-04-23+)：1M context，支持 Thinking / Non-Thinking 双模式 ──
+      // ── V4.1 Flash (2026-09)：1M context，原生多模态，Thinking / Non-Thinking 双模式 ──
+      // model code 实测取自端点本身：`/v1/models` 只列 `deepseek-flash` 与 `deepseek-v4-pro`，
+      // 传 `deepseek-v4.1-flash` 报 400 并把合法名字写在错误消息里。**不要**按发布公告里的
+      // 版本号拼 code（v0.4.198 的 `glm-5.2[1m]` 就是这么栽的）。
       {
-        id: "deepseek-v4-pro",
-        displayName: "DeepSeek V4 Pro (0813, 1.6T MoE, 49B active)",
+        id: "deepseek-flash",
+        displayName: "DeepSeek V4.1 Flash (multimodal, 1M)",
         contextWindow: 1048576,
         supportsStreaming: true,
         supportsThinking: true
       },
       {
-        id: "deepseek-v4-flash",
-        displayName: "DeepSeek V4 Flash (0731, 284B MoE, 13B active)",
+        id: "deepseek-v4-pro",
+        displayName: "DeepSeek V4 Pro (text-only; routes to V4.1 Flash from 2026-09-14)",
         contextWindow: 1048576,
         supportsStreaming: true,
         supportsThinking: true
       }
-      // Legacy aliases (deepseek-chat / deepseek-reasoner) removed in v0.4.140 —
-      // they retire 2026-07-24 and DeepSeek already routes them to V4 Flash server-side.
-      // Pre-existing sessions were migrated to deepseek-v4-flash; pricing.ts keeps the
-      // old ids for any historical cost calculations.
+      // Legacy aliases：`deepseek-v4-flash` / `deepseek-v4-flash-vision-exp` 的底层模型已退役，
+      // 端点仍接受这两个名字并路由到 V4.1 Flash（实测传 `deepseek-v4-flash` 返回 200 且响应
+      // `model` 字段回显 `deepseek-flash`）。它们不再列进推荐清单，config 里 pin 过的会被
+      // `migrateLegacyModels()` 自愈到 `deepseek-flash`；pricing.ts 保留旧 id 供历史成本回算。
+      // `deepseek-chat` / `deepseek-reasoner` 早在 v0.4.140 移除（2026-07-24 停用）。
     ]
   };
   /**