@gkorepanov/ccodex 0.4.19 → 0.4.23

package/dist/gateway/clientConnection.js

@@ -5,7 +5,7 @@ import { isRequest, isResponse, parseRpcMessage } from "../protocol/envelopes.js
 import { RpcError, rpcCodexErrorInfo, rpcError } from "../protocol/errors.js";
 import { mergedModelList } from "./modelList.js";
 import { providerSkillsList } from "./skillList.js";
-import { StockRpc } from "./stockRpc.js";
+import { StockRpc, findStockSection } from "./stockRpc.js";
 import { ThreadCatalog } from "./threadList.js";
 import { ServerRequestIds } from "./serverRequestIds.js";
 import { providerMigrationCompleted, providerMigrationFailed, providerMigrationNotice, transientCommandNotice, transientSystemNotice, transientSystemItemNotice, } from "./transientNotice.js";
@@ -19,6 +19,8 @@ import { StockStateTracker } from "../state/stockStateTracker.js";
 import { STOCK_SIDE_THREAD_SOURCE } from "./stockSideThreads.js";
 import { projectRpcToPublicThread } from "./logicalThreadProjection.js";
 import { isUserSideFork, normalizeUserSideFork } from "./sideFork.js";
+/** Stock RPC failures the App handles itself; a chat banner would only add noise (e.g. app/list 403 from Cloudflare). */
+const BANNERLESS_STOCK_ERRORS = new Set(["thread/read", "turn/steer", "app/list", "app/installed", "mcpServerStatus/list"]);
 function requestedFast(serviceTier) {
     return serviceTier === "fast" || serviceTier === "priority";
 }
@@ -62,6 +64,8 @@ export function attachClientConnection(client, stockSocket, claudeModels, claude
         const params = message.params && typeof message.params === "object"
             ? message.params
             : undefined;
+        if (message.method === "initialize" && typeof params?.clientInfo?.name === "string")
+            clientName = params.clientInfo.name;
         const systemEphemeral = (message.method === "thread/start" || message.method === "thread/fork")
             && params?.ephemeral === true
             && (params.threadSource === "system" || (message.method === "thread/start" && params.threadSource !== "user"));
@@ -127,11 +131,23 @@ export function attachClientConnection(client, stockSocket, claudeModels, claude
         completeLatency(id, "claude");
         sendJson({ id, result });
     };
+    // Stock sends these before the response, on every qualifying call.
+    const deprecationNotice = (summary) => sendJson({ method: "deprecationNotice", params: { summary, details: null } });
+    const rollbackDeprecated = () => {
+        if (clientName !== "codex-tui")
+            deprecationNotice("thread/rollback is deprecated and will be removed soon");
+    };
+    const fullHistoryDeprecated = (threadId, hint) => {
+        if (claude.readThread(threadId, false).thread.historyMode === "paginated") {
+            deprecationNotice(`Full-history hydration is deprecated for paginated threads; ${hint}, then page with \`thread/turns/list\` and \`thread/items/list\`.`);
+        }
+    };
     const sendError = (id, code, error) => {
         completeLatency(id, "claude");
         sendJson({ id, error: { code, message: error instanceof Error ? error.message : String(error) } });
     };
     let foreground;
+    let clientName;
     let skillsProvider;
     let foregroundGeneration = 0;
     let unknownStatusDiagnosed = false;
@@ -659,21 +675,30 @@ export function attachClientConnection(client, stockSocket, claudeModels, claude
                     sendResult(message.id, await claude.readRateLimits(backend));
                     return;
                 }
-                if (message.method === "account/usage/read" && foreground?.provider === "claude") {
-                    // The captured App status flow does not request this method. If a
-                    // client does, lifetime/streak Codex statistics have no Claude
-                    // equivalent and must not be mislabelled as provider usage.
-                    sendResult(message.id, {
-                        summary: {
-                            lifetimeTokens: null,
-                            peakDailyTokens: null,
-                            longestRunningTurnSec: null,
-                            currentStreakDays: null,
-                            longestStreakDays: null,
-                        },
-                        dailyUsageBuckets: null,
-                    });
-                    return;
+                if (message.method === "account/usage/read") {
+                    // 0.149.1 adds an optional per-thread scope. Route by the requested
+                    // thread's owner; only the legacy parameterless call uses foreground.
+                    const requestedThreadId = message.params?.threadId;
+                    const claudeScoped = requestedThreadId
+                        ? (handoffs.logical?.(requestedThreadId)?.epoch.provider === "claude"
+                            || claude.ownsThread(requestedThreadId))
+                        : foreground?.provider === "claude";
+                    if (claudeScoped) {
+                        // Lifetime/streak Codex statistics have no Claude equivalent and
+                        // must not be mislabelled as provider usage.
+                        sendResult(message.id, {
+                            summary: {
+                                lifetimeTokens: null,
+                                peakDailyTokens: null,
+                                longestRunningTurnSec: null,
+                                currentStreakDays: null,
+                                longestStreakDays: null,
+                            },
+                            dailyUsageBuckets: null,
+                            threadUsage: null,
+                        });
+                        return;
+                    }
                 }
                 if (message.method === "account/rateLimits/read" && !foreground)
                     diagnoseUnknownStatus("account/rateLimits/read");
@@ -686,11 +711,16 @@ export function attachClientConnection(client, stockSocket, claudeModels, claude
                     sendResult(message.id, await catalog.loaded((message.params ?? {})));
                     return;
                 }
+                if (message.method === "thread/search") {
+                    sendResult(message.id, await catalog.search((message.params ?? {})));
+                    return;
+                }
                 if (message.method === "thread/start") {
                     const params = (message.params ?? {});
                     if (params.model && claude.ownsModel(params.model)) {
                         const result = await claude.startThread(params);
-                        handoffs.observeDurableThread(connectionId, "claude");
+                        if (!result.thread.ephemeral)
+                            handoffs.observeDurableThread(connectionId, "claude", result.thread.id);
                         sendResult(message.id, result);
                         selectForeground("claude", result.thread.id);
                         subscribeClaude(result.thread.id);
@@ -869,7 +899,8 @@ export function attachClientConnection(client, stockSocket, claudeModels, claude
                     }
                 }
                 if (params.threadId && handoffs.logical?.(params.threadId)
-                    && message.method !== "thread/fork" && message.method !== "thread/rollback") {
+                    && message.method !== "thread/fork" && message.method !== "thread/rollback"
+                    && message.method !== "thread/revert") {
                     if (message.method === "thread/unsubscribe") {
                         subscriptions.unsubscribe(params.threadId, connectionId);
                         sendResult(message.id, { status: "unsubscribed" });
@@ -1006,9 +1037,15 @@ export function attachClientConnection(client, stockSocket, claudeModels, claude
                     return;
                 }
                 if (params.threadId && message.method === "thread/rollback" && handoffs.logical?.(params.threadId)) {
+                    rollbackDeprecated();
                     sendResult(message.id, await handoffs.rollbackLogicalThread((message.params ?? {}), stockRpc, connectionId));
                     return;
                 }
+                if (params.threadId && message.method === "thread/revert" && handoffs.logical?.(params.threadId)) {
+                    sendResult(message.id, await handoffs.revertLogicalThread((message.params ?? {}), stockRpc, connectionId));
+                    subscriptions.emitPublic(params.threadId, "thread/reverted", { threadId: params.threadId });
+                    return;
+                }
                 if (params.threadId && handoffs.overlay(params.threadId)) {
                     if (message.method === "thread/rollback") {
                         const rollback = (message.params ?? {});
@@ -1056,10 +1093,13 @@ export function attachClientConnection(client, stockSocket, claudeModels, claude
                     if (message.method === "thread/resume") {
                         muteClaudeDuringSnapshot(params.threadId);
                         try {
-                            const prepared = await claude.prepareResume((message.params ?? {}));
+                            const resume = (message.params ?? {});
+                            const prepared = await claude.prepareResume(resume);
                             const result = prepared.response;
                             const snapshotHighWatermark = claude.eventHighWatermark(params.threadId);
                             const tokenUsage = claude.latestTokenUsage(params.threadId);
+                            if (!resume.excludeTurns)
+                                fullHistoryDeprecated(params.threadId, "use `excludeTurns: true`");
                             sendResult(message.id, result);
                             selectForeground("claude", params.threadId);
                             subscriptions.unmute(params.threadId, connectionId);
@@ -1084,6 +1124,8 @@ export function attachClientConnection(client, stockSocket, claudeModels, claude
                     }
                     if (message.method === "thread/read") {
                         const read = (message.params ?? {});
+                        if (read.includeTurns)
+                            fullHistoryDeprecated(params.threadId, "omit `includeTurns` or set it to `false`");
                         sendResult(message.id, claude.readThread(read.threadId, read.includeTurns ?? false));
                         const failedFork = handoffs.claimFailedFork(params.threadId);
                         if (failedFork)
@@ -1143,7 +1185,10 @@ export function attachClientConnection(client, stockSocket, claudeModels, claude
                         return;
                     }
                     if (message.method === "thread/fork") {
-                        const result = await claude.forkThread(normalizeUserSideFork((message.params ?? {})));
+                        const fork = (message.params ?? {});
+                        const result = await claude.forkThread(normalizeUserSideFork(fork));
+                        if (!fork.excludeTurns && !fork.ephemeral)
+                            fullHistoryDeprecated(params.threadId, "use `excludeTurns: true`");
                         sendResult(message.id, result);
                         selectForeground("claude", result.thread.id);
                         subscribeClaude(result.thread.id);
@@ -1151,9 +1196,23 @@ export function attachClientConnection(client, stockSocket, claudeModels, claude
                         return;
                     }
                     if (message.method === "thread/rollback") {
+                        rollbackDeprecated();
                         sendResult(message.id, await claude.rollbackThread((message.params ?? {})));
                         return;
                     }
+                    if (message.method === "thread/revert") {
+                        const revert = (message.params ?? {});
+                        sendResult(message.id, await claude.revertThread(revert));
+                        // Stock ordering: the response lands before the lifecycle notification.
+                        subscriptions.emit(params.threadId, "thread/reverted", { threadId: params.threadId });
+                        return;
+                    }
+                    if (message.method === "thread/section/move") {
+                        const move = (message.params ?? {});
+                        await claude.setThreadSection(params.threadId, move.sectionId === null ? null : await findStockSection(stockRpc, move.sectionId));
+                        sendResult(message.id, {});
+                        return;
+                    }
                     if (message.method === "thread/compact/start") {
                         sendResult(message.id, await claude.compactThread(params.threadId));
                         return;
@@ -1203,6 +1262,45 @@ export function attachClientConnection(client, stockSocket, claudeModels, claude
                         sendResult(message.id, await claude.getGoal(params.threadId));
                         return;
                     }
+                    if (message.method === "thread/queue/list") {
+                        sendResult(message.id, claude.listQueue((message.params ?? {})));
+                        return;
+                    }
+                    if (message.method === "app/list" || message.method === "mcpServerStatus/list") {
+                        // Codex apps and MCP servers never apply to a Claude runtime.
+                        sendResult(message.id, { data: [], nextCursor: null });
+                        return;
+                    }
+                    if (message.method === "app/installed") {
+                        sendResult(message.id, { apps: [] });
+                        return;
+                    }
+                    if (message.method === "thread/queue/add") {
+                        const prepared = await claude.addQueuedSubmission((message.params ?? {}));
+                        sendResult(message.id, prepared.response);
+                        await prepared.after();
+                        return;
+                    }
+                    if (message.method === "thread/queue/update") {
+                        sendResult(message.id, await claude.updateQueuedSubmission((message.params ?? {})));
+                        return;
+                    }
+                    if (message.method === "thread/queue/delete") {
+                        sendResult(message.id, await claude.deleteQueuedSubmission((message.params ?? {})));
+                        return;
+                    }
+                    if (message.method === "thread/queue/reorder") {
+                        sendResult(message.id, await claude.reorderQueue((message.params ?? {})));
+                        return;
+                    }
+                    if (message.method === "thread/queue/start") {
+                        const prepared = await claude.prepareQueueStart((message.params ?? {}));
+                        sendResult(message.id, prepared.response);
+                        selectForeground("claude", params.threadId);
+                        await prepared.announce();
+                        prepared.start();
+                        return;
+                    }
                     if (message.method === "thread/goal/clear") {
                         const prepared = await claude.prepareGoalClear(params.threadId);
                         try {
@@ -1255,8 +1353,10 @@ export function attachClientConnection(client, stockSocket, claudeModels, claude
                     : undefined;
                 const threadId = typeof params?.threadId === "string" ? params.threadId : undefined;
                 const childProjection = Boolean(threadId && claude.isChildProjection(threadId));
+                // A steer that lost its turn (App races an automatic queue drain) expects a plain RPC error, not a banner.
+                const silent = message.method === "turn/steer";
                 let attachedToActiveTurn = false;
-                if (threadId && !childProjection && claude.ownsThread(threadId)) {
+                if (threadId && !childProjection && !silent && claude.ownsThread(threadId)) {
                     attachedToActiveTurn = await claude.reportError(threadId, typeof params?.turnId === "string" ? params.turnId : undefined, failure.message, rpcCodexErrorInfo(failure.code)).catch((diagnosticError) => {
                         logger.warn("claude.request.error-report-failed", {
                             connectionId,
@@ -1275,7 +1375,7 @@ export function attachClientConnection(client, stockSocket, claudeModels, claude
                     emitNotice(notice);
                     return;
                 }
-                if (threadId && !childProjection && !attachedToActiveTurn)
+                if (threadId && !childProjection && !attachedToActiveTurn && !silent)
                     emitSystemError(threadId, failure.message);
                 sendError(message.id, failure.code, failure.message);
                 if (threadId && !childProjection && !claude.ownsThread(threadId)) {
@@ -1365,7 +1465,7 @@ export function attachClientConnection(client, stockSocket, claudeModels, claude
                     }
                 }
                 if (forwarded?.threadId && isUuid(forwarded.threadId) && "error" in message
-                    && forwarded.method !== "thread/read") {
+                    && !BANNERLESS_STOCK_ERRORS.has(forwarded.method)) {
                     emitSystemError(forwarded.threadId, message.error.message);
                 }
                 if (forwarded && "result" in message) {
@@ -1375,7 +1475,7 @@ export function attachClientConnection(client, stockSocket, claudeModels, claude
                         : undefined;
                     const resultThreadId = typeof result?.thread?.id === "string" ? result.thread.id : forwarded.threadId;
                     if (forwarded.foreground && resultThreadId) {
-                        handoffs.observeDurableThread(connectionId, "stock");
+                        handoffs.observeDurableThread(connectionId, "stock", resultThreadId);
                         foregroundAfterForward = () => selectForeground(forwarded.foreground, resultThreadId);
                     }
                     else if (forwarded.clearForeground && forwarded.threadId) {
@@ -1396,6 +1496,11 @@ export function attachClientConnection(client, stockSocket, claudeModels, claude
                         stock.send(JSON.stringify({ id: message.id, result: { decision: "decline" } }));
                     return;
                 }
+                if (message.method === "turn/completed") {
+                    void handoffs.persistGeneratedTitle(message).catch((error) => {
+                        logger.warn("thread.generated-title.failed", { connectionId, error: String(error) });
+                    });
+                }
                 const rewritten = handoffs.rewriteTitleMessages(message);
                 if (rewritten) {
                     for (const output of rewritten)