@jingyi0605/codingns 0.1.5 → 0.2.5

package/node_modules/@codingns/session-sync-core/dist/providers/codex.js

@@ -317,6 +317,81 @@ export class CodexAdapter {
             initialCursor: encodeCursor(options.initialPrompt ? 1 : 0)
         };
     }
+    async forkSession(providerSessionId, workspacePath, options) {
+        const transportFactory = this.options.forkTransportFactory;
+        if (!transportFactory) {
+            throw new Error("CODEX_FORK_TRANSPORT_NOT_CONFIGURED");
+        }
+        const transport = transportFactory();
+        try {
+            await transport.initialize();
+            if (options.sourceType === "session") {
+                const forked = await transport.forkThread(providerSessionId);
+                return await this.buildForkResultFromTransport({
+                    providerSessionId: forked.providerSessionId,
+                    rawStoreRef: forked.rawStoreRef,
+                    workspacePath,
+                    fallbackParentProviderSessionId: providerSessionId,
+                    forkMethod: "native_session_fork",
+                    forkSourceType: "session",
+                    providerSourceMessageId: null
+                });
+            }
+            const targetMessageId = options.sourceMessageId?.trim();
+            if (!targetMessageId) {
+                throw new Error("FORK_SOURCE_MESSAGE_ID_REQUIRED");
+            }
+            if (options.strategy === "reconstruct-only") {
+                throw new Error("CODEX_RECONSTRUCTED_MESSAGE_FORK_NOT_SUPPORTED");
+            }
+            const resolvedStoreRef = this.resolveSessionFilePath(options.rawStoreRef, providerSessionId);
+            const parsedMessages = this.getParsedMessages(resolvedStoreRef, providerSessionId);
+            const targetMessage = parsedMessages.find((message) => message.messageId === targetMessageId);
+            if (!targetMessage) {
+                throw new Error("FORK_SOURCE_MESSAGE_NOT_FOUND");
+            }
+            const targetSnapshot = applyForkSourceMessageSnapshot(targetMessage, options.sourceMessageSnapshot);
+            const threadReadResult = await transport.readThread(providerSessionId);
+            const threadSnapshot = extractCodexThreadHistorySnapshot(threadReadResult);
+            if (threadSnapshot.kind === "turns") {
+                const rollbackPlan = buildCodexTurnRollbackPlan(threadSnapshot, parsedMessages, targetSnapshot);
+                const forked = await transport.forkThread(providerSessionId);
+                const finalized = rollbackPlan.numTurnsToRollback > 0
+                    ? await transport.rollbackThread(forked.providerSessionId, rollbackPlan.numTurnsToRollback)
+                    : forked;
+                return await this.buildForkResultFromTransport({
+                    providerSessionId: finalized.providerSessionId,
+                    rawStoreRef: finalized.rawStoreRef,
+                    workspacePath,
+                    fallbackParentProviderSessionId: providerSessionId,
+                    forkMethod: "native_message_fork",
+                    forkSourceType: "message",
+                    providerSourceMessageId: null
+                });
+            }
+            const truncatedHistory = truncateCodexThreadHistory(threadSnapshot.value, parsedMessages, targetSnapshot);
+            if (truncatedHistory.length === 0) {
+                throw new Error("CODEX_FORK_HISTORY_EMPTY");
+            }
+            const resumed = await transport.resumeThreadFromHistory({
+                providerSessionId: null,
+                workspacePath,
+                history: truncatedHistory
+            });
+            return await this.buildForkResultFromTransport({
+                providerSessionId: resumed.providerSessionId,
+                rawStoreRef: resumed.rawStoreRef,
+                workspacePath,
+                fallbackParentProviderSessionId: providerSessionId,
+                forkMethod: "native_message_fork",
+                forkSourceType: "message",
+                providerSourceMessageId: null
+            });
+        }
+        finally {
+            transport.close();
+        }
+    }
     async sendMessage(providerSessionId, rawStoreRef, content, clientRequestId, _permissionMode) {
         const resolvedStoreRef = this.resolveSessionFilePath(rawStoreRef, providerSessionId);
         const lineNumber = readJsonLines(resolvedStoreRef).length + 1;
@@ -439,6 +514,7 @@ export class CodexAdapter {
             supportsAttachments: true,
             supportsPermissionPrompt: true,
             supportsCheckpoint: false,
+            supportsSessionFork: true,
             limitations: [
                 "Codex 产品原生支持将指导加入队列，但当前 SDK 0.116.0 仍未向宿主暴露运行中 queue/steer 提交入口。",
                 "当前实现只维护原生会话文件，不负责直接驱动 Codex CLI 进程执行。"
@@ -693,6 +769,37 @@ export class CodexAdapter {
             this.historyCache.delete(oldestKey);
         }
     }
+    async buildForkResultFromTransport(input) {
+        const resolvedStoreRef = input.rawStoreRef
+            ? this.resolveSessionFilePath(input.rawStoreRef, input.providerSessionId)
+            : this.findSessionFileByThreadId(input.providerSessionId)
+                ?? buildCodexActiveSessionPath(this.options.homeDir, `${input.providerSessionId}.jsonl`);
+        const messages = existsSync(resolvedStoreRef)
+            ? this.getParsedMessages(resolvedStoreRef, input.providerSessionId)
+            : [];
+        const threadMetadataIndex = this.readThreadMetadataIndex();
+        const threadMetadata = threadMetadataIndex.get(input.providerSessionId) ?? null;
+        const title = this.resolveIndexedTitle(threadMetadataIndex, input.providerSessionId)
+            ?? resolveCodexFallbackTitle(messages)
+            ?? "";
+        return {
+            session: {
+                provider: this.providerId,
+                providerSessionId: input.providerSessionId,
+                title,
+                workspacePath: input.workspacePath,
+                rawStoreRef: resolvedStoreRef,
+                isArchived: resolveCodexArchivedState(threadMetadata, resolvedStoreRef),
+                lastMessageAt: messages.at(-1)?.timestamp ?? nextTimestamp(),
+                messageCount: messages.length,
+                parentProviderSessionId: input.fallbackParentProviderSessionId
+            },
+            forkMethod: input.forkMethod,
+            forkSourceType: input.forkSourceType,
+            inheritedPrefixMessageCount: messages.length,
+            providerSourceMessageId: input.providerSourceMessageId
+        };
+    }
     touchSessionSummaryCache(filePath, entry) {
         this.sessionSummaryCache.delete(filePath);
         this.sessionSummaryCache.set(filePath, entry);
@@ -862,6 +969,7 @@ export class CodexAdapter {
         return this.parseMessagesFromEntries(filePath, records, providerSessionId);
     }
     parseMessagesFromEntries(filePath, records, providerSessionId) {
+        const effectiveRecords = filterRolledBackCodexRecords(records);
         const messages = [];
         const messageIndexesByKey = new Map();
         const toolNameById = new Map();
@@ -900,8 +1008,8 @@ export class CodexAdapter {
                 }
             });
         };
-        records.forEach(({ lineNumber, data: record }) => {
-            const rawRef = createRawRef(this.providerId, filePath, lineNumber);
+        effectiveRecords.forEach(({ lineNumber, partIndex, data: record }) => {
+            const rawRef = createRawRef(this.providerId, filePath, lineNumber, partIndex || undefined);
             if (record.type === "event_msg") {
                 const payload = (record.payload ?? {});
                 const eventType = ensureText(payload.type);
@@ -1050,6 +1158,81 @@ export class CodexAdapter {
         return messages.map((entry) => entry.message);
     }
 }
+function filterRolledBackCodexRecords(records) {
+    const completedTurnSegments = [];
+    let activeTurnStartLineNumber = null;
+    let sawRollbackEvent = false;
+    for (const recordEntry of records) {
+        const record = recordEntry.data;
+        if (record.type !== "event_msg") {
+            continue;
+        }
+        const payload = (record.payload ?? {});
+        const eventType = ensureText(payload.type).trim();
+        if (eventType === "task_started") {
+            activeTurnStartLineNumber = recordEntry.lineNumber;
+            continue;
+        }
+        if (eventType === "task_complete" || eventType === "task_failed") {
+            if (activeTurnStartLineNumber !== null) {
+                completedTurnSegments.push({
+                    startLineNumber: activeTurnStartLineNumber,
+                    endLineNumber: recordEntry.lineNumber,
+                    rolledBack: false
+                });
+            }
+            activeTurnStartLineNumber = null;
+            continue;
+        }
+        if (eventType !== "thread_rolled_back") {
+            continue;
+        }
+        sawRollbackEvent = true;
+        const requestedTurnCount = Math.max(0, Math.trunc(typeof payload.num_turns === "number"
+            ? payload.num_turns
+            : Number.parseInt(ensureText(payload.num_turns), 10)) || 0);
+        if (requestedTurnCount <= 0) {
+            continue;
+        }
+        let remainingTurnsToRollback = requestedTurnCount;
+        for (let index = completedTurnSegments.length - 1; index >= 0; index -= 1) {
+            const segment = completedTurnSegments[index];
+            if (!segment || segment.rolledBack) {
+                continue;
+            }
+            segment.rolledBack = true;
+            remainingTurnsToRollback -= 1;
+            if (remainingTurnsToRollback <= 0) {
+                break;
+            }
+        }
+    }
+    if (!sawRollbackEvent) {
+        return records;
+    }
+    const rolledBackSegments = completedTurnSegments
+        .filter((segment) => segment.rolledBack)
+        .sort((left, right) => left.startLineNumber - right.startLineNumber);
+    if (rolledBackSegments.length === 0) {
+        return records;
+    }
+    const filteredRecords = [];
+    let segmentIndex = 0;
+    for (const recordEntry of records) {
+        while (segmentIndex < rolledBackSegments.length
+            && recordEntry.lineNumber > rolledBackSegments[segmentIndex].endLineNumber) {
+            segmentIndex += 1;
+        }
+        const activeSegment = segmentIndex < rolledBackSegments.length ? rolledBackSegments[segmentIndex] : null;
+        if (activeSegment
+            && recordEntry.lineNumber >= activeSegment.startLineNumber
+            && recordEntry.lineNumber <= activeSegment.endLineNumber) {
+            continue;
+        }
+        filteredRecords.push(recordEntry);
+    }
+    return filteredRecords;
+}
 function buildRecentHistoryPage(messages, totalMessageCount, limit) {
     const effectiveTotal = Math.max(totalMessageCount, messages.length);
     const pageMessages = messages.slice(-Math.min(limit, messages.length)).map((message, index, items) => ({
@@ -1365,4 +1548,326 @@ function normalizeCodexMessageTitle(content) {
     const normalized = normalizeCodexIndexedTitle(content);
     return normalized ? normalized.slice(0, CODEX_SESSION_TITLE_MAX_LENGTH) : null;
 }
+function extractCodexThreadHistory(result) {
+    const snapshot = extractCodexThreadHistorySnapshot(result);
+    return snapshot.value;
+}
+function extractCodexThreadHistorySnapshot(result) {
+    const directHistory = pickCodexHistoryArray(result)
+        ?? pickCodexHistoryArray(toRecord(result.thread))
+        ?? pickCodexHistoryArray(toRecord(result.data));
+    if (directHistory) {
+        return {
+            kind: "entries",
+            value: directHistory,
+            comparableEntries: directHistory.flatMap((entry, entryIndex) => {
+                const signature = buildCodexThreadHistorySignature(entry);
+                return signature ? [{ signature, entryIndex }] : [];
+            })
+        };
+    }
+    const turns = pickCodexTurnArray(result.turns)
+        ?? pickCodexTurnArray(toRecord(result.thread)?.turns)
+        ?? pickCodexTurnArray(toRecord(result.data)?.turns);
+    if (!turns) {
+        throw new Error("CODEX_THREAD_HISTORY_MISSING");
+    }
+    const comparableEntries = turns.flatMap((turn, turnIndex) => collectCodexTurnComparableEntries(turn, turnIndex));
+    if (comparableEntries.length === 0) {
+        throw new Error("CODEX_THREAD_HISTORY_MISSING");
+    }
+    return {
+        kind: "turns",
+        value: turns,
+        comparableEntries
+    };
+}
+function isSyntheticCodexSessionTitle(title) {
+    const normalizedTitle = ensureText(title).trim();
+    if (normalizedTitle.length === 0) {
+        return false;
+    }
+    return (/^rollout-\d{4}-\d{2}-\d{2}t/i.test(normalizedTitle) ||
+        /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(normalizedTitle));
+}
+function pickCodexHistoryArray(value) {
+    const record = toRecord(value);
+    if (!record) {
+        return null;
+    }
+    for (const key of ["history", "items"]) {
+        const candidate = record[key];
+        if (Array.isArray(candidate)
+            && candidate.some((entry) => buildCodexThreadHistorySignature(entry) !== null)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function pickCodexTurnArray(value) {
+    return Array.isArray(value) ? value : null;
+}
+function collectCodexTurnComparableEntries(value, turnIndex, parentPath = []) {
+    const record = toRecord(value);
+    if (!record) {
+        return [];
+    }
+    for (const key of ["history", "items"]) {
+        const candidate = record[key];
+        if (Array.isArray(candidate)
+            && candidate.some((entry) => buildCodexThreadHistorySignature(entry) !== null)) {
+            const containerPath = [...parentPath, key];
+            return candidate.flatMap((entry, entryIndex) => {
+                const signature = buildCodexThreadHistorySignature(entry);
+                return signature
+                    ? [{
+                            signature,
+                            turnIndex,
+                            containerPath,
+                            entryIndex
+                        }]
+                    : [];
+            });
+        }
+    }
+    return [
+        ["input", record.input],
+        ["output", record.output],
+        ["turn", record.turn],
+        ["data", record.data],
+        ["result", record.result]
+    ].flatMap(([key, candidate]) => collectCodexTurnComparableEntries(candidate, turnIndex, [...parentPath, key]));
+}
+function toRecord(value) {
+    return typeof value === "object" && value !== null
+        ? value
+        : null;
+}
+function truncateCodexThreadHistory(history, parsedMessages, targetMessage) {
+    const snapshot = normalizeCodexThreadHistorySnapshot(history);
+    if (snapshot.kind === "entries") {
+        const targetEntry = resolveCodexThreadHistoryTargetEntry(snapshot, parsedMessages, targetMessage);
+        return snapshot.value.slice(0, targetEntry.entryIndex + 1);
+    }
+    const targetEntry = resolveCodexThreadHistoryTargetEntry(snapshot, parsedMessages, targetMessage);
+    const truncatedTurns = snapshot.value.slice(0, targetEntry.turnIndex + 1);
+    const lastTurn = truncatedTurns.at(-1);
+    if (!lastTurn) {
+        throw new Error("CODEX_FORK_SOURCE_MESSAGE_UNMAPPABLE");
+    }
+    return [
+        ...flattenCodexTurnHistory(truncatedTurns.slice(0, -1)),
+        ...collectCodexTurnHistoryItems(truncateCodexTurnAtPath(lastTurn, targetEntry.containerPath, targetEntry.entryIndex))
+    ];
+}
+function normalizeCodexThreadHistorySnapshot(history) {
+    const directComparableEntries = history.flatMap((entry, entryIndex) => {
+        const signature = buildCodexThreadHistorySignature(entry);
+        return signature ? [{ signature, entryIndex }] : [];
+    });
+    if (directComparableEntries.length > 0) {
+        return {
+            kind: "entries",
+            value: history,
+            comparableEntries: directComparableEntries
+        };
+    }
+    const turnComparableEntries = history.flatMap((turn, turnIndex) => collectCodexTurnComparableEntries(turn, turnIndex));
+    if (turnComparableEntries.length > 0) {
+        return {
+            kind: "turns",
+            value: history,
+            comparableEntries: turnComparableEntries
+        };
+    }
+    throw new Error("CODEX_THREAD_HISTORY_MISSING");
+}
+function resolveCodexThreadHistoryTargetEntry(snapshot, parsedMessages, targetMessage) {
+    const targetSignature = buildCodexThreadHistorySignature(targetMessage);
+    if (!targetSignature) {
+        throw new Error("CODEX_FORK_SOURCE_MESSAGE_UNMAPPABLE");
+    }
+    const matchingEntries = snapshot.comparableEntries.filter((entry) => entry.signature === targetSignature);
+    if (matchingEntries.length === 0) {
+        throw new Error("CODEX_FORK_SOURCE_MESSAGE_UNMAPPABLE");
+    }
+    const targetOccurrence = resolveCodexMessageSignatureOccurrence(parsedMessages, targetMessage);
+    return matchingEntries[Math.min(targetOccurrence, matchingEntries.length) - 1] ?? matchingEntries.at(-1);
+}
+function resolveCodexMessageSignatureOccurrence(parsedMessages, targetMessage) {
+    const targetSignature = buildCodexThreadHistorySignature(targetMessage);
+    if (!targetSignature) {
+        return 1;
+    }
+    let occurrence = 0;
+    for (const message of parsedMessages) {
+        if (buildCodexThreadHistorySignature(message) !== targetSignature) {
+            continue;
+        }
+        occurrence += 1;
+        if (message.messageId === targetMessage.messageId) {
+            return occurrence;
+        }
+    }
+    return Math.max(1, occurrence);
+}
+function buildCodexTurnRollbackPlan(snapshot, parsedMessages, targetMessage) {
+    const targetEntry = resolveCodexThreadHistoryTargetEntry(snapshot, parsedMessages, targetMessage);
+    const turnEntries = snapshot.comparableEntries.filter((entry) => entry.turnIndex === targetEntry.turnIndex);
+    const lastComparableEntryInTurn = turnEntries.at(-1) ?? null;
+    if (!lastComparableEntryInTurn) {
+        throw new Error("CODEX_FORK_SOURCE_MESSAGE_UNMAPPABLE");
+    }
+    if (lastComparableEntryInTurn.containerPath.join("/") !== targetEntry.containerPath.join("/")
+        || lastComparableEntryInTurn.entryIndex !== targetEntry.entryIndex) {
+        throw new Error("CODEX_MESSAGE_FORK_TURN_BOUNDARY_REQUIRED");
+    }
+    return {
+        targetTurnIndex: targetEntry.turnIndex,
+        numTurnsToRollback: Math.max(0, snapshot.value.length - targetEntry.turnIndex - 1)
+    };
+}
+function truncateCodexTurnAtPath(turn, containerPath, entryIndex) {
+    if (containerPath.length === 0) {
+        return turn;
+    }
+    const record = toRecord(turn);
+    if (!record) {
+        return turn;
+    }
+    const [head, ...rest] = containerPath;
+    const current = record[head];
+    if (rest.length === 0) {
+        if (!Array.isArray(current)) {
+            return turn;
+        }
+        return {
+            ...record,
+            [head]: current.slice(0, entryIndex + 1)
+        };
+    }
+    return {
+        ...record,
+        [head]: truncateCodexTurnAtPath(current, rest, entryIndex)
+    };
+}
+function flattenCodexTurnHistory(turns) {
+    return turns.flatMap((turn) => collectCodexTurnHistoryItems(turn));
+}
+function collectCodexTurnHistoryItems(value) {
+    const direct = pickCodexHistoryArray(value);
+    if (direct) {
+        return direct;
+    }
+    const record = toRecord(value);
+    if (!record) {
+        return [];
+    }
+    return [
+        record.input,
+        record.output,
+        record.turn,
+        record.data,
+        record.result
+    ].flatMap((candidate) => collectCodexTurnHistoryItems(candidate));
+}
+function buildCodexThreadHistorySignature(value) {
+    if (!value || typeof value !== "object") {
+        return null;
+    }
+    const item = value;
+    const normalizedKind = ensureText(item.kind).trim();
+    const normalizedRole = ensureText(item.role).trim();
+    const normalizedContent = ensureText(item.content).trim();
+    if (normalizedKind && normalizedRole) {
+        return `${normalizedRole}:${normalizedKind}:${normalizedContent}`;
+    }
+    const type = ensureText(item.type).trim();
+    if (type === "userMessage") {
+        const content = stringifyCodexThreadMessageContent(item.content);
+        return content ? `user:text:${content}` : null;
+    }
+    if (type === "agentMessage") {
+        const content = ensureText(item.text).trim() || stringifyCodexThreadMessageContent(item.content);
+        return content ? `assistant:text:${content}` : null;
+    }
+    if (type === "message") {
+        const role = ensureText(item.role).trim();
+        const content = stringifyCodexThreadMessageContent(item.content);
+        if (!role || !content) {
+            return null;
+        }
+        return `${role}:text:${content}`;
+    }
+    if (type === "reasoning") {
+        const content = stringifyCodexReasoningContent(item.summary ?? item.content);
+        return content ? `assistant:thinking:${content}` : null;
+    }
+    if (type === "function_call" || type === "tool_call") {
+        const name = ensureText(item.name).trim();
+        const inputValue = item.arguments ?? item.input;
+        const content = stringifyStructuredValue(inputValue);
+        return name || content ? `assistant:tool_call:${name}:${content}` : null;
+    }
+    if (type === "function_call_output" || type === "tool_result") {
+        const content = ensureText(item.output ?? item.content).trim();
+        return content ? `tool:tool_result:${content}` : null;
+    }
+    if (normalizedRole && normalizedContent) {
+        return `${normalizedRole}:text:${normalizedContent}`;
+    }
+    return null;
+}
+function applyForkSourceMessageSnapshot(targetMessage, snapshot) {
+    if (!snapshot) {
+        return targetMessage;
+    }
+    return {
+        ...targetMessage,
+        role: snapshot.role,
+        kind: snapshot.kind,
+        content: snapshot.content
+    };
+}
+function stringifyCodexThreadMessageContent(content) {
+    if (typeof content === "string") {
+        return content.trim();
+    }
+    if (!Array.isArray(content)) {
+        return "";
+    }
+    return content
+        .map((part) => {
+        if (!part || typeof part !== "object") {
+            return "";
+        }
+        const record = part;
+        return ensureText(record.text
+            ?? record.input_text
+            ?? record.output_text
+            ?? (ensureText(record.type).trim() === "text" ? record.text : null)).trim();
+    })
+        .filter((value) => value.length > 0)
+        .join("\n")
+        .trim();
+}
+function stringifyCodexReasoningContent(content) {
+    if (typeof content === "string") {
+        return content.trim();
+    }
+    if (!Array.isArray(content)) {
+        return "";
+    }
+    return content
+        .map((part) => {
+        if (!part || typeof part !== "object") {
+            return "";
+        }
+        const record = part;
+        return ensureText(record.text ?? record.summary_text).trim();
+    })
+        .filter((value) => value.length > 0)
+        .join("\n")
+        .trim();
+}
 //# sourceMappingURL=codex.js.map