@4yi-dev/cli 0.1.14 → 0.1.16

package/README.md

@@ -39,7 +39,7 @@ 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>`.
 

package/package.json

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

package/src/codex-migrate.mjs

@@ -1,3 +1,5 @@
+import fs from "node:fs";
+import os from "node:os";
 import path from "node:path";
 import process from "node:process";
 import { spawn as nodeSpawn } from "node:child_process";
@@ -6,6 +8,8 @@ import { requestJson } from "./http.mjs";
 
 const DEFAULT_LIMIT = 10;
 const REQUEST_TIMEOUT_MS = 15_000;
+const SESSION_SCAN_LIMIT = 500;
+const SESSION_PREFIX_BYTES = 256 * 1024;
 
 function executableName(command, platform = process.platform) {
   return platform === "win32" ? `${command}.cmd` : command;
@@ -34,6 +38,104 @@ function relativeTime(timestamp, now = Date.now()) {
   return new Date(Number(timestamp) * 1000).toLocaleDateString();
 }
 
+function codexHomeForEnv(env = process.env) {
+  if (env.CODEX_HOME) return env.CODEX_HOME;
+  const home = env.HOME || env.USERPROFILE || os.homedir();
+  return path.join(home, ".codex");
+}
+
+function collectSessionFiles(root) {
+  const files = [];
+  const pending = [root];
+  while (pending.length > 0) {
+    const directory = pending.pop();
+    let entries;
+    try { entries = fs.readdirSync(directory, { withFileTypes: true }); } catch { continue; }
+    for (const entry of entries) {
+      const file = path.join(directory, entry.name);
+      if (entry.isDirectory()) pending.push(file);
+      else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+        try { files.push({ file, mtimeMs: fs.statSync(file).mtimeMs }); } catch { /* Ignore a file removed during scanning. */ }
+      }
+    }
+  }
+  return files.sort((left, right) => right.mtimeMs - left.mtimeMs).slice(0, SESSION_SCAN_LIMIT);
+}
+
+function readFilePrefix(file) {
+  const descriptor = fs.openSync(file, "r");
+  try {
+    const buffer = Buffer.alloc(SESSION_PREFIX_BYTES);
+    const bytes = fs.readSync(descriptor, buffer, 0, buffer.length, 0);
+    return buffer.toString("utf8", 0, bytes);
+  } finally {
+    fs.closeSync(descriptor);
+  }
+}
+
+function messageText(payload) {
+  if (payload?.type === "message" && payload.role === "user") {
+    if (typeof payload.content === "string") return payload.content;
+    if (Array.isArray(payload.content)) {
+      return payload.content
+        .map((item) => item?.text || item?.input_text || "")
+        .filter(Boolean)
+        .join(" ");
+    }
+  }
+  if (payload?.type === "user_message") return payload.message || payload.text || "";
+  return "";
+}
+
+function sessionThreadFromFile({ file, mtimeMs }) {
+  let text;
+  try { text = readFilePrefix(file); } catch { return null; }
+  let metadata;
+  let preview = "";
+  for (const line of text.split(/\r?\n/)) {
+    if (!line.trim()) continue;
+    let record;
+    try { record = JSON.parse(line); } catch { continue; }
+    if (record.type === "session_meta") metadata = record.payload;
+    if (!preview && (record.type === "response_item" || record.type === "event_msg")) {
+      preview = messageText(record.payload);
+    }
+    if (metadata && preview) break;
+  }
+  const id = metadata?.id || metadata?.session_id;
+  if (!id) return null;
+  const created = Date.parse(metadata.timestamp || "");
+  return {
+    id,
+    modelProvider: metadata.model_provider || metadata.modelProvider || "openai",
+    cwd: metadata.cwd || "",
+    preview,
+    createdAt: Number.isFinite(created) ? Math.floor(created / 1000) : Math.floor(mtimeMs / 1000),
+    updatedAt: Math.floor(mtimeMs / 1000),
+    recencyAt: Math.floor(mtimeMs / 1000),
+    ephemeral: false,
+  };
+}
+
+export function scanCodexSessionThreads({ codexHome = codexHomeForEnv() } = {}) {
+  const sessions = path.join(codexHome, "sessions");
+  return collectSessionFiles(sessions).map(sessionThreadFromFile).filter(Boolean);
+}
+
+function mergeCandidateThreads(serverThreads, sessionThreads, limit) {
+  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 !== "4yi" && !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 || "未知项目");
@@ -201,6 +303,7 @@ export async function migrateCodexTask({
   client,
   clientOptions = {},
   selectThread = selectCodexThread,
+  scanThreads = scanCodexSessionThreads,
 } = {}) {
   if (!session?.token) throw new Error("Not signed in. Run `4yi login`.");
   const selectedModel = model || await loadDefaultCodexModel(session);
@@ -215,13 +318,11 @@ export async function migrateCodexTask({
         limit: Math.max(limit * 3, 30),
         sortKey: "updated_at",
         sortDirection: "desc",
-        useStateDbOnly: true,
       });
-      const candidates = (response?.data || [])
-        .filter((thread) => thread?.id && thread.modelProvider !== "4yi" && !thread.ephemeral)
-        .slice(0, limit);
+      const sessionThreads = scanThreads({ codexHome: codexHomeForEnv(clientOptions.env || process.env) });
+      const candidates = mergeCandidateThreads(response?.data || [], sessionThreads, limit);
       if (candidates.length === 0) {
-        throw new Error("没有找到可迁移的旧 Codex 任务。新任务已经会默认使用 4YI。");
+        throw new Error("没有自动找到可迁移的旧 Codex 任务。新任务已经会默认使用 4YI；如已知任务 ID，可运行 `4yi migrate codex --thread <任务ID>`。");
       }
       selected = await selectThread(candidates, { input, output });
       if (!selected) {
@@ -230,7 +331,7 @@ export async function migrateCodexTask({
       }
     }
 
-    stdout(`正在迁移到 ${selectedModel}…`);
+    stdout(`正在创建新的 4YI 任务（${selectedModel}）…`);
     const result = await appServer.request("thread/fork", {
       threadId: selected.id,
       model: selectedModel,
@@ -251,6 +352,10 @@ export async function migrateCodexTask({
 
 export const __testing = {
   appServerLaunch,
+  codexHomeForEnv,
   loadDefaultCodexModel,
+  mergeCandidateThreads,
   relativeTime,
+  scanCodexSessionThreads,
+  sessionThreadFromFile,
 };

package/src/connect.mjs

@@ -97,10 +97,21 @@ function executableName(command, platform = process.platform) {
   return platform === "win32" ? `${command}.cmd` : command;
 }
 
-function commandAvailable(command, { platform = process.platform, spawn = spawnSync } = {}) {
-  const result = spawn(executableName(command, platform), ["--version"], {
+function commandLaunch(command, args, { platform = process.platform, env = process.env } = {}) {
+  if (platform !== "win32") return { command, args, shell: false };
+  // Avoid Node 24 DEP0190 by invoking cmd.exe explicitly. Every token passed
+  // here is owned by the CLI (tool names, fixed flags, and npm package names),
+  // never user input.
+  const shell = env.ComSpec || env.COMSPEC || "cmd.exe";
+  return { command: shell, args: ["/d", "/s", "/c", `${command} ${args.join(" ")}`], shell: false };
+}
+
+function commandAvailable(command, { platform = process.platform, env = process.env, spawn = spawnSync } = {}) {
+  const launch = commandLaunch(executableName(command, platform), ["--version"], { platform, env });
+  const result = spawn(launch.command, launch.args, {
     encoding: "utf8",
-    shell: platform === "win32",
+    env,
+    shell: launch.shell,
     stdio: "ignore",
   });
   return !result.error && result.status === 0;
@@ -123,29 +134,32 @@ async function ensureToolCli(target, {
   input = process.stdin,
   output = process.stdout,
   platform = process.platform,
+  env = process.env,
   spawn = spawnSync,
   stdout = console.log,
 } = {}) {
   const meta = TOOL_METADATA[target];
-  if (commandAvailable(meta.command, { platform, spawn })) return { installed: false };
+  if (commandAvailable(meta.command, { platform, env, spawn })) return { installed: false };
 
   const approved = autoInstall || await confirmInstall(meta, { input, output });
   if (!approved) {
     throw new Error(`${meta.label} CLI is required. Install it with \`npm install -g ${meta.npmPackage}\`, then run this command again.`);
   }
-  if (!commandAvailable("npm", { platform, spawn })) {
+  if (!commandAvailable("npm", { platform, env, spawn })) {
     throw new Error(`npm is required to install ${meta.label} CLI automatically. Install Node.js/npm, then run this command again.`);
   }
 
   stdout(`Installing ${meta.label} CLI (${meta.npmPackage})...`);
-  const result = spawn(executableName("npm", platform), ["install", "-g", meta.npmPackage], {
-    shell: platform === "win32",
+  const launch = commandLaunch(executableName("npm", platform), ["install", "-g", meta.npmPackage], { platform, env });
+  const result = spawn(launch.command, launch.args, {
+    env,
+    shell: launch.shell,
     stdio: "inherit",
   });
   if (result.error || result.status !== 0) {
     throw new Error(`Could not install ${meta.label} CLI automatically. Run \`npm install -g ${meta.npmPackage}\` and try again.`);
   }
-  if (!commandAvailable(meta.command, { platform, spawn })) {
+  if (!commandAvailable(meta.command, { platform, env, spawn })) {
     throw new Error(`${meta.label} CLI was installed, but \`${meta.command}\` is not available in this terminal. Open a new terminal and run this command again.`);
   }
   stdout(`${meta.label} CLI installed.`);
@@ -202,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;
   }
@@ -235,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) {
@@ -448,9 +478,10 @@ function escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
-function parseBundledCatalog({ platform = process.platform, spawn = spawnSync } = {}) {
+function parseBundledCatalog({ platform = process.platform, env = process.env, spawn = spawnSync } = {}) {
   const command = executableName("codex", platform);
-  const result = spawn(command, ["debug", "models", "--bundled"], { encoding: "utf8", shell: platform === "win32" });
+  const launch = commandLaunch(command, ["debug", "models", "--bundled"], { platform, env });
+  const result = spawn(launch.command, launch.args, { encoding: "utf8", env, shell: launch.shell });
   if (result.status !== 0 || !result.stdout) throw new Error("Codex CLI is required to build its 4YI model catalog. Install Codex, then run this command again.");
   const catalog = JSON.parse(result.stdout);
   const template = catalog.models?.find((model) => model.slug === "gpt-5.5") || catalog.models?.[0];
@@ -551,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);
@@ -569,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) {
@@ -669,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}`);
@@ -693,6 +732,7 @@ export const __testing = {
   buildCodexCatalog,
   checkCodex,
   commandAvailable,
+  commandLaunch,
   desktopAppCandidates,
   ensureToolCli,
   executableName,