@ailuntz/minilink 0.9.11 → 0.9.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ailuntz/minilink",
-  "version": "0.9.11",
+  "version": "0.9.12",
   "description": "Use your Codex profiles in the Desktop model menu.",
   "type": "module",
   "license": "MIT AND Apache-2.0",

package/src/history.mjs

@@ -0,0 +1,102 @@
+import { existsSync, lstatSync, realpathSync, readFileSync, writeFileSync, renameSync, unlinkSync, mkdirSync, copyFileSync, chmodSync, constants } from 'node:fs';
+import { basename, join, sep } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { DatabaseSync } from 'node:sqlite';
+import { codexHome } from './config.mjs';
+
+const defaultBackups = home => join(home, 'minilink-history-backups');
+
+function atomicBytes(path, data, mode) {
+  const temporary = `${path}.${randomUUID()}.tmp`;
+  try { writeFileSync(temporary, data, { mode, flag: 'wx' }); renameSync(temporary, path); }
+  finally { if (existsSync(temporary)) unlinkSync(temporary); }
+}
+
+function checkedPath(path, home, threadId) {
+  if (!existsSync(path)) return false;
+  if (!lstatSync(path).isFile()) throw new Error('任务历史不是普通文件，无法安全切换提供商。');
+  const actual = realpathSync(path), root = realpathSync(home);
+  if (![join(root, 'sessions') + sep, join(root, 'archived_sessions') + sep].some(prefix => actual.startsWith(prefix))) throw new Error('任务历史不在 CODEX_HOME 中，无法安全切换提供商。');
+  if (!basename(actual).endsWith(`${threadId}.jsonl`)) throw new Error('任务历史与任务 ID 不匹配，无法安全切换提供商。');
+  return true;
+}
+
+// Native Codex replays provider reasoning items from its JSONL journal. Some
+// Responses-compatible providers persist reasoning_text and opaque encrypted
+// content that another provider rejects. Normalize only those items, keeping
+// every line's byte length so the native journal offsets remain valid.
+export function repairThreadHistory(path, { threadId, home = codexHome(), backupDir = defaultBackups(home) } = {}) {
+  if (!existsSync(path)) return null;
+  if (!/^[0-9a-f-]{36}$/.test(threadId || '')) throw new Error('任务 ID 无效，无法备份历史。');
+  if (!checkedPath(path, home, threadId)) return null;
+  const before = readFileSync(path), after = Buffer.from(before), patches = [];
+  let start = 0;
+  while (start < before.length) {
+    const newline = before.indexOf(10, start);
+    const end = newline < 0 ? before.length : newline;
+    const original = before.subarray(start, end);
+    if (original.includes(Buffer.from('"type":"reasoning"'))) {
+      let record;
+      try { record = JSON.parse(original.toString('utf8')); }
+      catch { throw new Error('任务历史包含无法解析的记录，未修改原文件。'); }
+      if (record.type === 'response_item' && record.payload?.type === 'reasoning' && Array.isArray(record.payload.content) && record.payload.content.length) {
+        record.payload.content = [];
+        delete record.payload.encrypted_content;
+        const compact = Buffer.from(JSON.stringify(record));
+        if (compact.length > original.length) throw new Error('任务历史记录无法等长修复，未修改原文件。');
+        const replacement = Buffer.alloc(original.length, 32);
+        compact.copy(replacement);
+        replacement.copy(after, start);
+        patches.push({ start, original: Buffer.from(original), replacement });
+      }
+    }
+    start = end + 1;
+  }
+  const databasePath = join(home, 'thread_history_1.sqlite');
+  const database = existsSync(databasePath) ? new DatabaseSync(databasePath) : null;
+  let rows = [];
+  try {
+    if (database) rows = database.prepare("SELECT rowid, item_json FROM thread_items WHERE thread_id = ? AND item_type = 'reasoning'").all(threadId).flatMap(row => {
+      const item = JSON.parse(row.item_json);
+      if (!Array.isArray(item.content) || !item.content.length) return [];
+      item.content = [];
+      delete item.encrypted_content;
+      return [{ rowid: row.rowid, original: row.item_json, replacement: JSON.stringify(item) }];
+    });
+    if (!patches.length && !rows.length) return null;
+  mkdirSync(backupDir, { recursive: true, mode: 0o700 });
+  const stem = `${threadId}-${randomUUID()}`;
+  const backup = join(backupDir, `${stem}.jsonl`);
+  const databaseBackup = join(backupDir, `${stem}.sqlite-reasoning.json`);
+  copyFileSync(path, backup, constants.COPYFILE_EXCL);
+  chmodSync(backup, 0o600);
+  writeFileSync(databaseBackup, JSON.stringify({ databasePath, rows: rows.map(({ rowid, original }) => ({ rowid, original })) }), { mode: 0o600, flag: 'wx' });
+  const mode = lstatSync(path).mode & 0o777;
+  const updateRows = values => {
+    if (!existsSync(databasePath) || !values.length) return;
+    const connection = new DatabaseSync(databasePath);
+    connection.exec('BEGIN IMMEDIATE');
+    try {
+      const update = connection.prepare('UPDATE thread_items SET item_json = ? WHERE rowid = ?');
+      for (const row of values) update.run(row.replacement ?? row.original, row.rowid);
+      connection.exec('COMMIT');
+    } catch (error) { connection.exec('ROLLBACK'); throw error; }
+    finally { connection.close(); }
+  };
+  try { updateRows(rows); atomicBytes(path, after, mode); }
+  catch (error) { updateRows(rows.map(row => ({ rowid: row.rowid, original: row.original }))); throw error; }
+  return {
+    backup, databaseBackup,
+    count: Math.max(patches.length, rows.length),
+    restore() {
+      const current = readFileSync(path), restored = Buffer.from(current);
+      for (const patch of patches) {
+        if (!current.subarray(patch.start, patch.start + patch.replacement.length).equals(patch.replacement)) throw new Error('任务历史已被其他进程修改，请使用备份恢复。');
+        patch.original.copy(restored, patch.start);
+      }
+      updateRows(rows.map(row => ({ rowid: row.rowid, original: row.original })));
+      atomicBytes(path, restored, mode);
+    }
+  };
+  } finally { database?.close(); }
+}

package/src/provider-switch.mjs

@@ -2,6 +2,7 @@ import { isDeepStrictEqual } from 'node:util';
 import { randomUUID } from 'node:crypto';
 import { decodeAlias } from './model-menu.mjs';
 import { isRoutedProvider, findRoute, isChatProvider } from './config.mjs';
+import { repairThreadHistory } from './history.mjs';
 
 // Private requests use the same initialized app-server connection. Their replies
 // and temporary archive lifecycle events must not appear as Desktop requests.
@@ -64,7 +65,12 @@ export class ProviderSwitch {
         change = { effort: effort.reasoningEffort }; restore = { effort: loaded.reasoningEffort };
       } else if (model?.serviceTiers?.length) {
         change = { serviceTier: model.serviceTiers[0].id }; restore = { serviceTier: null };
-      } else throw new Error('原生接口未提供可安全读取的完整设置，请先在原菜单调整一次推理强度再试。');
+      } else {
+        // A one-effort catalog (for example Doubao Lite) has no alternate
+        // reasoning level. A temporary service tier setting still elicits the
+        // complete native settings notification without running a model turn.
+        change = { serviceTier: 'fast' }; restore = { serviceTier: null };
+      }
     }
     let waiter;
     const notification = new Promise((resolve, reject) => {
@@ -154,7 +160,7 @@ export class ProviderSwitch {
   }
   async switchThread(thread, provider, model, requested = {}) {
     const id = thread.id;
-    let snapshot, loaded, archived = false, closed = false, targetLoaded = false;
+    let snapshot, loaded, archived = false, closed = false, targetLoaded = false, historyRepair;
     this.hidden.add(id);
     try {
       loaded = await this.rpc('thread/resume', { threadId: id, excludeTurns: true });
@@ -171,6 +177,7 @@ export class ProviderSwitch {
       // immediately restores the same thread before resuming with the new provider.
       await this.rpc('thread/archive', { threadId: id }); archived = true; closed = true;
       await this.rpc('thread/unarchive', { threadId: id }); archived = false;
+      historyRepair = repairThreadHistory(thread.path, { threadId: id });
       const resumed = await this.rpc('thread/resume', this.resumeParams(id, desired, loaded, provider, model));
       targetLoaded = true;
       if (resumed.thread.id !== id || resumed.modelProvider !== provider) throw new Error('恢复后的提供商不匹配。');
@@ -183,6 +190,7 @@ export class ProviderSwitch {
         try {
           if (targetLoaded) { await this.rpc('thread/archive', { threadId: id }); archived = true; }
           if (archived) { await this.rpc('thread/unarchive', { threadId: id }); archived = false; }
+          historyRepair?.restore();
           const original = await this.rpc('thread/resume', this.resumeParams(id, snapshot, loaded, snapshot.modelProvider, snapshot.model));
           this.settings.delete(id);
           await this.snapshot(id, original);