@4yi-dev/cli 0.1.16 → 0.1.18

package/README.md

@@ -39,9 +39,13 @@ On macOS, `4yi connect claude` also configures an installed Claude Desktop throu
 
 `--scope project` changes only the project's Claude Code settings and never changes the global Claude Desktop profile.
 
-Codex CLI and Codex App share the same Codex home on native Windows (`%USERPROFILE%\\.codex`). After `4yi connect codex`, finish active App tasks, fully quit and reopen the App, and start a new chat so its embedded Codex process loads the new provider. Microsoft Store/AppX installations may not expose a conventional executable path, but that detection does not gate the shared configuration update. While the external 4YI provider supplies authentication, Codex App may hide its `Log out` action because there is no App-managed provider credential to clear. To switch back to OpenAI, run `4yi restore codex`, fully quit and reopen the App, and start a new chat.
+Codex CLI and Codex App share the same Codex home on native Windows (`%USERPROFILE%\\.codex`). Microsoft Store/AppX installations may not expose a conventional executable path, but that detection does not gate the shared configuration update. While the external 4YI provider supplies authentication, Codex App may hide its `Log out` action because there is no App-managed provider credential to clear.
 
-Existing Codex tasks keep the provider they were created with. Run `4yi migrate codex`, choose a recent task by number, and 4YI creates a new task with the same history and project using your Plan's default model. The original task is not modified. Scripts can use `--thread <id>` and optionally `--model <id>`.
+`4yi migrate codex` connects Codex to 4YI and switches every stored Codex task to the 4YI provider in place. `4yi restore codex` restores the protected OpenAI configuration and switches every task back to OpenAI in place. Task IDs, projects, visible user messages, assistant answers, and tool history remain on the original sidebar entries. Finish active turns before running either command, then fully quit and reopen Codex App when it completes.
+
+Before changing anything, the CLI validates the current `state_5.sqlite` and `thread_history_1.sqlite` schemas and every target rollout. It then creates consistent database and rollout backups under `~/.4yi/backups/codex-migrations`, removes provider-private reasoning/compaction references, updates the provider/model and UI projection offsets as one migration, and rolls back automatically if a commit or verification step fails. Node.js 22.13 or newer is required for this protected SQLite workflow.
+
+Use `--thread <id>` to switch only one task, `--model <id>` to override the target default model, or `--fork` to retain the older compatibility behavior that creates a migrated copy instead of changing the original task.
 
 The Codex provider uses the official command-backed authentication configuration. Its helper reads the current token from `~/.4yi/config.json`; `config.toml` and the model catalog do not contain the bearer token.
 

package/bin/4yi.mjs

@@ -1,8 +1,20 @@
 #!/usr/bin/env node
 import { login, loadSession, clearSession } from "../src/auth.mjs";
 import { runCode } from "../src/opencode.mjs";
-import { connect, connectionStatus, prepareConnectionTools, restoreConnection } from "../src/connect.mjs";
-import { migrateCodexTask } from "../src/codex-migrate.mjs";
+import {
+  captureCodexConnectionState,
+  connect,
+  connectionStatus,
+  prepareConnectionTools,
+  restoreCodexConnectionState,
+  restoreConnection,
+} from "../src/connect.mjs";
+import {
+  migrateCodexTask,
+  migrateCodexTasksTo4yi,
+  restoreCodexTasksByFork,
+  restoreCodexTasksToOpenAI,
+} from "../src/codex-migrate.mjs";
 
 const command = process.argv[2] || "help";
 
@@ -13,11 +25,16 @@ if (command === "help" || command === "--help" || command === "-h") {
   console.log("  4yi connect <claude|codex|all>  connect existing coding tools to 4YI");
   console.log("    --yes                         install a missing CLI without prompting");
   console.log("    Claude on macOS also configures installed Claude Desktop 3P Gateway mode");
-  console.log("  4yi migrate codex              continue an existing Codex task through 4YI");
-  console.log("    --thread ID                  select a specific task without prompting");
+  console.log("  4yi migrate codex              switch every Codex task in place to 4YI");
+  console.log("    --thread ID                  switch only one task in place");
+  console.log("    --fork                       create a migrated copy instead (compatibility fallback)");
   console.log("    --model X                    choose a model (defaults to your Plan model)");
   console.log("  4yi status [claude|codex|all]   inspect the current connection");
   console.log("  4yi restore <claude|codex|all>  restore the latest protected config");
+  console.log("    Codex: switch every task in place to OpenAI after restoring");
+  console.log("    --thread ID                  switch only one task in place");
+  console.log("    --fork                       create migrated copies instead (compatibility fallback)");
+  console.log("    --model X                    use a specific target-provider model");
   process.exit(0);
 }
 
@@ -48,6 +65,7 @@ function parseMigrateArgs(args) {
   if (target !== "codex") throw new Error("Use `4yi migrate codex`.");
   let threadId;
   let model;
+  let fork = false;
   for (let i = 1; i < args.length; i += 1) {
     const arg = args[i];
     if (arg === "--thread") {
@@ -60,10 +78,52 @@ function parseMigrateArgs(args) {
       if (!model || model.startsWith("-")) throw new Error("--model requires a model id.");
     }
     else if (arg.startsWith("--model=")) model = arg.slice("--model=".length);
+    else if (arg === "--fork") fork = true;
     else throw new Error(`Unknown option: ${arg}`);
   }
   if (threadId === "" || model === "") throw new Error("--thread and --model require a value.");
-  return { threadId, model };
+  return { threadId, model, fork };
+}
+
+function parseRestoreArgs(args) {
+  let target = "all";
+  let threadId;
+  let migrateTasks;
+  let model;
+  let fork = false;
+  let targetSeen = false;
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (!arg.startsWith("-") && !targetSeen) {
+      target = arg;
+      targetSeen = true;
+    } else if (arg === "--thread") {
+      threadId = args[++i];
+      if (!threadId || threadId.startsWith("-")) throw new Error("--thread requires a task id.");
+    } else if (arg.startsWith("--thread=")) {
+      threadId = arg.slice("--thread=".length);
+    } else if (arg === "--migrate-tasks") {
+      migrateTasks = args[++i];
+      if (!migrateTasks || migrateTasks.startsWith("-")) throw new Error("--migrate-tasks requires `all`.");
+    } else if (arg.startsWith("--migrate-tasks=")) {
+      migrateTasks = arg.slice("--migrate-tasks=".length);
+    } else if (arg === "--model" || arg === "-m") {
+      model = args[++i];
+      if (!model || model.startsWith("-")) throw new Error("--model requires a model id.");
+    } else if (arg.startsWith("--model=")) {
+      model = arg.slice("--model=".length);
+    } else if (arg === "--fork") {
+      fork = true;
+    } else {
+      throw new Error(`Unknown option: ${arg}`);
+    }
+  }
+  if (migrateTasks && migrateTasks !== "all") throw new Error("--migrate-tasks currently supports only `all`.");
+  if (threadId && migrateTasks) throw new Error("Use either --thread or --migrate-tasks all, not both.");
+  if ((threadId || migrateTasks || model || fork) && !new Set(["codex", "all"]).has(String(target).toLowerCase())) {
+    throw new Error("Codex task migration options require `4yi restore codex` or `4yi restore all`.");
+  }
+  return { target, threadId, migrateTasks, model, fork };
 }
 
 /** Split out `--model <id>` / `--model=<id>` / `-m <id>`; the rest pass through to OpenCode. */
@@ -117,13 +177,38 @@ try {
   } else if (command === "migrate") {
     const migrateArgs = parseMigrateArgs(process.argv.slice(3));
     const session = loadSession();
-    await migrateCodexTask({ session, ...migrateArgs });
+    await prepareConnectionTools({ target: "codex" });
+    const codexSnapshot = migrateArgs.fork ? null : captureCodexConnectionState();
+    try {
+      await connect({ session, target: "codex", skipToolCheck: true });
+      if (migrateArgs.fork) await migrateCodexTask({ session, ...migrateArgs });
+      else await migrateCodexTasksTo4yi({ session, ...migrateArgs });
+    } catch (error) {
+      if (codexSnapshot) {
+        try { restoreCodexConnectionState(codexSnapshot); } catch { /* Preserve the migration error. */ }
+      }
+      throw error;
+    }
+    console.log("请完全退出并重新打开 Codex App，使所有窗口加载新的 provider 配置。");
   } else if (command === "status") {
     const { target, scope } = parseConnectArgs(process.argv.slice(3));
     connectionStatus({ target, scope });
   } else if (command === "restore") {
-    const { target } = parseConnectArgs(process.argv.slice(3));
-    restoreConnection({ target });
+    const restoreArgs = parseRestoreArgs(process.argv.slice(3));
+    const codexSnapshot = restoreArgs.fork ? null : captureCodexConnectionState();
+    try {
+      const restored = restoreConnection({ target: restoreArgs.target });
+      if (restored.restoredCodex) {
+        if (restoreArgs.fork) await restoreCodexTasksByFork(restoreArgs);
+        else await restoreCodexTasksToOpenAI(restoreArgs);
+        console.log("Codex 已恢复为 OpenAI。请完全退出并重新打开 Codex App；原任务可在原位置继续。");
+      }
+    } catch (error) {
+      if (codexSnapshot) {
+        try { restoreCodexConnectionState(codexSnapshot); } catch { /* Preserve the restore error. */ }
+      }
+      throw error;
+    }
   } else {
     console.error(`Unknown command: ${command}`);
     process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@4yi-dev/cli",
-  "version": "0.1.16",
+  "version": "0.1.18",
   "description": "4YI command-line launcher for OAuth login and OpenCode runtime",
   "type": "module",
   "bin": {
@@ -22,7 +22,7 @@
     "publish:prod": "node scripts/stage-package.mjs prod --publish"
   },
   "engines": {
-    "node": ">=20.0.0"
+    "node": ">=22.13.0"
   },
   "license": "UNLICENSED"
 }

package/src/codex-in-place.mjs

@@ -0,0 +1,495 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+
+function timestampForPath(date = new Date()) {
+  return date.toISOString().replace(/[-:TZ.]/g, "").slice(0, 17);
+}
+
+function latestNumberedDatabase(codexHome, prefix) {
+  const expression = new RegExp(`^${prefix}_(\\d+)\\.sqlite$`);
+  const matches = fs.readdirSync(codexHome, { withFileTypes: true })
+    .filter((entry) => entry.isFile() && expression.test(entry.name))
+    .map((entry) => ({
+      file: path.join(codexHome, entry.name),
+      version: Number(entry.name.match(expression)[1]),
+    }))
+    .sort((left, right) => right.version - left.version);
+  if (matches.length === 0) throw new Error(`Codex 数据库缺失：${prefix}_*.sqlite`);
+  return matches[0];
+}
+
+function tableColumns(database, table) {
+  return new Set(database.prepare(`PRAGMA table_info(${table})`).all().map((row) => row.name));
+}
+
+function requireColumns(database, table, required) {
+  const columns = tableColumns(database, table);
+  const missing = required.filter((column) => !columns.has(column));
+  if (missing.length > 0) {
+    throw new Error(`不支持当前 Codex 数据库结构：${table} 缺少 ${missing.join(", ")}`);
+  }
+}
+
+function resolveRolloutPath(codexHome, rolloutPath) {
+  if (path.isAbsolute(rolloutPath)) return rolloutPath;
+  return path.resolve(codexHome, rolloutPath);
+}
+
+function lineParts(buffer) {
+  const text = buffer.toString("utf8");
+  const parts = text.match(/[^\n]*\n|[^\n]+$/g) || [];
+  return parts.map((line) => ({
+    body: line.endsWith("\n") ? line.slice(0, -1) : line,
+    newline: line.endsWith("\n") ? "\n" : "",
+  }));
+}
+
+function privateRecordKind(record) {
+  if (record?.type === "response_item" && record.payload?.type === "reasoning") return "reasoning";
+  if (record?.type === "event_msg" && record.payload?.type === "item_completed" && record.payload?.item?.type === "reasoning") {
+    return "reasoning-event";
+  }
+  if (record?.type === "compacted") return "compaction";
+  if (record?.type === "event_msg" && record.payload?.type === "context_compacted") return "compaction-event";
+  return null;
+}
+
+function tombstoneRecord(record, kind, byteLength) {
+  let tombstone = {
+    timestamp: record.timestamp,
+    type: "event_msg",
+    payload: { type: "token_count", info: null, migrated: kind },
+  };
+  if (record.ordinal !== undefined) tombstone.ordinal = record.ordinal;
+  let json = JSON.stringify(tombstone);
+  if (Buffer.byteLength(json) > byteLength) {
+    tombstone = { type: "event_msg", payload: { type: "token_count" } };
+    json = JSON.stringify(tombstone);
+  }
+  const length = Buffer.byteLength(json);
+  if (length > byteLength) {
+    throw new Error(`无法安全替换 ${kind} 记录：占位记录比原记录长。`);
+  }
+  return `${json}${" ".repeat(byteLength - length)}`;
+}
+
+function newTransformState(threadId, targetProvider) {
+  return {
+    threadId,
+    targetProvider,
+    sessionMetaCount: 0,
+    matchingSessionMetaCount: 0,
+    sourceProviders: new Set(),
+    removedReasoning: 0,
+    removedCompaction: 0,
+    originalOffset: 0,
+    cumulativeDelta: 0,
+    offsetChanges: [],
+  };
+}
+
+function transformRolloutBody(body, state) {
+  if (!body.trim()) return body;
+  let record;
+  try {
+    record = JSON.parse(body);
+  } catch {
+    throw new Error(`任务 ${state.threadId} 的 rollout 包含无法解析的 JSONL 记录。`);
+  }
+  if (record.type === "session_meta") {
+    state.sessionMetaCount += 1;
+    const recordThreadId = record.payload?.id || record.payload?.session_id;
+    if (recordThreadId === state.threadId) state.matchingSessionMetaCount += 1;
+    state.sourceProviders.add(record.payload?.model_provider || record.payload?.modelProvider || "openai");
+    record.payload.model_provider = state.targetProvider;
+    delete record.payload.modelProvider;
+    return JSON.stringify(record);
+  }
+  const kind = privateRecordKind(record);
+  if (!kind) return body;
+  if (kind.startsWith("reasoning")) state.removedReasoning += 1;
+  else state.removedCompaction += 1;
+  return tombstoneRecord(record, kind, Buffer.byteLength(body));
+}
+
+function recordOffsetChange(state, originalLength, transformedLength) {
+  state.originalOffset += originalLength;
+  const delta = transformedLength - originalLength;
+  if (delta !== 0) {
+    state.cumulativeDelta += delta;
+    state.offsetChanges.push({ afterOffset: state.originalOffset, delta: state.cumulativeDelta });
+  }
+}
+
+function transformResult(state) {
+  if (state.sessionMetaCount < 1) throw new Error(`任务 ${state.threadId} 缺少 session_meta。`);
+  if (state.matchingSessionMetaCount < 1) throw new Error(`任务 ${state.threadId} 的 rollout 不包含自身 session_meta。`);
+  return {
+    sourceProvider: [...state.sourceProviders].join(","),
+    byteDelta: state.cumulativeDelta,
+    offsetChanges: state.offsetChanges,
+    removedReasoning: state.removedReasoning,
+    removedCompaction: state.removedCompaction,
+  };
+}
+
+export function transformCodexRollout(buffer, { threadId, targetProvider }) {
+  const state = newTransformState(threadId, targetProvider);
+  const transformed = [];
+  for (const { body, newline } of lineParts(buffer)) {
+    const nextLine = `${transformRolloutBody(body, state)}${newline}`;
+    transformed.push(nextLine);
+    recordOffsetChange(state, Buffer.byteLength(`${body}${newline}`), Buffer.byteLength(nextLine));
+  }
+  const output = Buffer.from(transformed.join(""), "utf8");
+  return { buffer: output, ...transformResult(state) };
+}
+
+function transformCodexRolloutFile(file, { threadId, targetProvider }) {
+  const temporary = `${file}.4yi-migration-${process.pid}.tmp`;
+  const input = fs.openSync(file, "r");
+  const output = fs.openSync(temporary, "wx", 0o600);
+  const state = newTransformState(threadId, targetProvider);
+  let pending = Buffer.alloc(0);
+  const chunk = Buffer.alloc(1024 * 1024);
+  let failure;
+  try {
+    while (true) {
+      const bytes = fs.readSync(input, chunk, 0, chunk.length, null);
+      if (bytes === 0) break;
+      pending = pending.length === 0 ? Buffer.from(chunk.subarray(0, bytes)) : Buffer.concat([pending, chunk.subarray(0, bytes)]);
+      let newlineIndex;
+      while ((newlineIndex = pending.indexOf(0x0a)) >= 0) {
+        const originalLine = pending.subarray(0, newlineIndex + 1);
+        const body = originalLine.subarray(0, -1).toString("utf8");
+        const nextLine = Buffer.from(`${transformRolloutBody(body, state)}\n`, "utf8");
+        fs.writeSync(output, nextLine);
+        recordOffsetChange(state, originalLine.length, nextLine.length);
+        pending = pending.subarray(newlineIndex + 1);
+      }
+    }
+    if (pending.length > 0) {
+      const body = pending.toString("utf8");
+      const nextLine = Buffer.from(transformRolloutBody(body, state), "utf8");
+      fs.writeSync(output, nextLine);
+      recordOffsetChange(state, pending.length, nextLine.length);
+    }
+  } catch (error) {
+    failure = error;
+  } finally {
+    fs.closeSync(input);
+    fs.closeSync(output);
+  }
+  if (failure) {
+    try { fs.unlinkSync(temporary); } catch { /* Best effort cleanup. */ }
+    throw failure;
+  }
+  try {
+    return { temporary, ...transformResult(state) };
+  } catch (error) {
+    try { fs.unlinkSync(temporary); } catch { /* Best effort cleanup. */ }
+    throw error;
+  }
+}
+
+function mapRolloutOffset(offset, changes) {
+  if (offset === null || offset === undefined) return offset;
+  let delta = 0;
+  for (const change of changes) {
+    if (Number(offset) < change.afterOffset) break;
+    delta = change.delta;
+  }
+  return Number(offset) + delta;
+}
+
+function atomicWrite(file, buffer, mode) {
+  const temporary = `${file}.4yi-migration-${process.pid}.tmp`;
+  fs.writeFileSync(temporary, buffer, { mode });
+  try {
+    fs.renameSync(temporary, file);
+  } catch (error) {
+    try { fs.unlinkSync(temporary); } catch { /* Best effort cleanup. */ }
+    throw error;
+  }
+}
+
+function writeManifest(file, manifest) {
+  const buffer = Buffer.from(`${JSON.stringify(manifest, null, 2)}\n`);
+  atomicWrite(file, buffer, 0o600);
+}
+
+async function loadSqlite() {
+  try {
+    return await import("node:sqlite");
+  } catch {
+    throw new Error("原地迁移需要 Node.js 22.13 或更高版本（需要内置 node:sqlite）。");
+  }
+}
+
+function acquireMigrationLock(codexHome) {
+  const directory = path.join(path.dirname(codexHome), ".4yi", "locks");
+  fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
+  const file = path.join(directory, "codex-provider-migration.lock");
+  let descriptor;
+  try {
+    descriptor = fs.openSync(file, "wx", 0o600);
+  } catch (error) {
+    if (error.code === "EEXIST") throw new Error(`已有 Codex 迁移正在执行。如确认没有迁移进程，请删除锁文件：${file}`);
+    throw error;
+  }
+  fs.writeFileSync(descriptor, `${JSON.stringify({ pid: process.pid, startedAt: new Date().toISOString() })}\n`);
+  return () => {
+    try { fs.closeSync(descriptor); } catch { /* Already closed. */ }
+    try { fs.unlinkSync(file); } catch { /* Best effort cleanup. */ }
+  };
+}
+
+function assertUnchanged(item) {
+  const current = fs.statSync(item.file);
+  if (current.size !== item.originalSize || current.mtimeMs !== item.originalMtimeMs) {
+    throw new Error(`迁移准备期间任务仍在写入：${item.threadId}。请完全退出 Codex App 后重试。`);
+  }
+}
+
+function restoreFiles(prepared) {
+  for (const item of prepared) {
+    if (!item.backupFile || !fs.existsSync(item.backupFile)) continue;
+    const backup = fs.readFileSync(item.backupFile);
+    atomicWrite(item.file, backup, item.mode);
+  }
+}
+
+function restoreDatabase(backupFile, destination) {
+  for (const suffix of ["-wal", "-shm"]) {
+    try { fs.unlinkSync(`${destination}${suffix}`); } catch { /* Missing sidecar. */ }
+  }
+  fs.copyFileSync(backupFile, destination);
+}
+
+function migrationCandidates(database, codexHome, targetProvider, threadId) {
+  const rows = database.prepare("SELECT id, rollout_path, model_provider, model FROM threads ORDER BY created_at ASC").all();
+  const selected = threadId ? rows.filter((row) => row.id === threadId) : rows;
+  if (threadId && selected.length === 0) throw new Error(`找不到 Codex 任务：${threadId}`);
+  return selected.map((row) => ({
+    ...row,
+    file: resolveRolloutPath(codexHome, row.rollout_path),
+    needsMigration: row.model_provider !== targetProvider,
+  }));
+}
+
+export async function switchCodexThreadsInPlace({
+  targetProvider,
+  targetModel,
+  threadId,
+  codexHome = process.env.CODEX_HOME || path.join(process.env.HOME || process.env.USERPROFILE || os.homedir(), ".codex"),
+  backupRoot = path.join(path.dirname(codexHome), ".4yi", "backups", "codex-migrations"),
+  stdout = console.log,
+  now = new Date(),
+  dryRun = false,
+} = {}) {
+  if (!new Set(["4yi", "openai"]).has(targetProvider)) throw new Error(`不支持的目标 provider：${targetProvider}`);
+  if (!targetModel) throw new Error("缺少目标 Codex 模型。需要先验证目标 provider 的模型列表。");
+
+  const releaseLock = acquireMigrationLock(codexHome);
+  let stateDatabase;
+  let historyDatabase;
+  let stateBackup;
+  let historyBackup;
+  let prepared = [];
+  try {
+    const sqlite = await loadSqlite();
+    const state = latestNumberedDatabase(codexHome, "state");
+    const history = latestNumberedDatabase(codexHome, "thread_history");
+    if (state.version !== 5 || history.version !== 1) {
+      throw new Error(`尚未适配当前 Codex 存储版本：state_${state.version} / thread_history_${history.version}。未修改任何任务。`);
+    }
+    stateDatabase = new sqlite.DatabaseSync(state.file);
+    historyDatabase = new sqlite.DatabaseSync(history.file);
+    requireColumns(stateDatabase, "threads", ["id", "rollout_path", "model_provider", "model"]);
+    requireColumns(historyDatabase, "thread_turns", ["thread_id", "rollout_byte_offset", "rollout_end_byte_offset"]);
+    requireColumns(historyDatabase, "thread_items", ["thread_id", "item_type"]);
+    requireColumns(historyDatabase, "thread_history_projection_state", ["thread_id", "next_rollout_byte_offset"]);
+    requireColumns(historyDatabase, "thread_realtime_items", ["thread_id", "item_type"]);
+
+    const rows = migrationCandidates(stateDatabase, codexHome, targetProvider, threadId);
+    const failures = [];
+    for (const row of rows) {
+      if (!fs.existsSync(row.file)) {
+        failures.push({ threadId: row.id, error: `rollout 文件不存在：${row.file}` });
+        continue;
+      }
+      try {
+        const stat = fs.statSync(row.file);
+        const transformed = transformCodexRolloutFile(row.file, { threadId: row.id, targetProvider });
+        if (!row.needsMigration && transformed.sourceProvider === targetProvider) {
+          fs.unlinkSync(transformed.temporary);
+          continue;
+        }
+        prepared.push({
+          threadId: row.id,
+          file: row.file,
+          mode: stat.mode & 0o777,
+          originalSize: stat.size,
+          originalMtimeMs: stat.mtimeMs,
+          ...transformed,
+        });
+      } catch (error) {
+        failures.push({ threadId: row.id, error: error.message });
+      }
+    }
+
+    if (failures.length > 0) {
+      for (const item of prepared) {
+        try { fs.unlinkSync(item.temporary); } catch { /* Best effort cleanup. */ }
+      }
+      throw new Error(`全量迁移预检查失败，未修改任何任务。首个错误：${failures[0].error}`);
+    }
+
+    if (prepared.length === 0) {
+      stdout(`全部 Codex 任务已经使用 ${targetProvider}，无需修改。`);
+      return { migrated: [], failed: [], backupDirectory: null, targetProvider, targetModel };
+    }
+
+    if (dryRun) {
+      for (const item of prepared) fs.unlinkSync(item.temporary);
+      return {
+        planned: prepared.map((item) => ({ threadId: item.threadId, sourceProvider: item.sourceProvider })),
+        failed: [],
+        targetProvider,
+        targetModel,
+      };
+    }
+
+    const backupDirectory = path.join(backupRoot, `${timestampForPath(now)}-to-${targetProvider}`);
+    const rolloutBackupDirectory = path.join(backupDirectory, "rollouts");
+    fs.mkdirSync(rolloutBackupDirectory, { recursive: true, mode: 0o700 });
+    stateBackup = path.join(backupDirectory, path.basename(state.file));
+    historyBackup = path.join(backupDirectory, path.basename(history.file));
+    await sqlite.backup(stateDatabase, stateBackup);
+    await sqlite.backup(historyDatabase, historyBackup);
+
+    for (const item of prepared) {
+      item.backupFile = path.join(rolloutBackupDirectory, `${item.threadId}.jsonl`);
+      fs.copyFileSync(item.file, item.backupFile);
+    }
+    const manifestFile = path.join(backupDirectory, "manifest.json");
+    const manifest = {
+      version: 1,
+      status: "prepared",
+      createdAt: now.toISOString(),
+      targetProvider,
+      targetModel,
+      stateDatabase: state.file,
+      historyDatabase: history.file,
+      threads: prepared.map((item) => ({
+        threadId: item.threadId,
+        rolloutPath: item.file,
+        backupPath: item.backupFile,
+        sourceProvider: item.sourceProvider,
+        byteDelta: item.byteDelta,
+        removedReasoning: item.removedReasoning,
+        removedCompaction: item.removedCompaction,
+      })),
+      failures,
+    };
+    writeManifest(manifestFile, manifest);
+
+    for (const item of prepared) assertUnchanged(item);
+    for (const item of prepared) {
+      fs.chmodSync(item.temporary, item.mode);
+      fs.renameSync(item.temporary, item.file);
+    }
+
+    stateDatabase.exec("BEGIN IMMEDIATE");
+    historyDatabase.exec("BEGIN IMMEDIATE");
+    try {
+      const updateThread = stateDatabase.prepare("UPDATE threads SET model_provider = ?, model = ? WHERE id = ?");
+      const selectOffsets = historyDatabase.prepare("SELECT turn_id, rollout_byte_offset, rollout_end_byte_offset FROM thread_turns WHERE thread_id = ?");
+      const updateOffsets = historyDatabase.prepare("UPDATE thread_turns SET rollout_byte_offset = ?, rollout_end_byte_offset = ? WHERE thread_id = ? AND turn_id = ?");
+      const selectProjection = historyDatabase.prepare("SELECT next_rollout_byte_offset FROM thread_history_projection_state WHERE thread_id = ?");
+      const updateProjection = historyDatabase.prepare("UPDATE thread_history_projection_state SET next_rollout_byte_offset = ? WHERE thread_id = ?");
+      const deleteItems = historyDatabase.prepare("DELETE FROM thread_items WHERE thread_id = ? AND item_type IN ('reasoning', 'contextCompaction')");
+      const deleteRealtime = historyDatabase.prepare("DELETE FROM thread_realtime_items WHERE thread_id = ? AND item_type IN ('reasoning', 'contextCompaction')");
+      for (const item of prepared) {
+        updateThread.run(targetProvider, targetModel, item.threadId);
+        if (item.offsetChanges.length > 0) {
+          for (const turn of selectOffsets.all(item.threadId)) {
+            updateOffsets.run(
+              mapRolloutOffset(turn.rollout_byte_offset, item.offsetChanges),
+              mapRolloutOffset(turn.rollout_end_byte_offset, item.offsetChanges),
+              item.threadId,
+              turn.turn_id,
+            );
+          }
+          const projection = selectProjection.get(item.threadId);
+          if (projection) {
+            updateProjection.run(mapRolloutOffset(projection.next_rollout_byte_offset, item.offsetChanges), item.threadId);
+          }
+        }
+        deleteItems.run(item.threadId);
+        deleteRealtime.run(item.threadId);
+      }
+      historyDatabase.exec("COMMIT");
+      stateDatabase.exec("COMMIT");
+    } catch (error) {
+      try { historyDatabase.exec("ROLLBACK"); } catch { /* Transaction may already be closed. */ }
+      try { stateDatabase.exec("ROLLBACK"); } catch { /* Transaction may already be closed. */ }
+      throw error;
+    }
+
+    const remaining = stateDatabase.prepare("SELECT COUNT(*) AS count FROM threads WHERE model_provider <> ?").get(targetProvider).count;
+    if (Number(remaining) !== 0 && !threadId) throw new Error(`数据库验证失败：仍有 ${remaining} 个任务未切换 provider。`);
+    for (const item of prepared) {
+      const first = lineParts(fs.readFileSync(item.file)).find((part) => part.body.trim());
+      const meta = JSON.parse(first.body);
+      if (meta.type !== "session_meta" || meta.payload?.model_provider !== targetProvider) {
+        throw new Error(`rollout 验证失败：${item.threadId}`);
+      }
+    }
+
+    manifest.status = "complete";
+    manifest.completedAt = new Date().toISOString();
+    writeManifest(manifestFile, manifest);
+    const migrated = prepared.map((item) => ({
+      threadId: item.threadId,
+      sourceProvider: item.sourceProvider,
+      removedReasoning: item.removedReasoning,
+      removedCompaction: item.removedCompaction,
+    }));
+    stdout(`✓ 已将 ${migrated.length} 个 Codex 任务原地切换到 ${targetProvider}；任务 ID 和可见聊天历史保持不变。`);
+    stdout(`迁移备份：${backupDirectory}`);
+    return { migrated, failed: failures, backupDirectory, targetProvider, targetModel };
+  } catch (error) {
+    try { stateDatabase?.close(); } catch { /* Best effort. */ }
+    try { historyDatabase?.close(); } catch { /* Best effort. */ }
+    stateDatabase = null;
+    historyDatabase = null;
+    if (prepared.some((item) => item.backupFile)) {
+      try {
+        restoreFiles(prepared);
+        if (stateBackup) restoreDatabase(stateBackup, latestNumberedDatabase(codexHome, "state").file);
+        if (historyBackup) restoreDatabase(historyBackup, latestNumberedDatabase(codexHome, "thread_history").file);
+      } catch (rollbackError) {
+        throw new Error(`${error.message}；自动回滚也失败：${rollbackError.message}`);
+      }
+    }
+    throw error;
+  } finally {
+    for (const item of prepared) {
+      if (!item.temporary) continue;
+      try { fs.unlinkSync(item.temporary); } catch { /* Already committed or cleaned up. */ }
+    }
+    try { stateDatabase?.close(); } catch { /* Best effort. */ }
+    try { historyDatabase?.close(); } catch { /* Best effort. */ }
+    releaseLock();
+  }
+}
+
+export const __testing = {
+  latestNumberedDatabase,
+  mapRolloutOffset,
+  privateRecordKind,
+  timestampForPath,
+};

package/src/codex-migrate.mjs

@@ -5,6 +5,7 @@ import process from "node:process";
 import { spawn as nodeSpawn } from "node:child_process";
 import { createInterface } from "node:readline/promises";
 import { requestJson } from "./http.mjs";
+import { switchCodexThreadsInPlace } from "./codex-in-place.mjs";
 
 const DEFAULT_LIMIT = 10;
 const REQUEST_TIMEOUT_MS = 15_000;
@@ -136,6 +137,20 @@ function mergeCandidateThreads(serverThreads, sessionThreads, limit) {
     .slice(0, limit);
 }
 
+function mergeProviderThreads(serverThreads, sessionThreads, provider, limit = Number.POSITIVE_INFINITY) {
+  const threads = new Map();
+  for (const thread of sessionThreads) if (thread?.id) threads.set(thread.id, thread);
+  for (const thread of serverThreads) if (thread?.id) threads.set(thread.id, { ...threads.get(thread.id), ...thread });
+  return [...threads.values()]
+    .filter((thread) => thread.modelProvider === provider && !thread.ephemeral)
+    .sort((left, right) => {
+      const leftTime = left.recencyAt || left.updatedAt || left.createdAt || 0;
+      const rightTime = right.recencyAt || right.updatedAt || right.createdAt || 0;
+      return rightTime - leftTime;
+    })
+    .slice(0, limit);
+}
+
 export function describeCodexThread(thread, { now = Date.now() } = {}) {
   const title = oneLine(thread.name || thread.preview, "未命名任务");
   const project = path.basename(String(thread.cwd || "")) || String(thread.cwd || "未知项目");
@@ -173,6 +188,35 @@ export async function selectCodexThread(threads, {
   }
 }
 
+export async function selectCodexRestoreThreads(threads, {
+  input = process.stdin,
+  output = process.stdout,
+  now = Date.now(),
+} = {}) {
+  if (!input?.isTTY || !output?.isTTY) return null;
+
+  output.write("\n发现仍绑定 4YI Gateway 的 Codex 任务。选择要复制到 OpenAI 的任务：\n\n");
+  threads.forEach((thread, index) => {
+    const item = describeCodexThread(thread, { now });
+    output.write(`${index + 1}. ${item.title}\n   ${item.project} · ${item.age}\n`);
+  });
+
+  const readline = createInterface({ input, output });
+  try {
+    while (true) {
+      const answer = await readline.question("\n输入序号（默认 1，a 复制以上全部，s 跳过）：");
+      const value = answer.trim().toLowerCase();
+      if (value === "s" || value === "skip" || value === "q" || value === "quit") return [];
+      if (value === "a" || value === "all") return threads;
+      const index = value === "" ? 0 : Number(value) - 1;
+      if (Number.isInteger(index) && index >= 0 && index < threads.length) return [threads[index]];
+      output.write(`请输入 1-${threads.length} 之间的序号、a 或 s。\n`);
+    }
+  } finally {
+    readline.close();
+  }
+}
+
 export class CodexAppServerClient {
   constructor({
     command = executableName("codex"),
@@ -292,6 +336,152 @@ async function loadDefaultCodexModel(session) {
   return ids.includes(response.default_model) ? response.default_model : ids[0];
 }
 
+async function loadDefaultOpenAIModel(appServer) {
+  const response = await appServer.request("model/list", { limit: 100, includeHidden: false });
+  const models = response?.data || [];
+  const selected = models.find((model) => model?.isDefault) || models[0];
+  const id = selected?.id || selected?.model;
+  if (!id) throw new Error("Codex did not report an available OpenAI model after restore.");
+  return id;
+}
+
+async function listProviderThreads(appServer, provider, limit = SESSION_SCAN_LIMIT) {
+  const threads = [];
+  let cursor;
+  do {
+    const response = await appServer.request("thread/list", {
+      cursor,
+      limit: Math.min(100, limit - threads.length),
+      sortKey: "recency_at",
+      sortDirection: "desc",
+      modelProviders: [provider],
+      useStateDbOnly: false,
+    });
+    threads.push(...(response?.data || []));
+    cursor = response?.nextCursor || null;
+  } while (cursor && threads.length < limit);
+  return threads;
+}
+
+export async function restoreCodexTasksByFork({
+  threadId,
+  migrateTasks,
+  model,
+  limit = DEFAULT_LIMIT,
+  input = process.stdin,
+  output = process.stdout,
+  stdout = console.log,
+  client,
+  clientOptions = {},
+  selectThreads = selectCodexRestoreThreads,
+  scanThreads = scanCodexSessionThreads,
+} = {}) {
+  const appServer = client || new CodexAppServerClient(clientOptions);
+  try {
+    await appServer.initialize();
+    let selected;
+    if (threadId) {
+      selected = [{ id: threadId }];
+    } else {
+      const serverThreads = await listProviderThreads(appServer, "4yi");
+      const sessionThreads = scanThreads({ codexHome: codexHomeForEnv(clientOptions.env || process.env) });
+      const candidates = mergeProviderThreads(serverThreads, sessionThreads, "4yi");
+      if (candidates.length === 0) {
+        stdout("未发现仍绑定 4YI Gateway 的 Codex 任务。新任务将使用 OpenAI。");
+        return { cancelled: false, migrated: [], failed: [] };
+      }
+      if (migrateTasks === "all") {
+        selected = candidates;
+      } else if (!input?.isTTY || !output?.isTTY) {
+        stdout(`发现 ${candidates.length} 个仍绑定 4YI Gateway 的任务；非交互模式未自动复制。可运行 \`4yi restore codex --migrate-tasks all\` 或使用 \`--thread <任务ID>\`。`);
+        return { cancelled: true, migrated: [], failed: [] };
+      } else {
+        selected = await selectThreads(candidates.slice(0, limit), { input, output });
+        if (!selected || selected.length === 0) {
+          stdout("已跳过任务复制。原 4YI 任务未修改。");
+          return { cancelled: true, migrated: [], failed: [] };
+        }
+      }
+    }
+
+    const selectedModel = model || await loadDefaultOpenAIModel(appServer);
+    const migrated = [];
+    const failed = [];
+    for (const thread of selected) {
+      const item = describeCodexThread(thread);
+      stdout(`正在复制到 OpenAI：${item.title}…`);
+      try {
+        const result = await appServer.request("thread/fork", {
+          threadId: thread.id,
+          model: selectedModel,
+          modelProvider: "openai",
+          excludeTurns: true,
+        });
+        if (!result?.thread?.id) throw new Error("Codex did not return the copied task id.");
+        if (result.modelProvider !== "openai" && result.thread.modelProvider !== "openai") {
+          throw new Error("Codex created the task but did not apply the OpenAI provider.");
+        }
+        migrated.push({ sourceThreadId: thread.id, threadId: result.thread.id });
+        stdout(`✓ OpenAI 任务 ID: ${result.thread.id}`);
+      } catch (error) {
+        failed.push({ sourceThreadId: thread.id, error: error.message });
+        stdout(`✗ 复制失败（${thread.id}）：${error.message}`);
+      }
+    }
+    stdout(`任务复制完成：成功 ${migrated.length}，失败 ${failed.length}。原 4YI 任务均未修改。`);
+    return { cancelled: false, migrated, failed, model: selectedModel };
+  } finally {
+    if (!client) await appServer.close();
+  }
+}
+
+export async function restoreCodexTasksToOpenAI({
+  threadId,
+  model,
+  stdout = console.log,
+  client,
+  clientOptions = {},
+  switchThreads = switchCodexThreadsInPlace,
+  dryRun = false,
+} = {}) {
+  const appServer = client || new CodexAppServerClient(clientOptions);
+  try {
+    await appServer.initialize();
+    const selectedModel = model || await loadDefaultOpenAIModel(appServer);
+    return await switchThreads({
+      targetProvider: "openai",
+      targetModel: selectedModel,
+      threadId,
+      codexHome: codexHomeForEnv(clientOptions.env || process.env),
+      stdout,
+      dryRun,
+    });
+  } finally {
+    if (!client) await appServer.close();
+  }
+}
+
+export async function migrateCodexTasksTo4yi({
+  session,
+  threadId,
+  model,
+  stdout = console.log,
+  clientOptions = {},
+  switchThreads = switchCodexThreadsInPlace,
+  dryRun = false,
+} = {}) {
+  if (!session?.token) throw new Error("Not signed in. Run `4yi login`.");
+  const selectedModel = model || await loadDefaultCodexModel(session);
+  return switchThreads({
+    targetProvider: "4yi",
+    targetModel: selectedModel,
+    threadId,
+    codexHome: codexHomeForEnv(clientOptions.env || process.env),
+    stdout,
+    dryRun,
+  });
+}
+
 export async function migrateCodexTask({
   session,
   threadId,
@@ -355,6 +545,9 @@ export const __testing = {
   codexHomeForEnv,
   loadDefaultCodexModel,
   mergeCandidateThreads,
+  mergeProviderThreads,
+  listProviderThreads,
+  loadDefaultOpenAIModel,
   relativeTime,
   scanCodexSessionThreads,
   sessionThreadFromFile,

package/src/connect.mjs

@@ -720,12 +720,35 @@ function restoreOne(target, home, stdout, { required = true } = {}) {
 
 export function restoreConnection({ target = "all", home = os.homedir(), stdout = console.log } = {}) {
   const normalized = normalizeTarget(target);
-  if (normalized === "claude") return restoreOne("claude", home, stdout);
-  if (normalized === "codex") return restoreOne("codex", home, stdout);
+  if (normalized === "claude") {
+    restoreOne("claude", home, stdout);
+    return { restoredClaude: true, restoredCodex: false };
+  }
+  if (normalized === "codex") {
+    restoreOne("codex", home, stdout);
+    return { restoredClaude: false, restoredCodex: true };
+  }
   const restoredClaude = restoreOne("claude", home, stdout, { required: false });
   const restoredCodex = restoreOne("codex", home, stdout, { required: false });
   if (!restoredClaude && !restoredCodex) throw new Error("No Claude or Codex backup found.");
-  return true;
+  return { restoredClaude, restoredCodex };
+}
+
+export function captureCodexConnectionState({ home = os.homedir(), codexHome = process.env.CODEX_HOME } = {}) {
+  const paths = connectionPaths({ home, codexHome });
+  const files = [paths.codexConfig, paths.codexCatalog, paths.codexCredentialHelper];
+  return files.map((file) => {
+    if (!fs.existsSync(file)) return { file, exists: false };
+    const stat = fs.statSync(file);
+    return { file, exists: true, content: fs.readFileSync(file), mode: stat.mode & 0o777 };
+  });
+}
+
+export function restoreCodexConnectionState(snapshot = []) {
+  for (const item of snapshot) {
+    if (item.exists) atomicWrite(item.file, item.content, item.mode);
+    else if (fs.existsSync(item.file)) fs.unlinkSync(item.file);
+  }
 }
 
 export const __testing = {