@4yi-dev/cli 0.1.15 → 0.1.17

package/README.md

@@ -39,10 +39,12 @@ 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.
+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.
 
 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 restore codex` restores the protected OpenAI configuration, then detects tasks that still belong to the 4YI provider. In an interactive terminal, choose a recent task by number, press Enter for the newest task, enter `a` for every displayed task, or enter `s` to skip. Codex copies each selected task to a new OpenAI task without modifying the original. For scripts, use `4yi restore codex --thread <id>` or `4yi restore codex --migrate-tasks all`; optionally pass `--model <id>` to override the OpenAI default model. Fully quit and reopen Codex App after the command completes.
+
 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.
 
 For local development:

package/bin/4yi.mjs

@@ -2,7 +2,7 @@
 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 { migrateCodexTask, restoreCodexTasksToOpenAI } from "../src/codex-migrate.mjs";
 
 const command = process.argv[2] || "help";
 
@@ -18,6 +18,10 @@ if (command === "help" || command === "--help" || command === "-h") {
   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: interactively copy 4YI tasks to OpenAI after restoring");
+  console.log("    --thread ID                  copy one specific 4YI task to OpenAI");
+  console.log("    --migrate-tasks all          copy every detected 4YI task to OpenAI");
+  console.log("    --model X                    use a specific OpenAI model for copied tasks");
   process.exit(0);
 }
 
@@ -66,6 +70,44 @@ function parseMigrateArgs(args) {
   return { threadId, model };
 }
 
+function parseRestoreArgs(args) {
+  let target = "all";
+  let threadId;
+  let migrateTasks;
+  let model;
+  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 {
+      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) && !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 };
+}
+
 /** Split out `--model <id>` / `--model=<id>` / `-m <id>`; the rest pass through to OpenCode. */
 function parseCodeArgs(args) {
   let preferredModel = null;
@@ -122,8 +164,12 @@ try {
     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 restored = restoreConnection({ target: restoreArgs.target });
+    if (restored.restoredCodex) {
+      await restoreCodexTasksToOpenAI(restoreArgs);
+      console.log("Codex 已恢复为 OpenAI。请完全退出并重新打开 Codex App，然后打开复制后的任务或创建新任务。");
+    }
   } else {
     console.error(`Unknown command: ${command}`);
     process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@4yi-dev/cli",
-  "version": "0.1.15",
+  "version": "0.1.17",
   "description": "4YI command-line launcher for OAuth login and OpenCode runtime",
   "type": "module",
   "bin": {

package/src/codex-migrate.mjs

@@ -136,6 +136,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 +187,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 +335,105 @@ 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 restoreCodexTasksToOpenAI({
+  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 migrateCodexTask({
   session,
   threadId,
@@ -355,6 +497,9 @@ export const __testing = {
   codexHomeForEnv,
   loadDefaultCodexModel,
   mergeCandidateThreads,
+  mergeProviderThreads,
+  listProviderThreads,
+  loadDefaultOpenAIModel,
   relativeTime,
   scanCodexSessionThreads,
   sessionThreadFromFile,

package/src/connect.mjs

@@ -216,9 +216,9 @@ function reportDesktopApp(target, {
   const detected = candidates.some((candidate) => exists(candidate));
   if (target === "codex" && platform === "win32") {
     if (detected) {
-      stdout("Codex App detected. 4YI updated the shared Windows Codex home. Finish active tasks, fully quit and reopen the App, then start a new chat to load the new provider.");
+      stdout("Codex App detected. 4YI updated the shared Windows Codex home. Finish active tasks, fully quit and reopen the App, then start a new chat to load the new provider. The App may hide Log out while this external provider supplies authentication; use `4yi restore codex`, then reopen the App, to return to OpenAI.");
     } else {
-      stdout("4YI updated the shared Windows Codex home. A Microsoft Store/AppX install may not expose a standard executable path; finish active tasks, fully quit and reopen any running Codex App, then start a new chat.");
+      stdout("4YI updated the shared Windows Codex home. A Microsoft Store/AppX install may not expose a standard executable path; finish active tasks, fully quit and reopen any running Codex App, then start a new chat. The App may hide Log out while this external provider supplies authentication; use `4yi restore codex`, then reopen the App, to return to OpenAI.");
     }
     return detected;
   }
@@ -249,21 +249,37 @@ function backupFile(target, file, home, groupId = timestamp()) {
   return backup;
 }
 
-function latestBackups(target, home) {
+function backupGroups(target, home) {
   const dir = path.join(pathsForHome(home).backupsDir, target);
   if (!fs.existsSync(dir)) return [];
   const entries = fs.readdirSync(dir)
     .filter((entry) => entry.endsWith(".json"))
     .sort()
     .reverse();
-  if (!entries[0]) return [];
-  const latest = path.join(dir, entries[0]);
-  const latestRecord = JSON.parse(fs.readFileSync(latest, "utf8"));
-  const groupId = latestRecord.group_id;
-  if (!groupId) return [latest];
-  return entries
-    .map((entry) => path.join(dir, entry))
-    .filter((file) => JSON.parse(fs.readFileSync(file, "utf8")).group_id === groupId);
+  const groups = new Map();
+  for (const entry of entries) {
+    const file = path.join(dir, entry);
+    const record = JSON.parse(fs.readFileSync(file, "utf8"));
+    const groupId = record.group_id || entry;
+    if (!groups.has(groupId)) groups.set(groupId, []);
+    groups.get(groupId).push({ file, record });
+  }
+  return [...groups.values()];
+}
+
+function latestBackups(target, home) {
+  const groups = backupGroups(target, home);
+  if (target !== "codex") return groups[0] || [];
+
+  // Older CLI releases created a fresh backup every time `connect codex` ran,
+  // even when Codex was already connected. Such a group only restores the 4YI
+  // provider and credential helper. Walk back to the newest group whose config
+  // predates 4YI management so existing installations can still return to the
+  // official provider.
+  return groups.find((group) => !group.some(({ record }) => (
+    typeof record.content === "string"
+      && (record.content.includes(CODEX_ROOT_START) || record.content.includes(CODEX_PROVIDER_START))
+  ))) || [];
 }
 
 function mask(value) {
@@ -566,10 +582,15 @@ async function connectCodex({ session, home, codexHome, codexBaseUrl, stdout, sk
   const catalog = buildCodexCatalog(models, template);
   atomicWrite(paths.codexCatalog, `${JSON.stringify(catalog, null, 2)}\n`);
 
-  const backupGroup = timestamp();
-  const backup = backupFile("codex", paths.codexConfig, home, backupGroup);
-  const helperBackup = backupFile("codex", paths.codexCredentialHelper, home, backupGroup);
   let existing = fs.existsSync(paths.codexConfig) ? fs.readFileSync(paths.codexConfig, "utf8") : "";
+  const alreadyManaged = existing.includes(CODEX_ROOT_START) || existing.includes(CODEX_PROVIDER_START);
+  let backup;
+  let helperBackup;
+  if (!alreadyManaged) {
+    const backupGroup = timestamp();
+    backup = backupFile("codex", paths.codexConfig, home, backupGroup);
+    helperBackup = backupFile("codex", paths.codexCredentialHelper, home, backupGroup);
+  }
   existing = removeManagedBlock(existing, CODEX_ROOT_START, CODEX_ROOT_END);
   existing = removeManagedBlock(existing, CODEX_PROVIDER_START, CODEX_PROVIDER_END);
   existing = removeCodexRootAssignments(existing);
@@ -584,8 +605,12 @@ async function connectCodex({ session, home, codexHome, codexBaseUrl, stdout, sk
   stdout(`Connected Codex: ${paths.codexConfig}`);
   stdout(`Codex credential helper: ${paths.codexCredentialHelper}`);
   stdout(`Available Codex models: ${models.map((model) => model.id).join(", ")}`);
-  stdout(`Backup: ${backup}`);
-  stdout(`Backup: ${helperBackup}`);
+  if (backup && helperBackup) {
+    stdout(`Backup: ${backup}`);
+    stdout(`Backup: ${helperBackup}`);
+  } else {
+    stdout("Preserved the existing Codex restore point.");
+  }
 }
 
 function resolveUrls(session, options) {
@@ -684,8 +709,7 @@ function restoreOne(target, home, stdout, { required = true } = {}) {
     if (required) throw new Error(`No ${target} backup found.`);
     return false;
   }
-  for (const backup of backups) {
-    const record = JSON.parse(fs.readFileSync(backup, "utf8"));
+  for (const { file: backup, record } of backups) {
     if (record.existed) atomicWrite(record.source, record.content || "");
     else if (fs.existsSync(record.source)) fs.unlinkSync(record.source);
     stdout(`Restored ${target}: ${record.source}`);
@@ -696,12 +720,18 @@ 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 const __testing = {