codex-slot 0.1.8 → 0.1.17

package/dist/app/service-lifecycle-service.js

@@ -11,9 +11,13 @@ const node_net_1 = __importDefault(require("node:net"));
 const node_path_1 = __importDefault(require("node:path"));
 const node_child_process_1 = require("node:child_process");
 const undici_1 = require("undici");
+const account_service_1 = require("./account-service");
+const account_store_1 = require("../account-store");
 const codex_config_1 = require("../codex-config");
+const codex_auth_1 = require("../codex-auth");
 const cli_helpers_1 = require("../cli-helpers");
 const config_1 = require("../config");
+const scheduler_1 = require("../scheduler");
 const STARTUP_POLL_INTERVAL_MS = 100;
 const STARTUP_TIMEOUT_MS = 5000;
 /**
@@ -163,6 +167,41 @@ function rollbackFailedStart(pid, previousConfig) {
     node_fs_1.default.rmSync((0, config_1.getPidPath)(), { force: true });
     (0, config_1.saveConfig)(previousConfig);
     (0, codex_config_1.deactivateManagedCodexConfig)();
+    (0, codex_auth_1.deactivateManagedCodexAuth)();
+}
+/**
+ * 选择一个可用于接管主 `~/.codex` 登录态的账号。
+ *
+ * 业务规则：
+ * 1. 优先复用当前调度器已经选中的最佳账号，保证 CLI 与代理请求走同一身份。
+ * 2. 若当前没有可调度账号，则回退到首个启用且本地工作空间仍存在的账号。
+ * 3. 若仍无可用账号，则返回 `null`，此时仅接管 provider 配置，不强行覆盖主登录态。
+ *
+ * @returns 选中的受管账号；若不存在可接管账号则返回 `null`。
+ * @throws 无显式抛出。
+ */
+function resolveManagedAuthAccount() {
+    const selected = (0, scheduler_1.pickBestAccount)()?.account;
+    if (selected && (0, account_store_1.hasCompleteCodexAuthState)(selected.codex_home)) {
+        return selected;
+    }
+    return ((0, account_service_1.listAccounts)().find((account) => account.enabled &&
+        node_fs_1.default.existsSync(account.codex_home) &&
+        (0, account_store_1.hasCompleteCodexAuthState)(account.codex_home)) ?? null);
+}
+/**
+ * 将主 `~/.codex` 登录态切换到当前受管账号，供 `codex_apps` 等依赖主登录态的链路复用。
+ *
+ * @returns 实际接管的账号；若没有合适账号则返回 `null`。
+ * @throws 当目标账号目录缺少完整登录态时抛出异常。
+ */
+function applyManagedAuthIfPossible() {
+    const account = resolveManagedAuthAccount();
+    if (!account) {
+        return null;
+    }
+    (0, codex_auth_1.applyManagedCodexAuth)(account.codex_home, { sourceAccountId: account.id });
+    return account;
 }
 /**
  * 为后台服务挑选最终启动端口。
@@ -225,6 +264,7 @@ async function startManagedService(portOverride) {
     // 每次真正启动服务前都轮换一次本地 api_key，并让受管 config.toml 使用同一新值。
     const persistedConfig = (0, config_1.rotateServerApiKey)(config);
     (0, codex_config_1.applyManagedCodexConfig)(undefined, { config: persistedConfig });
+    applyManagedAuthIfPossible();
     const logPath = (0, config_1.getServiceLogPath)();
     const logFd = node_fs_1.default.openSync(logPath, "a");
     const serveEntrypoint = resolveServeEntrypoint();
@@ -267,10 +307,12 @@ function stopManagedService() {
     const pid = getRunningPid();
     if (!pid) {
         (0, codex_config_1.deactivateManagedCodexConfig)();
+        (0, codex_auth_1.deactivateManagedCodexAuth)();
         return { stoppedPid: null };
     }
     process.kill(pid, "SIGTERM");
     node_fs_1.default.rmSync((0, config_1.getPidPath)(), { force: true });
     (0, codex_config_1.deactivateManagedCodexConfig)();
+    (0, codex_auth_1.deactivateManagedCodexAuth)();
     return { stoppedPid: pid };
 }

package/dist/codex-auth.js

@@ -0,0 +1,134 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultCodexHome = getDefaultCodexHome;
+exports.applyManagedCodexAuth = applyManagedCodexAuth;
+exports.deactivateManagedCodexAuth = deactivateManagedCodexAuth;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const account_store_1 = require("./account-store");
+const state_1 = require("./state");
+/**
+ * 返回默认的 Codex HOME 目录。
+ *
+ * @returns 当前进程 HOME；未设置时返回空字符串。
+ */
+function getDefaultCodexHome() {
+    return process.env.HOME ?? "";
+}
+/**
+ * 读取目标 HOME 下 `.codex/accounts` 目录中的所有 `.auth.json` 文件内容。
+ *
+ * @param codexHome 目标 HOME 目录。
+ * @returns 文件名到原始文本的映射；目录不存在时返回空对象。
+ */
+function snapshotAccountAuthFiles(codexHome) {
+    const accountsDir = node_path_1.default.join((0, account_store_1.getCodexDataDir)(codexHome), "accounts");
+    if (!node_fs_1.default.existsSync(accountsDir)) {
+        return {};
+    }
+    const snapshots = {};
+    for (const entry of node_fs_1.default.readdirSync(accountsDir, { withFileTypes: true })) {
+        if (!entry.isFile() || !entry.name.endsWith(".auth.json")) {
+            continue;
+        }
+        snapshots[entry.name] = node_fs_1.default.readFileSync(node_path_1.default.join(accountsDir, entry.name), "utf8");
+    }
+    return snapshots;
+}
+/**
+ * 基于当前目标 HOME 生成登录态恢复快照。
+ *
+ * @param targetHome 需要接管的主 HOME 目录。
+ * @param sourceAccountId 可选的来源账号标识，仅用于状态记录。
+ * @returns 用于 stop 恢复的快照。
+ */
+function buildManagedAuthSnapshot(targetHome, sourceAccountId) {
+    const codexDir = (0, account_store_1.getCodexDataDir)(targetHome);
+    const authPath = node_path_1.default.join(codexDir, "auth.json");
+    const registryPath = node_path_1.default.join(codexDir, "accounts", "registry.json");
+    return {
+        target_home: targetHome,
+        source_account_id: sourceAccountId ?? null,
+        original_auth_file: node_fs_1.default.existsSync(authPath) ? node_fs_1.default.readFileSync(authPath, "utf8") : null,
+        original_registry_file: node_fs_1.default.existsSync(registryPath) ? node_fs_1.default.readFileSync(registryPath, "utf8") : null,
+        original_account_auth_files: snapshotAccountAuthFiles(targetHome)
+    };
+}
+/**
+ * 将指定文件恢复为快照内容；快照为空时删除目标文件。
+ *
+ * @param targetFile 目标文件路径。
+ * @param content 原始文件内容；为 `null` 时表示恢复为不存在。
+ * @returns 无返回值。
+ */
+function restoreSnapshotFile(targetFile, content) {
+    if (content === null) {
+        node_fs_1.default.rmSync(targetFile, { force: true });
+        return;
+    }
+    node_fs_1.default.mkdirSync(node_path_1.default.dirname(targetFile), { recursive: true });
+    node_fs_1.default.writeFileSync(targetFile, content, "utf8");
+}
+/**
+ * 将主 HOME 中多余的 `.auth.json` 文件删除，再恢复快照中记录的文件集合。
+ *
+ * @param targetHome 目标 HOME 目录。
+ * @param snapshot 登录态快照。
+ * @returns 无返回值。
+ */
+function restoreAccountAuthFiles(targetHome, snapshot) {
+    const accountsDir = node_path_1.default.join((0, account_store_1.getCodexDataDir)(targetHome), "accounts");
+    node_fs_1.default.mkdirSync(accountsDir, { recursive: true });
+    for (const entry of node_fs_1.default.readdirSync(accountsDir, { withFileTypes: true })) {
+        if (!entry.isFile() || !entry.name.endsWith(".auth.json")) {
+            continue;
+        }
+        if (!(entry.name in snapshot.original_account_auth_files)) {
+            node_fs_1.default.rmSync(node_path_1.default.join(accountsDir, entry.name), { force: true });
+        }
+    }
+    for (const [fileName, content] of Object.entries(snapshot.original_account_auth_files)) {
+        restoreSnapshotFile(node_path_1.default.join(accountsDir, fileName), content);
+    }
+}
+/**
+ * 将主 `~/.codex` 登录态切换到指定受管账号，供 `codex_apps` 等依赖主登录态的能力复用。
+ *
+ * @param sourceHome 来源账号 HOME。
+ * @param options 可选控制项；可指定目标 HOME 与来源账号标识。
+ * @returns 实际接管的目标 HOME 路径。
+ */
+function applyManagedCodexAuth(sourceHome, options) {
+    const targetHome = options?.targetHome ?? getDefaultCodexHome();
+    const previousState = (0, state_1.getManagedCodexAuthState)();
+    const snapshot = previousState && previousState.target_home === targetHome
+        ? previousState
+        : buildManagedAuthSnapshot(targetHome, options?.sourceAccountId);
+    (0, account_store_1.cloneCodexAuthState)(sourceHome, targetHome);
+    (0, state_1.setManagedCodexAuthState)({
+        ...snapshot,
+        source_account_id: options?.sourceAccountId ?? snapshot.source_account_id ?? null
+    });
+    return targetHome;
+}
+/**
+ * 恢复主 `~/.codex` 登录态到 cslot 接管前的原始状态。
+ *
+ * @returns 恢复的目标 HOME 路径；若没有接管快照则返回 `null`。
+ */
+function deactivateManagedCodexAuth() {
+    const snapshot = (0, state_1.getManagedCodexAuthState)();
+    if (!snapshot) {
+        return null;
+    }
+    const targetHome = snapshot.target_home;
+    const codexDir = (0, account_store_1.getCodexDataDir)(targetHome);
+    restoreSnapshotFile(node_path_1.default.join(codexDir, "auth.json"), snapshot.original_auth_file);
+    restoreSnapshotFile(node_path_1.default.join(codexDir, "accounts", "registry.json"), snapshot.original_registry_file);
+    restoreAccountAuthFiles(targetHome, snapshot);
+    (0, state_1.clearManagedCodexAuthState)();
+    return targetHome;
+}

package/dist/codex-config.js

@@ -73,9 +73,31 @@ function buildManagedProviderBlock(eol, config) {
         `base_url = "http://${config.server.host}:${config.server.port}/v1"`,
         'wire_api = "responses"',
         `experimental_bearer_token = "${config.server.api_key}"`,
+        "[model_providers.cslot.http_headers]",
+        `Authorization = "Bearer ${config.server.api_key}"`,
         PROVIDER_BLOCK_END_MARKER
     ].join(eol);
 }
+/**
+ * 判断候选表头是否属于指定父表的子表。
+ *
+ * @param parentHeader 父表表头，例如 `[model_providers.cslot]`。
+ * @param candidateHeader 当前扫描到的候选表头。
+ * @returns `true` 表示候选表头属于父表子表；否则返回 `false`。
+ */
+function isChildTableHeader(parentHeader, candidateHeader) {
+    const normalizedParent = parentHeader.trim();
+    const normalizedCandidate = candidateHeader.trim();
+    if (!normalizedParent.startsWith("[") || !normalizedParent.endsWith("]")) {
+        return false;
+    }
+    if (!normalizedCandidate.startsWith("[") || !normalizedCandidate.endsWith("]")) {
+        return false;
+    }
+    const parentName = normalizedParent.slice(1, -1);
+    const candidateName = normalizedCandidate.slice(1, -1);
+    return candidateName.startsWith(`${parentName}.`);
+}
 /**
  * 在文本中定位受 cslot 接管的块范围。
  *
@@ -103,29 +125,22 @@ function findMarkedBlockRange(content, startMarker, endMarker) {
     return { start, end };
 }
 /**
- * 恢复文本中由 cslot 管理的配置块，得到接管前的原始内容基线。
+ * 反复移除文本中所有带指定标记的受管块，避免异常退出后残留旧块导致后续写入出现重复或串位。
  *
  * @param content 当前 `config.toml` 内容。
- * @param managedState 上一次接管时保存的原始片段快照。
- * @returns 恢复后的文本内容。
+ * @param startMarker 块起始标记。
+ * @param endMarker 块结束标记。
+ * @returns 清理后的文本内容。
  */
-function restoreManagedContent(content, managedState) {
-    let restored = content;
-    const providerRange = findMarkedBlockRange(restored, PROVIDER_BLOCK_START_MARKER, PROVIDER_BLOCK_END_MARKER);
-    if (providerRange) {
-        restored =
-            restored.slice(0, providerRange.start) +
-                (managedState.original_cslot_provider_block ?? "") +
-                restored.slice(providerRange.end);
-    }
-    const modelProviderRange = findMarkedBlockRange(restored, MODEL_PROVIDER_START_MARKER, MODEL_PROVIDER_END_MARKER);
-    if (modelProviderRange) {
-        restored =
-            restored.slice(0, modelProviderRange.start) +
-                (managedState.original_model_provider_block ?? "") +
-                restored.slice(modelProviderRange.end);
+function stripMarkedBlocks(content, startMarker, endMarker) {
+    let stripped = content;
+    while (true) {
+        const range = findMarkedBlockRange(stripped, startMarker, endMarker);
+        if (!range) {
+            return stripped;
+        }
+        stripped = stripped.slice(0, range.start) + stripped.slice(range.end);
     }
-    return restored;
 }
 /**
  * 查找首个 `model_provider` 配置块，兼容已启用与注释掉的场景。
@@ -183,12 +198,13 @@ function findModelProviderLine(content) {
     return null;
 }
 /**
- * 查找 `[model_providers.cslot]` 表块的文本范围。
+ * 查找指定表块的文本范围。
  *
  * @param content 当前 `config.toml` 内容。
+ * @param header 目标表头，例如 `[model_providers.cslot]`。
  * @returns 命中时返回完整表块范围；未命中返回 `null`。
  */
-function findProviderSectionRange(content) {
+function findTableSectionRange(content, header) {
     const lines = content.split(/\r?\n/);
     let offset = 0;
     let startLineIndex = -1;
@@ -196,7 +212,7 @@ function findProviderSectionRange(content) {
     for (let i = 0; i < lines.length; i += 1) {
         const line = lines[i];
         const lineEnd = offset + line.length;
-        if (line.trim() === "[model_providers.cslot]") {
+        if (line.trim() === header) {
             startLineIndex = i;
             startOffset = offset;
             break;
@@ -212,7 +228,10 @@ function findProviderSectionRange(content) {
         const line = lines[i];
         const lineEnd = offset + line.length;
         const trimmed = line.trim();
-        if (i > startLineIndex && trimmed.startsWith("[") && !trimmed.startsWith("[[")) {
+        if (i > startLineIndex &&
+            trimmed.startsWith("[") &&
+            !trimmed.startsWith("[[") &&
+            !isChildTableHeader(header, trimmed)) {
             break;
         }
         endOffset = lineEnd;
@@ -234,6 +253,164 @@ function findProviderSectionRange(content) {
         value: content.slice(startOffset, endOffset)
     };
 }
+/**
+ * 查找 `[model_providers.cslot]` 表块的文本范围。
+ *
+ * @param content 当前 `config.toml` 内容。
+ * @returns 命中时返回完整表块范围；未命中返回 `null`。
+ */
+function findProviderSectionRange(content) {
+    return findTableSectionRange(content, "[model_providers.cslot]");
+}
+/**
+ * 查找指定表头所在的行起始偏移。
+ *
+ * @param content 当前 `config.toml` 内容。
+ * @param header 目标表头。
+ * @returns 命中时返回表头行起始偏移；未命中返回 `null`。
+ */
+function findTableHeaderOffset(content, header) {
+    const lines = content.split(/\r?\n/);
+    let offset = 0;
+    for (const line of lines) {
+        const lineEnd = offset + line.length;
+        if (line.trim() === header) {
+            return offset;
+        }
+        offset = lineEnd + (content.slice(lineEnd, lineEnd + 2) === "\r\n" ? 2 : 1);
+    }
+    return null;
+}
+/**
+ * 查找指定偏移之前最近的表头，供恢复原有表块位置时作为后备锚点。
+ *
+ * @param content 当前 `config.toml` 内容。
+ * @param offset 截止偏移。
+ * @returns 最近的表头文本；未命中返回 `null`。
+ */
+function findPreviousTableHeaderBeforeOffset(content, offset) {
+    const lines = content.split(/\r?\n/);
+    let currentOffset = 0;
+    let previousHeader = null;
+    for (const line of lines) {
+        const lineEnd = currentOffset + line.length;
+        const trimmed = line.trim();
+        if (currentOffset >= offset) {
+            break;
+        }
+        if (trimmed.startsWith("[") && !trimmed.startsWith("[[") && !trimmed.startsWith("#")) {
+            previousHeader = trimmed;
+        }
+        currentOffset = lineEnd + (content.slice(lineEnd, lineEnd + 2) === "\r\n" ? 2 : 1);
+    }
+    return previousHeader;
+}
+/**
+ * 查找指定偏移之后的首个表头，供恢复原有表块位置时作为优先锚点。
+ *
+ * @param content 当前 `config.toml` 内容。
+ * @param offset 起始偏移。
+ * @returns 首个后续表头文本；未命中返回 `null`。
+ */
+function findNextTableHeaderAfterOffset(content, offset) {
+    const lines = content.split(/\r?\n/);
+    let currentOffset = 0;
+    for (const line of lines) {
+        const lineEnd = currentOffset + line.length;
+        const trimmed = line.trim();
+        if (currentOffset >= offset &&
+            trimmed.startsWith("[") &&
+            !trimmed.startsWith("[[") &&
+            !trimmed.startsWith("#")) {
+            return trimmed;
+        }
+        currentOffset = lineEnd + (content.slice(lineEnd, lineEnd + 2) === "\r\n" ? 2 : 1);
+    }
+    return null;
+}
+/**
+ * 清理文本中的所有 `model_provider` 配置块，确保每次接管都以单一稳定块重新写入。
+ *
+ * @param content 当前 `config.toml` 内容。
+ * @returns 移除后的文本内容。
+ */
+function removeAllModelProviderLines(content) {
+    let nextContent = content;
+    while (true) {
+        const range = findModelProviderLine(nextContent);
+        if (!range) {
+            return nextContent;
+        }
+        nextContent = nextContent.slice(0, range.start) + nextContent.slice(range.end);
+    }
+}
+/**
+ * 清理文本中的所有 `[model_providers.cslot]` 表块，避免残留旧块影响下一段配置。
+ *
+ * @param content 当前 `config.toml` 内容。
+ * @returns 移除后的文本内容。
+ */
+function removeAllProviderSections(content) {
+    let nextContent = content;
+    while (true) {
+        const range = findProviderSectionRange(nextContent);
+        if (!range) {
+            return nextContent;
+        }
+        nextContent = nextContent.slice(0, range.start) + nextContent.slice(range.end);
+    }
+}
+/**
+ * 移除所有 cslot 受管标记块，得到不包含历史残留接管片段的基线内容。
+ *
+ * @param content 当前 `config.toml` 内容。
+ * @returns 清理后的基线内容。
+ */
+function stripAllManagedBlocks(content) {
+    const withoutProviderBlock = stripMarkedBlocks(content, PROVIDER_BLOCK_START_MARKER, PROVIDER_BLOCK_END_MARKER);
+    return stripMarkedBlocks(withoutProviderBlock, MODEL_PROVIDER_START_MARKER, MODEL_PROVIDER_END_MARKER);
+}
+/**
+ * 查找根级配置区的尾部插入点。
+ *
+ * 业务规则：
+ * 1. 若文件中存在 table header，则插入到首个 table 之前，保证 `model_provider` 仍处于根级作用域。
+ * 2. 若文件不存在任何 table，则允许直接追加到文件尾部。
+ *
+ * @param content 当前 `config.toml` 内容。
+ * @returns 可用于插入根级配置块的偏移位置。
+ */
+function findRootSectionInsertOffset(content) {
+    const lines = content.split(/\r?\n/);
+    let offset = 0;
+    for (const line of lines) {
+        const lineEnd = offset + line.length;
+        const trimmed = line.trim();
+        if (trimmed.startsWith("[") && !trimmed.startsWith("#")) {
+            return offset;
+        }
+        offset = lineEnd + (content.slice(lineEnd, lineEnd + 2) === "\r\n" ? 2 : 1);
+    }
+    return content.length;
+}
+/**
+ * 将根级配置块插回根级区域。
+ *
+ * 若能命中原始记录的后续表头，则优先插回该表头前；否则回退到首个表头前。
+ *
+ * @param content 当前 `config.toml` 内容。
+ * @param block 待插入的根级配置块。
+ * @param eol 目标换行符。
+ * @param preferredNextTableHeader 原始记录的后续表头锚点。
+ * @returns 插入后的完整文本。
+ */
+function insertRootBlock(content, block, eol, preferredNextTableHeader) {
+    const preferredOffset = preferredNextTableHeader
+        ? findTableHeaderOffset(content, preferredNextTableHeader)
+        : null;
+    const insertOffset = preferredOffset ?? findRootSectionInsertOffset(content);
+    return insertBlockBetween(content.slice(0, insertOffset), block, content.slice(insertOffset), eol);
+}
 /**
  * 将指定文本规范为单个块插入形式，避免在块两侧不断叠加多余空行。
  *
@@ -248,6 +425,103 @@ function insertBlockBetween(before, block, after, eol) {
     const normalizedAfter = after.startsWith(eol) || after.length === 0 ? after : `${eol}${after}`;
     return `${normalizedBefore}${block}${normalizedAfter}`;
 }
+/**
+ * 将配置块稳定追加到文件尾部，统一清理尾部多余空行，避免多次接管后空行不断累积。
+ *
+ * @param content 当前 `config.toml` 内容。
+ * @param block 待追加配置块。
+ * @param eol 目标换行符。
+ * @returns 追加后的完整文本。
+ */
+function appendBlockToEnd(content, block, eol) {
+    let trimmed = content;
+    while (trimmed.endsWith(eol)) {
+        trimmed = trimmed.slice(0, -eol.length);
+    }
+    if (trimmed.length === 0) {
+        return `${block}${eol}`;
+    }
+    return `${trimmed}${eol}${eol}${block}${eol}`;
+}
+/**
+ * 将表块尽量插回原有相邻表头附近；若锚点已不存在，则退回文件尾部追加。
+ *
+ * @param content 当前 `config.toml` 内容。
+ * @param block 待插入的表块。
+ * @param eol 目标换行符。
+ * @param preferredNextTableHeader 原始后续表头锚点，命中时优先插到该表之前。
+ * @param preferredPreviousTableHeader 原始前驱表头锚点，当前者失效时插到该表之后。
+ * @returns 插入后的完整文本。
+ */
+function insertTableBlock(content, block, eol, preferredNextTableHeader, preferredPreviousTableHeader) {
+    if (preferredNextTableHeader) {
+        const nextOffset = findTableHeaderOffset(content, preferredNextTableHeader);
+        if (nextOffset !== null) {
+            return insertBlockBetween(content.slice(0, nextOffset), block, content.slice(nextOffset), eol);
+        }
+    }
+    if (preferredPreviousTableHeader) {
+        const previousRange = findTableSectionRange(content, preferredPreviousTableHeader);
+        if (previousRange) {
+            return insertBlockBetween(content.slice(0, previousRange.end), block, content.slice(previousRange.end), eol);
+        }
+    }
+    return appendBlockToEnd(content, block, eol);
+}
+/**
+ * 解析当前目标文件对应的上一轮接管快照。
+ *
+ * @param targetFile 当前准备接管或恢复的 `config.toml` 路径。
+ * @returns 命中同一目标文件时返回上一轮快照；否则返回 `null`。
+ */
+function resolveManagedStateForTarget(targetFile) {
+    const managedState = (0, state_1.getManagedCodexConfigState)();
+    if (!managedState || managedState.target_file !== targetFile) {
+        return null;
+    }
+    return managedState;
+}
+/**
+ * 基于当前未受管的配置文本与上一轮快照，生成本轮接管所需的最小恢复快照。
+ *
+ * 业务规则：
+ * 1. 优先记录当前文件里实际存在的原始 `model_provider` 与 `[model_providers.cslot]`。
+ * 2. 若当前文件只剩残留受管块，允许继承上一轮快照中的原始片段。
+ * 3. 仅保存 cslot 自己声明所有权的两块配置及其锚点，不保存整文件内容。
+ *
+ * @param targetFile 当前准备接管的 `config.toml` 路径。
+ * @param strippedCurrent 已移除受管标记块后的配置文本。
+ * @param previousManagedState 同一目标文件的上一轮快照；不存在时传 `null`。
+ * @returns 本轮接管后用于 stop 恢复的快照。
+ */
+function buildManagedSnapshot(targetFile, strippedCurrent, previousManagedState) {
+    const originalModelProviderLine = findModelProviderLine(strippedCurrent);
+    const originalProviderSection = findProviderSectionRange(strippedCurrent);
+    return {
+        target_file: targetFile,
+        original_model_provider_block: originalModelProviderLine?.value ??
+            previousManagedState?.original_model_provider_block ??
+            null,
+        original_model_provider_next_table_header: (originalModelProviderLine
+            ? findNextTableHeaderAfterOffset(strippedCurrent, originalModelProviderLine.end)
+            : null) ??
+            previousManagedState?.original_model_provider_next_table_header ??
+            null,
+        original_cslot_provider_block: originalProviderSection?.value ??
+            previousManagedState?.original_cslot_provider_block ??
+            null,
+        original_cslot_provider_previous_table_header: (originalProviderSection
+            ? findPreviousTableHeaderBeforeOffset(strippedCurrent, originalProviderSection.start)
+            : null) ??
+            previousManagedState?.original_cslot_provider_previous_table_header ??
+            null,
+        original_cslot_provider_next_table_header: (originalProviderSection
+            ? findNextTableHeaderAfterOffset(strippedCurrent, originalProviderSection.end)
+            : null) ??
+            previousManagedState?.original_cslot_provider_next_table_header ??
+            null
+    };
+}
 /**
  * 将 cslot 需要的 provider 配置写入指定 `config.toml`，并保存恢复快照。
  *
@@ -260,51 +534,16 @@ function applyManagedCodexConfig(targetPathOrDir, options) {
     const rawTarget = targetPathOrDir ? (0, config_1.expandHome)(targetPathOrDir) : getDefaultCodexConfigPath();
     const targetFile = rawTarget.endsWith(".toml") ? rawTarget : node_path_1.default.join(rawTarget, "config.toml");
     const current = node_fs_1.default.existsSync(targetFile) ? node_fs_1.default.readFileSync(targetFile, "utf8") : "";
-    const previousManagedState = (0, state_1.getManagedCodexConfigState)();
-    const baseContent = previousManagedState && previousManagedState.target_file === targetFile
-        ? restoreManagedContent(current, previousManagedState)
-        : current;
-    const eol = detectEol(baseContent);
-    const originalModelProviderLine = findModelProviderLine(baseContent);
-    const originalProviderSection = findProviderSectionRange(baseContent);
-    const snapshot = {
-        target_file: targetFile,
-        original_model_provider_block: originalModelProviderLine?.value ?? null,
-        original_cslot_provider_block: originalProviderSection?.value ?? null
-    };
+    const previousManagedState = resolveManagedStateForTarget(targetFile);
+    const strippedCurrent = stripAllManagedBlocks(current);
+    const eol = detectEol(strippedCurrent);
+    const snapshot = buildManagedSnapshot(targetFile, strippedCurrent, previousManagedState);
     const config = options?.config ?? (0, config_1.loadConfig)();
-    let nextContent = baseContent;
     const managedModelProviderBlock = buildManagedModelProviderBlock(eol);
     const managedProviderBlock = buildManagedProviderBlock(eol, config);
-    // 先处理 provider 表块，再处理 model_provider 行，避免前面的插入导致后续偏移失效。
-    if (originalProviderSection) {
-        nextContent =
-            nextContent.slice(0, originalProviderSection.start) +
-                managedProviderBlock +
-                nextContent.slice(originalProviderSection.end);
-    }
-    else if (nextContent.length > 0) {
-        nextContent = insertBlockBetween(nextContent, managedProviderBlock, "", eol);
-    }
-    else {
-        nextContent = `${managedProviderBlock}${eol}`;
-    }
-    const modelProviderLine = findModelProviderLine(nextContent);
-    if (modelProviderLine) {
-        nextContent =
-            nextContent.slice(0, modelProviderLine.start) +
-                managedModelProviderBlock +
-                nextContent.slice(modelProviderLine.end);
-    }
-    else {
-        const firstNonWhitespaceMatch = nextContent.match(/\S/);
-        if (firstNonWhitespaceMatch && firstNonWhitespaceMatch.index !== undefined) {
-            nextContent = insertBlockBetween(nextContent.slice(0, firstNonWhitespaceMatch.index), managedModelProviderBlock, nextContent.slice(firstNonWhitespaceMatch.index), eol);
-        }
-        else {
-            nextContent = `${managedModelProviderBlock}${eol}`;
-        }
-    }
+    const cleanedBaseContent = removeAllProviderSections(removeAllModelProviderLines(strippedCurrent));
+    let nextContent = insertRootBlock(cleanedBaseContent, managedModelProviderBlock, eol, snapshot.original_model_provider_next_table_header);
+    nextContent = appendBlockToEnd(nextContent, managedProviderBlock, eol);
     if (!nextContent.endsWith(eol)) {
         nextContent = `${nextContent}${eol}`;
     }
@@ -335,7 +574,16 @@ function deactivateManagedCodexConfig() {
         return null;
     }
     const current = node_fs_1.default.readFileSync(targetFile, "utf8");
-    const restored = restoreManagedContent(current, managedState);
+    const eol = detectEol(current);
+    let restored = stripAllManagedBlocks(current);
+    const existingModelProviderLine = findModelProviderLine(restored);
+    if (!existingModelProviderLine && managedState.original_model_provider_block) {
+        restored = insertRootBlock(restored, managedState.original_model_provider_block, eol, managedState.original_model_provider_next_table_header);
+    }
+    const existingProviderSection = findProviderSectionRange(restored);
+    if (!existingProviderSection && managedState.original_cslot_provider_block) {
+        restored = insertTableBlock(restored, managedState.original_cslot_provider_block, eol, managedState.original_cslot_provider_next_table_header, managedState.original_cslot_provider_previous_table_header);
+    }
     writeFileAtomic(targetFile, restored);
     (0, state_1.clearManagedCodexConfigState)();
     return targetFile;

package/dist/state.js

@@ -10,9 +10,15 @@ exports.pruneExpiredBlocks = pruneExpiredBlocks;
 exports.getAccountBlock = getAccountBlock;
 exports.setUsageCache = setUsageCache;
 exports.getUsageCache = getUsageCache;
+exports.setUsageRefreshError = setUsageRefreshError;
+exports.clearUsageRefreshError = clearUsageRefreshError;
+exports.getUsageRefreshError = getUsageRefreshError;
 exports.getManagedCodexConfigState = getManagedCodexConfigState;
+exports.getManagedCodexAuthState = getManagedCodexAuthState;
 exports.setManagedCodexConfigState = setManagedCodexConfigState;
+exports.setManagedCodexAuthState = setManagedCodexAuthState;
 exports.clearManagedCodexConfigState = clearManagedCodexConfigState;
+exports.clearManagedCodexAuthState = clearManagedCodexAuthState;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const config_1 = require("./config");
@@ -30,6 +36,8 @@ function loadState() {
         return {
             account_blocks: {},
             usage_cache: {},
+            usage_refresh_errors: {},
+            managed_codex_auth: null,
             managed_codex_config: null
         };
     }
@@ -39,11 +47,15 @@ function loadState() {
         : {
             account_blocks: {},
             usage_cache: {},
+            usage_refresh_errors: {},
+            managed_codex_auth: null,
             managed_codex_config: null
         };
     return {
         account_blocks: parsed.account_blocks ?? {},
         usage_cache: parsed.usage_cache ?? {},
+        usage_refresh_errors: parsed.usage_refresh_errors ?? {},
+        managed_codex_auth: parsed.managed_codex_auth ?? null,
         managed_codex_config: parsed.managed_codex_config ?? null
     };
 }
@@ -125,6 +137,41 @@ function getUsageCache(accountId) {
     const state = loadState();
     return state.usage_cache[accountId] ?? null;
 }
+/**
+ * 记录指定账号最近一次额度刷新失败的状态，供 `status` 命令渲染为账号状态而不是直接打印异常。
+ *
+ * @param usageError 刷新失败信息，包含账号、状态码与原始错误摘要。
+ * @returns 无返回值。
+ */
+function setUsageRefreshError(usageError) {
+    const state = loadState();
+    state.usage_refresh_errors[usageError.accountId] = usageError;
+    saveState(state);
+}
+/**
+ * 清理指定账号最近一次记录的额度刷新失败状态，避免后续成功刷新后继续展示旧错误。
+ *
+ * @param accountId 账号标识。
+ * @returns 无返回值。
+ */
+function clearUsageRefreshError(accountId) {
+    const state = loadState();
+    if (!(accountId in state.usage_refresh_errors)) {
+        return;
+    }
+    delete state.usage_refresh_errors[accountId];
+    saveState(state);
+}
+/**
+ * 读取指定账号最近一次记录的额度刷新失败状态。
+ *
+ * @param accountId 账号标识。
+ * @returns 刷新失败信息；若不存在则返回 `null`。
+ */
+function getUsageRefreshError(accountId) {
+    const state = loadState();
+    return state.usage_refresh_errors[accountId] ?? null;
+}
 /**
  * 读取当前记录的 Codex `config.toml` 接管快照。
  *
@@ -134,6 +181,15 @@ function getManagedCodexConfigState() {
     const state = loadState();
     return state.managed_codex_config ?? null;
 }
+/**
+ * 读取当前记录的 Codex 主 HOME 登录态接管快照。
+ *
+ * @returns 最近一次接管时保存的登录态快照；不存在时返回 `null`。
+ */
+function getManagedCodexAuthState() {
+    const state = loadState();
+    return state.managed_codex_auth ?? null;
+}
 /**
  * 保存 Codex `config.toml` 接管快照，用于后续停止服务时精确恢复。
  *
@@ -145,6 +201,17 @@ function setManagedCodexConfigState(managedState) {
     state.managed_codex_config = managedState;
     saveState(state);
 }
+/**
+ * 保存 Codex 主 HOME 登录态接管快照，用于 stop 时恢复原始登录态文件。
+ *
+ * @param managedState 接管前保存的原始登录态快照。
+ * @returns 无返回值。
+ */
+function setManagedCodexAuthState(managedState) {
+    const state = loadState();
+    state.managed_codex_auth = managedState;
+    saveState(state);
+}
 /**
  * 清理 Codex `config.toml` 接管快照。
  *
@@ -155,3 +222,13 @@ function clearManagedCodexConfigState() {
     state.managed_codex_config = null;
     saveState(state);
 }
+/**
+ * 清理 Codex 主 HOME 登录态接管快照。
+ *
+ * @returns 无返回值。
+ */
+function clearManagedCodexAuthState() {
+    const state = loadState();
+    state.managed_codex_auth = null;
+    saveState(state);
+}

package/dist/status-command.js

@@ -10,6 +10,87 @@ const status_service_1 = require("./app/status-service");
 const scheduler_1 = require("./scheduler");
 const status_1 = require("./status");
 const text_1 = require("./text");
+const ANSI = {
+    reset: "\x1b[0m",
+    bold: "\x1b[1m",
+    dim: "\x1b[2m",
+    cyan: "\x1b[36m",
+    green: "\x1b[32m",
+    yellow: "\x1b[33m"
+};
+/**
+ * 判断当前终端是否适合启用 ANSI 样式，避免在 dumb/no-color 环境输出控制字符。
+ *
+ * @returns 可安全启用样式时返回 `true`，否则返回 `false`。
+ * @throws 无显式抛出。
+ */
+function shouldUseAnsiStyle() {
+    return Boolean(process.stdout.isTTY) && process.env.NO_COLOR === undefined && process.env.TERM !== "dumb";
+}
+/**
+ * 对文本应用 ANSI 样式；当样式关闭时原样返回。
+ *
+ * @param text 原始文本。
+ * @param color ANSI 颜色码。
+ * @param enabled 是否启用 ANSI 样式。
+ * @returns 样式化后的文本或原文。
+ * @throws 无显式抛出。
+ */
+function paint(text, color, enabled) {
+    if (!enabled) {
+        return text;
+    }
+    return `${color}${text}${ANSI.reset}`;
+}
+/**
+ * 渲染分区标题行，兼容窄终端与普通宽度终端。
+ *
+ * @param title 分区标题文本。
+ * @param width 当前终端宽度。
+ * @param styled 是否启用 ANSI 样式。
+ * @returns 可直接打印的单行分区标题。
+ * @throws 无显式抛出。
+ */
+function renderSectionHeader(title, width, styled) {
+    if (width < 44) {
+        return paint(`[ ${title} ]`, ANSI.cyan, styled);
+    }
+    const plainLabel = ` ${title} `;
+    const targetWidth = Math.max(plainLabel.length + 2, Math.min(width, 96));
+    const side = Math.max(1, Math.floor((targetWidth - plainLabel.length) / 2));
+    const line = `${"-".repeat(side)}${plainLabel}${"-".repeat(side)}`;
+    return paint(line.slice(0, targetWidth), ANSI.cyan, styled);
+}
+/**
+ * 渲染轻量分隔线，用于账号主表与当前账号明细之间建立清晰层次。
+ *
+ * @param width 当前终端宽度。
+ * @param styled 是否启用 ANSI 样式。
+ * @returns 可直接打印的分隔线文本。
+ * @throws 无显式抛出。
+ */
+function renderDivider(width, styled) {
+    const dividerWidth = Math.max(24, Math.min(width, 96));
+    return paint("-".repeat(dividerWidth), ANSI.dim, styled);
+}
+/**
+ * 渲染摘要区可读性更高的计数文本，并对关键指标做轻量着色。
+ *
+ * @param summary 状态摘要计数。
+ * @param narrowScreen 是否窄屏布局。
+ * @param styled 是否启用 ANSI 样式。
+ * @returns 摘要展示文本。
+ * @throws 无显式抛出。
+ */
+function renderSummaryLine(summary, narrowScreen, styled) {
+    const available = paint(String(summary.available), ANSI.green, styled);
+    const fiveHourLimited = paint(String(summary.fiveHourLimited), ANSI.yellow, styled);
+    const weeklyLimited = paint(String(summary.weeklyLimited), ANSI.yellow, styled);
+    if (narrowScreen) {
+        return `ok=${available}  5h=${fiveHourLimited}  wk=${weeklyLimited}`;
+    }
+    return `available=${available}  5h_limited=${fiveHourLimited}  weekly_limited=${weeklyLimited}`;
+}
 /**
  * 进入交互式全屏缓冲区，并隐藏光标，确保后续重绘始终基于固定画布。
  *
@@ -103,6 +184,9 @@ async function handleInteractiveToggle(initialStatuses) {
     return await new Promise((resolve) => {
         let closed = false;
         const render = () => {
+            const screenWidth = process.stdout.columns ?? 80;
+            const narrowScreen = screenWidth < 72;
+            const styled = shouldUseAnsiStyle();
             const latestSnapshot = (0, status_service_1.getStatusSnapshot)();
             const statusSource = changed ? latestSnapshot.statuses : (initialStatuses ?? latestSnapshot.statuses);
             const statusById = new Map(statusSource.map((item) => [item.id, item]));
@@ -120,18 +204,28 @@ async function handleInteractiveToggle(initialStatuses) {
                 };
             })
                 .filter((item) => item !== null);
+            const currentItem = displayStatuses.find((item) => item.id === accounts[cursor]?.id) ?? null;
             renderInteractiveScreen([
+                renderSectionHeader("accounts", screenWidth, styled),
                 (0, status_1.renderStatusTable)(displayStatuses, {
+                    compact: true,
+                    maxWidth: screenWidth,
                     selectorColumn: {
                         enabledById: Object.fromEntries(accounts.map((account) => [account.id, account.enabled])),
                         cursorAccountId: accounts[cursor]?.id ?? null
                     }
                 }),
                 "",
-                `available=${summary.available} 5h_limited=${summary.fiveHourLimited} weekly_limited=${summary.weeklyLimited}`,
+                renderDivider(screenWidth, styled),
+                renderSectionHeader("current", screenWidth, styled),
+                (0, status_1.renderStatusDetails)(currentItem, { maxWidth: screenWidth, header: false }),
+                "",
+                renderSectionHeader("summary", screenWidth, styled),
+                renderSummaryLine(summary, narrowScreen, styled),
                 `selected=${latestSnapshot.selectedName ?? "none"}`,
                 "",
-                (0, text_1.bi)("空格切换当前行启用状态，Enter / q 退出。", "Press Space to toggle the current row, Enter or q to exit.")
+                renderSectionHeader("help", screenWidth, styled),
+                (0, text_1.bi)(narrowScreen ? "Space 切换，Enter / q 退出。" : "Space 切换启用状态，Enter / q 退出。", narrowScreen ? "Space toggles, Enter or q exits." : "Space toggles enabled state, Enter or q exits.")
             ]);
         };
         const applyChanges = () => {

package/dist/status.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.collectAccountStatuses = collectAccountStatuses;
 exports.summarizeAccountStatuses = summarizeAccountStatuses;
 exports.renderStatusTable = renderStatusTable;
+exports.renderStatusDetails = renderStatusDetails;
 const config_1 = require("./config");
 const account_store_1 = require("./account-store");
 const state_1 = require("./state");
@@ -28,6 +29,69 @@ function formatPercent(value) {
 function formatReset(unixSeconds) {
     return (0, text_1.formatLocalDateTime)(unixSeconds);
 }
+/**
+ * 按给定最大宽度截断单元格文本，优先保证表格整体不换行。
+ *
+ * @param value 原始文本。
+ * @param maxWidth 最大宽度。
+ * @returns 截断后的文本；宽度过小时退化为最短可读形式。
+ */
+function truncateCell(value, maxWidth) {
+    if (maxWidth <= 0) {
+        return "";
+    }
+    if (value.length <= maxWidth) {
+        return value;
+    }
+    if (maxWidth <= 2) {
+        return value.slice(0, maxWidth);
+    }
+    return `${value.slice(0, maxWidth - 1)}…`;
+}
+/**
+ * 生成固定标签宽度的详情行，超出终端宽度时自动截断值部分。
+ *
+ * @param label 字段标签。
+ * @param value 字段值。
+ * @param maxWidth 当前可用最大宽度。
+ * @returns 单行详情文本。
+ */
+function formatDetailLine(label, value, maxWidth) {
+    const prefix = `${label.padEnd(6)} `;
+    const safeWidth = Number.isFinite(maxWidth) ? maxWidth : prefix.length + value.length;
+    const valueWidth = Math.max(8, safeWidth - prefix.length);
+    return `${prefix}${truncateCell(value, valueWidth)}`;
+}
+/**
+ * 将状态对象归一化为单个紧凑状态标签，供表格与详情面板复用。
+ *
+ * @param item 单个账号状态。
+ * @returns 适合在终端展示的状态标签。
+ */
+function resolveStatusLabel(item) {
+    if (item.refreshErrorCode) {
+        return item.refreshErrorCode;
+    }
+    if (!item.exists) {
+        return "missing";
+    }
+    if (!item.enabled) {
+        return "disabled";
+    }
+    if (item.localBlockUntil && item.localBlockUntil * 1000 > Date.now()) {
+        return formatBlockedStatus(item.localBlockReason, item.localBlockUntil);
+    }
+    if (item.isWeeklyLimited) {
+        return formatLimitStatus("weekly_limited", item.weeklyResetsAt);
+    }
+    if (item.isFiveHourLimited) {
+        return formatLimitStatus("5h_limited", item.fiveHourResetsAt);
+    }
+    if (item.isAvailable) {
+        return "available";
+    }
+    return "unknown";
+}
 function formatLimitStatus(label, resetAt) {
     const remaining = formatRemainingDuration(resetAt);
     if (!remaining) {
@@ -44,6 +108,46 @@ function normalizeBlockReason(reason) {
     }
     return reason;
 }
+/**
+ * 将账号工作空间读取异常统一归类为状态码，避免状态汇总阶段直接抛出异常中断整个命令。
+ *
+ * @param error 工作空间读取过程中抛出的异常。
+ * @returns 归一化后的状态码与错误摘要。
+ */
+function classifyWorkspaceStatusError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+        code: "workspace_invalid",
+        message
+    };
+}
+/**
+ * 读取账号工作空间的本地登录态摘要；若目录损坏或 JSON 非法，则降级为工作空间不可用状态。
+ *
+ * @param codexHome 账号隔离 HOME 目录。
+ * @returns 是否存在完整登录态、主账号信息以及可选的工作空间错误状态。
+ */
+function readWorkspaceSnapshot(codexHome) {
+    try {
+        const exists = (0, account_store_1.hasCompleteCodexAuthState)(codexHome);
+        const primary = exists ? (0, account_store_1.resolvePrimaryRegistryAccount)(codexHome) : null;
+        return {
+            exists,
+            primary,
+            workspaceErrorCode: null,
+            workspaceErrorMessage: null
+        };
+    }
+    catch (error) {
+        const workspaceError = classifyWorkspaceStatusError(error);
+        return {
+            exists: false,
+            primary: null,
+            workspaceErrorCode: workspaceError.code,
+            workspaceErrorMessage: workspaceError.message
+        };
+    }
+}
 /**
  * 将剩余秒数格式化为紧凑的人类可读文本，便于在状态列中展示熔断剩余时间。
  *
@@ -92,10 +196,10 @@ function formatBlockedStatus(reason, until) {
 function collectAccountStatuses() {
     const config = (0, config_1.loadConfig)();
     return config.accounts.map((account) => {
-        const exists = (0, account_store_1.hasCompleteCodexAuthState)(account.codex_home);
-        const primary = exists ? (0, account_store_1.resolvePrimaryRegistryAccount)(account.codex_home) : null;
+        const workspace = readWorkspaceSnapshot(account.codex_home);
         const usageCache = (0, state_1.getUsageCache)(account.id);
-        const activeEmail = usageCache?.email ?? primary?.email ?? account.email;
+        const refreshError = (0, state_1.getUsageRefreshError)(account.id);
+        const activeEmail = usageCache?.email ?? workspace.primary?.email ?? account.email;
         const fiveHourUsed = usageCache?.fiveHourUsedPercent ?? null;
         const fiveHourReset = usageCache?.fiveHourResetAt ?? null;
         const weeklyUsed = usageCache?.weeklyUsedPercent ?? null;
@@ -106,13 +210,15 @@ function collectAccountStatuses() {
         const isWeeklyLimited = isLimited(weeklyUsed, weeklyReset);
         const localBlock = (0, state_1.getAccountBlock)(account.id);
         const localBlocked = localBlock?.until != null ? localBlock.until * 1000 > Date.now() : false;
+        const refreshErrorCode = workspace.workspaceErrorCode ?? refreshError?.code ?? null;
+        const refreshErrorMessage = workspace.workspaceErrorMessage ?? refreshError?.message ?? null;
         return {
             id: account.id,
             name: account.name,
             email: activeEmail,
             enabled: account.enabled,
-            exists,
-            plan: usageCache?.plan ?? primary?.plan ?? "-",
+            exists: workspace.exists,
+            plan: usageCache?.plan ?? workspace.primary?.plan ?? "-",
             fiveHourLeftPercent,
             fiveHourResetsAt: fiveHourReset,
             weeklyLeftPercent,
@@ -121,8 +227,11 @@ function collectAccountStatuses() {
             isWeeklyLimited,
             localBlockReason: localBlock?.reason,
             localBlockUntil: localBlock?.until ?? null,
+            refreshErrorCode,
+            refreshErrorMessage,
             isAvailable: account.enabled &&
-                exists &&
+                workspace.exists &&
+                !refreshErrorCode &&
                 !isFiveHourLimited &&
                 !isWeeklyLimited &&
                 !localBlocked,
@@ -152,58 +261,95 @@ function summarizeAccountStatuses(statuses) {
  */
 function renderStatusTable(statuses, options) {
     const selectorColumn = options?.selectorColumn;
+    const compact = options?.compact ?? false;
+    const maxWidth = options?.maxWidth ?? Number.POSITIVE_INFINITY;
+    const compactHeader = maxWidth < 68;
+    const compactSlotWidth = maxWidth < 56 ? 8 : 12;
+    const compactPlanWidth = maxWidth < 56 ? 4 : 6;
+    const compactStatusWidth = maxWidth < 56 ? 12 : 18;
     const rows = [
-        [
-            ...(selectorColumn ? [" "] : []),
-            "NAME",
-            "EMAIL",
-            "PLAN",
-            "5H_LEFT",
-            "5H_RESET",
-            "WEEK_LEFT",
-            "WEEK_RESET",
-            "STATUS"
-        ]
+        compact
+            ? [
+                ...(selectorColumn ? [" "] : []),
+                compactHeader ? "ID" : "SLOT",
+                compactHeader ? "P" : "PLAN",
+                "5H",
+                compactHeader ? "WK" : "WEEK",
+                compactHeader ? "ST" : "STATUS"
+            ]
+            : [
+                ...(selectorColumn ? [" "] : []),
+                "NAME",
+                "EMAIL",
+                "PLAN",
+                "5H_LEFT",
+                "5H_RESET",
+                "WEEK_LEFT",
+                "WEEK_RESET",
+                "STATUS"
+            ]
     ];
     for (const item of statuses) {
-        let status = "missing";
-        if (item.exists) {
-            if (!item.enabled) {
-                status = "disabled";
-            }
-            else if (item.localBlockUntil && item.localBlockUntil * 1000 > Date.now()) {
-                status = formatBlockedStatus(item.localBlockReason, item.localBlockUntil);
-            }
-            else if (item.isWeeklyLimited) {
-                status = formatLimitStatus("weekly_limited", item.weeklyResetsAt);
-            }
-            else if (item.isFiveHourLimited) {
-                status = formatLimitStatus("5h_limited", item.fiveHourResetsAt);
-            }
-            else if (item.isAvailable) {
-                status = "available";
-            }
-            else {
-                status = "unknown";
-            }
-        }
+        const status = resolveStatusLabel(item);
         const selectorCell = selectorColumn
             ? `${selectorColumn.cursorAccountId === item.id ? ">" : " "}[${selectorColumn.enabledById[item.id] ? "x" : " "}]`
             : null;
-        rows.push([
-            ...(selectorCell ? [selectorCell] : []),
-            item.name,
-            item.email ?? "-",
-            item.plan,
-            formatPercent(item.fiveHourLeftPercent),
-            formatReset(item.fiveHourResetsAt),
-            formatPercent(item.weeklyLeftPercent),
-            formatReset(item.weeklyResetsAt),
-            status
-        ]);
+        rows.push(compact
+            ? [
+                ...(selectorCell ? [selectorCell] : []),
+                truncateCell(item.name, compactSlotWidth),
+                truncateCell(item.plan, compactPlanWidth),
+                formatPercent(item.fiveHourLeftPercent),
+                formatPercent(item.weeklyLeftPercent),
+                truncateCell(status, compactStatusWidth)
+            ]
+            : [
+                ...(selectorCell ? [selectorCell] : []),
+                item.name,
+                item.email ?? "-",
+                item.plan,
+                formatPercent(item.fiveHourLeftPercent),
+                formatReset(item.fiveHourResetsAt),
+                formatPercent(item.weeklyLeftPercent),
+                formatReset(item.weeklyResetsAt),
+                status
+            ]);
     }
     const widths = rows[0].map((_, columnIndex) => Math.max(...rows.map((row) => row[columnIndex].length)));
     return rows
         .map((row) => row.map((cell, index) => cell.padEnd(widths[index])).join("  "))
         .join("\n");
 }
+/**
+ * 将当前选中账号渲染为紧凑详情区，补充主表中省略的邮箱、重置时间与错误摘要。
+ *
+ * @param item 当前选中的账号状态；为空时返回占位提示。
+ * @param options 详情区渲染选项。
+ * @returns 适合直接打印的详情区文本。
+ */
+function renderStatusDetails(item, options) {
+    const includeHeader = options?.header ?? true;
+    if (!item) {
+        return [includeHeader ? "[ current ]" : "slot   -", includeHeader ? "slot   -" : ""]
+            .filter((line) => line.length > 0)
+            .join("\n");
+    }
+    const maxWidth = options?.maxWidth ?? Number.POSITIVE_INFINITY;
+    const narrow = maxWidth < 72;
+    const lines = [
+        ...(includeHeader ? ["[ current ]"] : []),
+        formatDetailLine("slot", `${item.name}  plan=${item.plan}`, maxWidth),
+        formatDetailLine("email", item.email ?? "-", maxWidth),
+        formatDetailLine("status", resolveStatusLabel(item), maxWidth),
+        narrow
+            ? formatDetailLine("5h", `${formatPercent(item.fiveHourLeftPercent)}  reset=${formatReset(item.fiveHourResetsAt)}`, maxWidth)
+            : formatDetailLine("5h", `${formatPercent(item.fiveHourLeftPercent)}  reset=${formatReset(item.fiveHourResetsAt)}`, maxWidth),
+        narrow
+            ? formatDetailLine("week", `${formatPercent(item.weeklyLeftPercent)}  reset=${formatReset(item.weeklyResetsAt)}`, maxWidth)
+            : formatDetailLine("week", `${formatPercent(item.weeklyLeftPercent)}  reset=${formatReset(item.weeklyResetsAt)}`, maxWidth)
+    ];
+    if (item.refreshErrorMessage) {
+        lines.push(formatDetailLine("error", item.refreshErrorMessage, narrow ? Math.max(28, maxWidth) : Math.min(maxWidth, 96)));
+    }
+    return lines.join("\n");
+}

package/dist/usage-sync.js

@@ -21,6 +21,32 @@ function normalizeResetAt(value, resetAfterSeconds) {
     }
     return null;
 }
+/**
+ * 将额度刷新异常归类为可直接展示在 `status` 表格中的状态码。
+ *
+ * @param accountId 刷新失败的账号标识。
+ * @param error 刷新流程抛出的原始异常。
+ * @returns 归一化后的刷新失败状态。
+ */
+function classifyUsageRefreshError(accountId, error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const workspaceInvalidPatterns = [
+        "未找到账号",
+        "缺少 access_token",
+        "缺少 refresh_token",
+        "Unexpected end of JSON input",
+        "Unexpected token"
+    ];
+    const code = workspaceInvalidPatterns.some((pattern) => message.includes(pattern))
+        ? "workspace_invalid"
+        : "refresh_failed";
+    return {
+        accountId,
+        code,
+        message,
+        updatedAt: new Date().toISOString()
+    };
+}
 /**
  * 使用 refresh token 刷新指定账号的 access token，并回写到账号目录。
  *
@@ -122,6 +148,7 @@ async function refreshAccountUsage(accountId) {
         refreshedAt: new Date().toISOString()
     };
     (0, state_1.setUsageCache)(result);
+    (0, state_1.clearUsageRefreshError)(accountId);
     return result;
 }
 /**
@@ -182,8 +209,7 @@ async function refreshAllAccountUsage() {
             results.push(result);
         }
         catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            console.error((0, text_1.bi)(`[refresh] ${account.id} 失败: ${message}`, `[refresh] ${account.id} failed: ${message}`));
+            (0, state_1.setUsageRefreshError)(classifyUsageRefreshError(account.id, error));
         }
     }
     return results;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-slot",
-  "version": "0.1.8",
+  "version": "0.1.17",
   "description": "本地 Codex 多账号切换与状态管理工具",
   "type": "commonjs",
   "main": "dist/cli.js",