claude-code-rust 0.12.3 → 0.13.0

package/agent-sdk/dist/bridge.js

@@ -36,6 +36,63 @@ export { MCP_STALE_STATUS_REVALIDATION_COOLDOWN_MS, staleMcpAuthCandidates };
 export function buildSessionMutationOptions(cwd) {
     return cwd ? { dir: cwd } : undefined;
 }
+function normalizeRewindTargetText(text) {
+    return text.replace(/\s+/g, " ").trim();
+}
+function userTextPartsFromSessionMessage(message) {
+    const record = message;
+    if (record.type !== "user") {
+        return undefined;
+    }
+    const payload = record.message;
+    if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+        return undefined;
+    }
+    const content = payload.content;
+    if (typeof content === "string") {
+        const firstText = normalizeRewindTargetText(content);
+        return firstText ? { firstText, inputText: content } : undefined;
+    }
+    if (!Array.isArray(content)) {
+        return undefined;
+    }
+    const textBlocks = [];
+    for (const block of content) {
+        if (!block || typeof block !== "object" || Array.isArray(block)) {
+            continue;
+        }
+        const blockRecord = block;
+        if (blockRecord.type === "text" && typeof blockRecord.text === "string") {
+            textBlocks.push(blockRecord.text);
+        }
+    }
+    const firstText = textBlocks.map(normalizeRewindTargetText).find((text) => text.length > 0);
+    return firstText ? { firstText, inputText: textBlocks.join("\n").trim() } : undefined;
+}
+export function rewindTargetsFromSessionMessages(messages) {
+    const targets = [];
+    let previousAssistantUuid;
+    messages.forEach((message, index) => {
+        const record = message;
+        const uuid = typeof record.uuid === "string" ? record.uuid.trim() : "";
+        if (record.type === "assistant" && uuid) {
+            previousAssistantUuid = uuid;
+            return;
+        }
+        const textParts = userTextPartsFromSessionMessage(message);
+        if (!uuid || !textParts) {
+            return;
+        }
+        targets.push({
+            uuid,
+            first_text: textParts.firstText,
+            input_text: textParts.inputText,
+            index,
+            ...(previousAssistantUuid ? { previous_assistant_uuid: previousAssistantUuid } : {}),
+        });
+    });
+    return targets.reverse();
+}
 export function canGenerateSessionTitle(query) {
     return typeof query.generateSessionTitle === "function";
 }
@@ -72,7 +129,7 @@ export function emitAgentConfigOptionUpdate(sessionId, agent) {
         value: agent,
     });
 }
-const EXPECTED_AGENT_SDK_VERSION = "0.3.177";
+const EXPECTED_AGENT_SDK_VERSION = "0.3.198";
 const require = createRequire(import.meta.url);
 export function resolveInstalledAgentSdkVersion() {
     try {
@@ -119,6 +176,309 @@ export async function handleReloadPluginsCommand(session, requestId) {
         emitRuntimeReloadFailed(session.sessionId, message, requestId);
     }
 }
+function resolveRewindTarget(messages, targetUserMessageId) {
+    let previousAssistantUuid;
+    let textUserCountBeforeTarget = 0;
+    for (let index = 0; index < messages.length; index += 1) {
+        const message = messages[index];
+        const record = message;
+        const uuid = typeof record.uuid === "string" ? record.uuid.trim() : "";
+        if (record.type === "assistant" && uuid) {
+            previousAssistantUuid = uuid;
+            continue;
+        }
+        const textParts = userTextPartsFromSessionMessage(message);
+        if (!textParts) {
+            continue;
+        }
+        if (uuid === targetUserMessageId) {
+            if (!previousAssistantUuid && textUserCountBeforeTarget > 0) {
+                return null;
+            }
+            if (previousAssistantUuid) {
+                const anchorIndex = messages.findIndex((candidate) => {
+                    const candidateRecord = candidate;
+                    return candidateRecord.uuid === previousAssistantUuid;
+                });
+                if (anchorIndex < 0) {
+                    return null;
+                }
+                return {
+                    inputText: textParts.inputText,
+                    previousAssistantUuid,
+                    targetIndex: index,
+                    retainedMessages: messages.slice(0, anchorIndex + 1),
+                };
+            }
+            return {
+                inputText: textParts.inputText,
+                targetIndex: index,
+                retainedMessages: [],
+            };
+        }
+        if (uuid) {
+            textUserCountBeforeTarget += 1;
+        }
+    }
+    return null;
+}
+export function buildRewindConversationPlan(messages, targetUserMessageId) {
+    const resolved = resolveRewindTarget(messages, targetUserMessageId);
+    if (!resolved) {
+        return null;
+    }
+    return {
+        ...resolved,
+        resumeUpdates: mapSessionMessagesToUpdates(resolved.retainedMessages),
+    };
+}
+function mapRewindFilesResult(result) {
+    return {
+        can_rewind: result.canRewind,
+        ...(result.error ? { error: result.error } : {}),
+        files_changed: result.filesChanged ?? [],
+        ...(result.insertions !== undefined ? { insertions: result.insertions } : {}),
+        ...(result.deletions !== undefined ? { deletions: result.deletions } : {}),
+    };
+}
+async function rewindFiles(session, targetUserMessageId, dryRun) {
+    if (typeof session.query.rewindFiles !== "function") {
+        return {
+            can_rewind: false,
+            error: "file rewind is not supported by this SDK runtime",
+            files_changed: [],
+        };
+    }
+    return mapRewindFilesResult(await session.query.rewindFiles(targetUserMessageId, { dryRun }));
+}
+function emitRewindResult(sessionId, restoreMode, status, requestId, fileResult, message) {
+    writeEvent({
+        event: "rewind_result",
+        session_id: sessionId,
+        restore_mode: restoreMode,
+        status,
+        ...(fileResult ? { file_result: fileResult } : {}),
+        ...(message ? { message } : {}),
+    }, requestId);
+}
+async function replaceConversationForRewind(command, session, targetUserMessageId, requestId, pendingRewindResult) {
+    const historyMessages = await getSessionMessages(command.session_id, {
+        dir: session.cwd,
+        includeSystemMessages: true,
+    });
+    const resolved = buildRewindConversationPlan(historyMessages, targetUserMessageId);
+    if (!resolved) {
+        bridgeLogger.warn({
+            target: LOG_TARGETS.APP_SESSION,
+            eventName: "rewind_failed",
+            message: "conversation rewind target was stale or inconsistent",
+            outcome: "failure",
+            ...(requestId ? { requestId } : {}),
+            sessionId: session.sessionId,
+            fields: {
+                target_user_message_id: targetUserMessageId,
+                history_message_count: historyMessages.length,
+                reason: "target_not_found_or_inconsistent",
+            },
+        });
+        throw new Error(`unknown rewind target: ${targetUserMessageId}`);
+    }
+    const resumeUpdates = resolved.resumeUpdates;
+    const staleSessions = Array.from(sessions.values());
+    setSessionListingDir(session.cwd);
+    bridgeLogger.info({
+        target: LOG_TARGETS.APP_SESSION,
+        eventName: "rewind_target_resolved",
+        message: "conversation rewind target resolved",
+        outcome: "success",
+        ...(requestId ? { requestId } : {}),
+        sessionId: session.sessionId,
+        fields: {
+            target_user_message_id: targetUserMessageId,
+            target_index: resolved.targetIndex,
+            previous_assistant_uuid: resolved.previousAssistantUuid ?? "<none>",
+            history_message_count: historyMessages.length,
+            retained_message_count: resolved.retainedMessages.length,
+            retained_update_count: resumeUpdates.length,
+            stale_session_count: staleSessions.length,
+        },
+    });
+    if (!resolved.previousAssistantUuid) {
+        bridgeLogger.info({
+            target: LOG_TARGETS.APP_SESSION,
+            eventName: "rewind_first_message_branch",
+            message: "conversation rewind target is first user message; creating fresh replacement",
+            outcome: "start",
+            ...(requestId ? { requestId } : {}),
+            sessionId: session.sessionId,
+            fields: {
+                target_user_message_id: targetUserMessageId,
+                history_message_count: historyMessages.length,
+                stale_session_count: staleSessions.length,
+            },
+        });
+        await createSession({
+            cwd: session.cwd,
+            launchSettings: command.launch_settings,
+            connectEvent: "session_replaced",
+            requestId,
+            restoredInput: resolved.inputText,
+            ...(pendingRewindResult ? { pendingRewindResult } : {}),
+            ...(staleSessions.length > 0 ? { sessionsToCloseAfterConnect: staleSessions } : {}),
+        });
+        bridgeLogger.info({
+            target: LOG_TARGETS.APP_SESSION,
+            eventName: "rewind_replacement_created",
+            message: "conversation rewind replacement session created",
+            outcome: "success",
+            ...(requestId ? { requestId } : {}),
+            fields: {
+                target_user_message_id: targetUserMessageId,
+                resume_session_at: "<none>",
+                retained_message_count: 0,
+                retained_update_count: 0,
+                stale_session_count: staleSessions.length,
+            },
+        });
+        return;
+    }
+    const sessionsToCloseAfterConnect = staleSessions.filter((stale) => stale !== session);
+    await createSession({
+        cwd: session.cwd,
+        resume: command.session_id,
+        resumeSessionAt: resolved.previousAssistantUuid,
+        launchSettings: command.launch_settings,
+        connectEvent: "session_replaced",
+        requestId,
+        sessionsToCloseBeforeRegister: [session],
+        ...(resumeUpdates.length > 0 ? { resumeUpdates } : {}),
+        restoredInput: resolved.inputText,
+        ...(pendingRewindResult ? { pendingRewindResult } : {}),
+        ...(sessionsToCloseAfterConnect.length > 0 ? { sessionsToCloseAfterConnect } : {}),
+    });
+    bridgeLogger.info({
+        target: LOG_TARGETS.APP_SESSION,
+        eventName: "rewind_replacement_created",
+        message: "conversation rewind replacement session created",
+        outcome: "success",
+        ...(requestId ? { requestId } : {}),
+        sessionId: command.session_id,
+        fields: {
+            target_user_message_id: targetUserMessageId,
+            resume_session_at: resolved.previousAssistantUuid,
+            retained_message_count: resolved.retainedMessages.length,
+            retained_update_count: resumeUpdates.length,
+            stale_session_count: staleSessions.length,
+        },
+    });
+}
+async function handleRewind(command, requestId) {
+    const session = sessionById(command.session_id);
+    if (!session) {
+        slashError(command.session_id, `unknown session: ${command.session_id}`, requestId);
+        return;
+    }
+    const targetUserMessageId = command.target_user_message_id.trim();
+    if (!targetUserMessageId) {
+        slashError(command.session_id, "rewind target cannot be empty", requestId);
+        return;
+    }
+    bridgeLogger.info({
+        target: LOG_TARGETS.APP_SESSION,
+        eventName: "rewind_requested",
+        message: "rewind requested",
+        outcome: "start",
+        ...(requestId ? { requestId } : {}),
+        sessionId: session.sessionId,
+        fields: {
+            target_user_message_id: targetUserMessageId,
+            restore_mode: command.restore_mode,
+        },
+    });
+    if (command.restore_mode === "conversation") {
+        try {
+            await replaceConversationForRewind(command, session, targetUserMessageId, requestId);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            bridgeLogger.error({
+                target: LOG_TARGETS.APP_SESSION,
+                eventName: "rewind_failed",
+                message: "conversation rewind failed",
+                outcome: "failure",
+                ...(requestId ? { requestId } : {}),
+                sessionId: session.sessionId,
+                fields: {
+                    target_user_message_id: targetUserMessageId,
+                    restore_mode: command.restore_mode,
+                    error_message: message,
+                },
+            });
+            slashError(command.session_id, `failed to rewind conversation: ${message}`, requestId);
+        }
+        return;
+    }
+    let appliedFileResult;
+    try {
+        const dryRunResult = await rewindFiles(session, targetUserMessageId, true);
+        if (!dryRunResult.can_rewind) {
+            slashError(command.session_id, dryRunResult.error ?? "failed to dry-run file rewind", requestId);
+            return;
+        }
+        appliedFileResult = await rewindFiles(session, targetUserMessageId, false);
+        if (!appliedFileResult.can_rewind) {
+            slashError(command.session_id, appliedFileResult.error ?? "failed to restore code", requestId);
+            return;
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        bridgeLogger.error({
+            target: LOG_TARGETS.APP_SESSION,
+            eventName: "rewind_failed",
+            message: "file rewind failed",
+            outcome: "failure",
+            ...(requestId ? { requestId } : {}),
+            sessionId: session.sessionId,
+            fields: {
+                target_user_message_id: targetUserMessageId,
+                restore_mode: command.restore_mode,
+                error_message: message,
+            },
+        });
+        slashError(command.session_id, `failed to restore code: ${message}`, requestId);
+        return;
+    }
+    if (command.restore_mode === "code") {
+        emitRewindResult(session.sessionId, command.restore_mode, "success", requestId, appliedFileResult);
+        return;
+    }
+    try {
+        await replaceConversationForRewind(command, session, targetUserMessageId, requestId, {
+            event: "rewind_result",
+            restore_mode: command.restore_mode,
+            status: "success",
+            file_result: appliedFileResult,
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        bridgeLogger.error({
+            target: LOG_TARGETS.APP_SESSION,
+            eventName: "rewind_failed",
+            message: "conversation rewind failed after file restore",
+            outcome: "partial_failure",
+            ...(requestId ? { requestId } : {}),
+            sessionId: session.sessionId,
+            fields: {
+                target_user_message_id: targetUserMessageId,
+                restore_mode: command.restore_mode,
+                error_message: message,
+            },
+        });
+        emitRewindResult(session.sessionId, command.restore_mode, "partial_failure", requestId, appliedFileResult, `Code was restored, but the conversation could not be rewound: ${message}`);
+    }
+}
 async function handleCommand(command, requestId) {
     logBridgeCommandReceived(command, requestId);
     const sdkVersionError = agentSdkVersionCompatibilityError();
@@ -597,6 +957,54 @@ async function handleCommand(command, requestId) {
             }
             return;
         }
+        case "get_rewind_targets": {
+            const session = sessionById(command.session_id);
+            if (!session) {
+                slashError(command.session_id, `unknown session: ${command.session_id}`, requestId);
+                return;
+            }
+            try {
+                const historyMessages = await getSessionMessages(command.session_id, {
+                    dir: session.cwd,
+                    includeSystemMessages: true,
+                });
+                const targets = rewindTargetsFromSessionMessages(historyMessages);
+                bridgeLogger.info({
+                    target: LOG_TARGETS.APP_SESSION,
+                    eventName: "rewind_targets_loaded",
+                    message: "rewind targets loaded from session history",
+                    outcome: "success",
+                    ...(requestId ? { requestId } : {}),
+                    sessionId: session.sessionId,
+                    fields: {
+                        history_message_count: historyMessages.length,
+                        target_count: targets.length,
+                    },
+                });
+                writeEvent({
+                    event: "rewind_targets",
+                    session_id: session.sessionId,
+                    targets,
+                }, requestId);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                bridgeLogger.warn({
+                    target: LOG_TARGETS.APP_SESSION,
+                    eventName: "rewind_targets_failed",
+                    message: "failed to load rewind targets",
+                    outcome: "failure",
+                    ...(requestId ? { requestId } : {}),
+                    sessionId: session.sessionId,
+                    fields: { error_message: message },
+                });
+                slashError(command.session_id, `failed to load rewind targets: ${message}`, requestId);
+            }
+            return;
+        }
+        case "rewind":
+            await handleRewind(command, requestId);
+            return;
         case "reload_plugins": {
             const session = sessionById(command.session_id);
             if (!session) {