@jingyi0605/codingns 0.7.4 → 0.8.0

package/node_modules/@codingns/session-sync-core/dist/runtime/claude-runtime.js

@@ -1,939 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { accessSync, constants, existsSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { delimiter, dirname, isAbsolute, join, sep } from "node:path";
-import { spawn } from "node:child_process";
-import { tmpdir } from "node:os";
-import { buildClaudeMessageSignature, buildClaudeProgressiveTrackKey, buildClaudeStableRawRef, normalizeClaudeMessagePart, normalizeClaudeMessageParts, readClaudeMessageId, readClaudeStableRawRefIdentity, shouldReuseClaudeProgressiveIdentity, toClaudeRecord } from "../claude-message-utils.js";
-import { ClaudeCodeAdapter } from "../providers/claude-code.js";
-import { ensureDirectory, ensureText, nextTimestamp, safeDate, stringifyStructuredValue } from "../providers/utils.js";
-import { CLAUDE_CODE_SESSION_STORE_PROFILE } from "../providers/claude-session-store.js";
-/**
- * Claude 真实运行时：通过 claude.cmd 流式读取事件，而不是伪造写文件。
- */
-export class ClaudeRuntimeAdapter {
-    options;
-    providerId;
-    commandPath;
-    constructor(options) {
-        this.options = options;
-        this.providerId = options.providerId ?? "claude-code";
-        this.commandPath = resolveClaudeCommand(options.commandPath);
-    }
-    async startSession(request, sink) {
-        const homeDir = request.runtimeHomeDir?.trim() || this.options.homeDir;
-        const providerSessionId = request.providerSessionId ?? buildPendingClaudeSessionId(this.providerId, request.sessionId);
-        const rawStoreRef = buildClaudePendingRawStoreRef(this.getSessionStoreProfile(), homeDir, request.workspacePath, request.sessionId);
-        sink.updateSessionBinding({
-            providerSessionId,
-            rawStoreRef
-        });
-        const runtimeSeed = await buildClaudeRuntimeSeed({
-            homeDir,
-            providerId: this.providerId,
-            workspacePath: request.workspacePath,
-            sessionStoreProfile: this.getSessionStoreProfile(),
-            providerSessionId,
-            rawStoreRef
-        });
-        return this.launchClaude(request, sink, providerSessionId, rawStoreRef, [], runtimeSeed);
-    }
-    async continueSession(request, sink) {
-        const homeDir = request.runtimeHomeDir?.trim() || this.options.homeDir;
-        const providerSessionId = ensureNonEmpty(request.providerSessionId, "CLAUDE_PROVIDER_SESSION_ID_REQUIRED");
-        const rawStoreRef = findClaudeSessionFile(this.getSessionStoreProfile(), homeDir, request.workspacePath, providerSessionId) ??
-            request.rawStoreRef ??
-            buildClaudeRawStoreRef(this.getSessionStoreProfile(), homeDir, request.workspacePath, providerSessionId);
-        sink.updateSessionBinding({
-            providerSessionId,
-            rawStoreRef
-        });
-        const runtimeSeed = await buildClaudeRuntimeSeed({
-            homeDir,
-            providerId: this.providerId,
-            workspacePath: request.workspacePath,
-            sessionStoreProfile: this.getSessionStoreProfile(),
-            providerSessionId,
-            rawStoreRef
-        });
-        return this.launchClaude(request, sink, providerSessionId, rawStoreRef, ["--resume", providerSessionId], runtimeSeed);
-    }
-    launchClaude(request, sink, providerSessionId, rawStoreRef, sessionArgs, runtimeSeed) {
-        const homeDir = request.runtimeHomeDir?.trim() || this.options.homeDir;
-        const instructionFilePath = normalizeOptionalInstructionFilePath(request.options.providerInstructionFilePath);
-        const hookSettings = shouldInjectClaudeHookBridge(request.options.permissionMode) && this.options.hookBridge
-            ? createClaudeHookSettingsFile(this.options.hookBridge)
-            : null;
-        const attachmentDirectories = Array.from(new Set(request.options.attachments.map((attachment) => dirname(attachment.filePath))));
-        const args = [
-            "-p",
-            "--verbose",
-            "--output-format",
-            "stream-json",
-            "--input-format",
-            "stream-json",
-            "--include-partial-messages",
-            ...(instructionFilePath ? ["--system-prompt-file", instructionFilePath] : []),
-            ...(hookSettings ? ["--settings", hookSettings.filePath] : []),
-            ...attachmentDirectories.flatMap((directory) => ["--add-dir", directory]),
-            ...sessionArgs
-        ];
-        const permissionArgs = buildClaudePermissionArgs(request.options.permissionMode);
-        if (permissionArgs.length > 0) {
-            args.push(...permissionArgs);
-        }
-        if (request.options.model) {
-            args.push("--model", request.options.model);
-        }
-        logClaudeRuntimeDebug("launch.begin", {
-            sessionId: request.sessionId,
-            providerSessionId,
-            workspacePath: request.workspacePath,
-            commandPath: this.commandPath,
-            args,
-            instructionFilePath,
-            hookSettingsPath: hookSettings?.filePath ?? null,
-            hookDebugLogPath: hookSettings?.debugLogPath ?? null,
-            hookSettingsJson: hookSettings?.json ?? null
-        });
-        let sequence = Math.max(0, request.sequenceBase ?? 0, runtimeSeed.maxSequence);
-        const toolNameById = new Map();
-        const stableMessageRefByIdentity = new Map(runtimeSeed.stableMessageRefByIdentity);
-        const progressiveMessagesByTrackKey = new Map();
-        const emittedSignatureByMessageId = new Map(runtimeSeed.emittedSignatureByMessageId);
-        const streamEventState = {
-            currentMessageKey: null,
-            messages: new Map()
-        };
-        let interrupted = false;
-        let completed = false;
-        let fatalWriteError = null;
-        let fatalWriteErrorCode = null;
-        let stderrBuffer = "";
-        let stdoutBuffer = "";
-        let stdinClosed = false;
-        let activeProviderSessionId = providerSessionId;
-        let activeRawStoreRef = rawStoreRef;
-        const refreshBinding = (parsed) => {
-            const discoveredProviderSessionId = extractClaudeSessionId(parsed);
-            let changed = false;
-            if (discoveredProviderSessionId &&
-                discoveredProviderSessionId !== activeProviderSessionId &&
-                !isPendingClaudeSessionId(discoveredProviderSessionId)) {
-                activeProviderSessionId = discoveredProviderSessionId;
-                changed = true;
-            }
-            if (!isPendingClaudeSessionId(activeProviderSessionId)) {
-                const nextRawStoreRef = findClaudeSessionFile(this.getSessionStoreProfile(), homeDir, request.workspacePath, activeProviderSessionId) ??
-                    buildClaudeRawStoreRef(this.getSessionStoreProfile(), homeDir, request.workspacePath, activeProviderSessionId);
-                if (nextRawStoreRef !== activeRawStoreRef) {
-                    activeRawStoreRef = nextRawStoreRef;
-                    this.ensureRuntimeStoreReady(activeRawStoreRef);
-                    changed = true;
-                }
-            }
-            if (changed) {
-                sink.updateSessionBinding({
-                    providerSessionId: activeProviderSessionId,
-                    rawStoreRef: activeRawStoreRef
-                });
-            }
-            return {
-                providerSessionId: activeProviderSessionId,
-                rawStoreRef: activeRawStoreRef
-            };
-        };
-        this.ensureRuntimeStoreReady(activeRawStoreRef);
-        const runtimeEnv = {
-            ...buildClaudeRuntimeEnv(homeDir),
-            ...(request.runtimeEnv ?? {})
-        };
-        const proc = spawn(this.commandPath, args, {
-            cwd: request.workspacePath,
-            env: runtimeEnv,
-            shell: shouldSpawnClaudeViaShell(this.commandPath),
-            windowsHide: true,
-            stdio: ["pipe", "pipe", "pipe"]
-        });
-        let pendingInputWrite = Promise.resolve();
-        const submitDuringRun = (options) => {
-            pendingInputWrite = pendingInputWrite.then(() => writeClaudeStreamingInput(proc, options, completed || interrupted || stdinClosed));
-            return pendingInputWrite;
-        };
-        const bindingRefreshTimer = setInterval(() => {
-            refreshBinding();
-        }, 250);
-        void submitDuringRun(request.options).catch((error) => {
-            if (completed || interrupted) {
-                return;
-            }
-            fatalWriteError = error instanceof Error ? error.message : "claude stdin write failed";
-            fatalWriteErrorCode = "CLAUDE_CLI_STDIN_WRITE_FAILED";
-            stderrBuffer = `${stderrBuffer}\n${fatalWriteError}`.trim();
-            if (!proc.killed) {
-                proc.kill("SIGTERM");
-            }
-        });
-        const completedPromise = new Promise((resolve) => {
-            const shutdownProcessAfterTurn = () => {
-                stdinClosed = true;
-                if (!proc.stdin.destroyed) {
-                    proc.stdin.end();
-                }
-                if (!proc.killed) {
-                    proc.kill("SIGTERM");
-                }
-            };
-            const emitRuntimeError = async (detail, errorCode = "CLAUDE_RUNTIME_ERROR") => {
-                if (completed) {
-                    return;
-                }
-                completed = true;
-                const binding = refreshBinding();
-                await sink.emit({
-                    type: "error",
-                    status: "failed",
-                    providerSessionId: binding.providerSessionId,
-                    rawStoreRef: binding.rawStoreRef,
-                    errorCode,
-                    detail
-                });
-            };
-            const emitRuntimeComplete = async (status, detail) => {
-                if (completed) {
-                    return;
-                }
-                completed = true;
-                const binding = refreshBinding();
-                await sink.emit({
-                    type: status,
-                    status: status === "complete" ? "completed" : "interrupted",
-                    providerSessionId: binding.providerSessionId,
-                    rawStoreRef: binding.rawStoreRef,
-                    detail
-                });
-            };
-            const handleControlLine = (parsed) => {
-                const result = readClaudeResultOutcome(parsed);
-                if (!result) {
-                    return false;
-                }
-                stableMessageRefByIdentity.clear();
-                const settle = result.kind === "complete"
-                    ? emitRuntimeComplete("complete", result.detail)
-                    : emitRuntimeError(result.detail, result.errorCode);
-                void settle.finally(() => {
-                    shutdownProcessAfterTurn();
-                    resolve();
-                });
-                return true;
-            };
-            proc.stdout.setEncoding("utf8");
-            proc.stdout.on("data", (chunk) => {
-                stdoutBuffer += chunk;
-                const lines = stdoutBuffer.split(/\r?\n/);
-                stdoutBuffer = lines.pop() ?? "";
-                for (const line of lines) {
-                    const trimmed = line.trim();
-                    if (!trimmed) {
-                        continue;
-                    }
-                    void this.consumeStreamLine({
-                        line: trimmed,
-                        onParsed: handleControlLine,
-                        refreshBinding,
-                        sink,
-                        allocateSequence: () => {
-                            sequence += 1;
-                            return sequence;
-                        },
-                        toolNameById,
-                        stableMessageRefByIdentity,
-                        progressiveMessagesByTrackKey,
-                        emittedSignatureByMessageId,
-                        streamEventState
-                    });
-                }
-            });
-            proc.stderr.setEncoding("utf8");
-            proc.stderr.on("data", (chunk) => {
-                stderrBuffer += chunk;
-            });
-            proc.on("error", (error) => {
-                clearInterval(bindingRefreshTimer);
-                stdinClosed = true;
-                hookSettings?.cleanup();
-                void emitRuntimeError(error.message, "CLAUDE_CLI_SPAWN_FAILED").finally(resolve);
-            });
-            proc.on("close", (code, signal) => {
-                clearInterval(bindingRefreshTimer);
-                stdinClosed = true;
-                hookSettings?.cleanup();
-                if (fatalWriteError) {
-                    void emitRuntimeError(fatalWriteError, fatalWriteErrorCode ?? "CLAUDE_CLI_STDIN_WRITE_FAILED").finally(resolve);
-                    return;
-                }
-                if (interrupted || signal === "SIGTERM" || signal === "SIGINT") {
-                    void emitRuntimeComplete("interrupted", "claude process interrupted").finally(resolve);
-                    return;
-                }
-                if (code === 0) {
-                    void emitRuntimeComplete("complete", "claude turn completed").finally(resolve);
-                    return;
-                }
-                const detail = stderrBuffer.trim() || `claude exited with code ${String(code)}`;
-                void emitRuntimeError(detail, "CLAUDE_CLI_EXIT_NON_ZERO").finally(resolve);
-            });
-        });
-        return {
-            providerSessionId: activeProviderSessionId,
-            rawStoreRef: activeRawStoreRef,
-            completed: completedPromise,
-            submitDuringRun,
-            interrupt: async () => {
-                if (proc.killed) {
-                    return;
-                }
-                interrupted = true;
-                stdinClosed = true;
-                if (!proc.stdin.destroyed) {
-                    proc.stdin.end();
-                }
-                proc.kill("SIGTERM");
-            }
-        };
-    }
-    ensureRuntimeStoreReady(rawStoreRef) {
-        ensureDirectory(dirname(rawStoreRef));
-        if (existsSync(rawStoreRef)) {
-            return;
-        }
-        writeFileSync(rawStoreRef, "", "utf8");
-    }
-    async consumeStreamLine(input) {
-        let parsed;
-        try {
-            parsed = JSON.parse(input.line);
-        }
-        catch {
-            return;
-        }
-        if (input.onParsed(parsed)) {
-            return;
-        }
-        const binding = input.refreshBinding(parsed);
-        const envelopes = collectMessageEnvelopes(parsed, input.streamEventState);
-        for (const envelope of envelopes) {
-            const parts = normalizeClaudeMessageParts(envelope.message.content);
-            for (let partIndex = 0; partIndex < parts.length; partIndex += 1) {
-                const part = parts[partIndex];
-                const normalized = normalizeClaudeMessagePart({
-                    part,
-                    envelope,
-                    providerId: this.providerId,
-                    providerSessionId: binding.providerSessionId,
-                    partIndex,
-                    timestamp: safeDate(envelope.timestamp, nextTimestamp()),
-                    toolNameById: input.toolNameById,
-                    resolveStableMessageRef: (identity) => {
-                        const existing = input.stableMessageRefByIdentity.get(identity);
-                        if (existing) {
-                            return existing;
-                        }
-                        const sequence = input.allocateSequence();
-                        const created = {
-                            sequence,
-                            rawRef: buildClaudeStableRawRef(identity, this.providerId)
-                        };
-                        input.stableMessageRefByIdentity.set(identity, created);
-                        return created;
-                    }
-                });
-                if (!normalized) {
-                    continue;
-                }
-                if (normalized.role === "user") {
-                    input.progressiveMessagesByTrackKey.clear();
-                }
-                const trackKey = buildClaudeProgressiveTrackKey(normalized, partIndex);
-                const previousProgressive = trackKey
-                    ? input.progressiveMessagesByTrackKey.get(trackKey) ?? null
-                    : null;
-                const nextMessage = previousProgressive && shouldReuseClaudeProgressiveIdentity(previousProgressive, normalized)
-                    ? {
-                        ...normalized,
-                        messageId: previousProgressive.messageId,
-                        rawRef: previousProgressive.rawRef,
-                        sequence: previousProgressive.sequence
-                    }
-                    : normalized;
-                if (trackKey) {
-                    input.progressiveMessagesByTrackKey.set(trackKey, nextMessage);
-                }
-                const signature = buildClaudeMessageSignature(nextMessage);
-                if (input.emittedSignatureByMessageId.get(nextMessage.messageId) === signature) {
-                    continue;
-                }
-                input.emittedSignatureByMessageId.set(nextMessage.messageId, signature);
-                await input.sink.emit({
-                    type: "message",
-                    providerSessionId: binding.providerSessionId,
-                    rawStoreRef: binding.rawStoreRef,
-                    message: nextMessage,
-                    status: "running",
-                    rawEventRef: nextMessage.rawRef
-                });
-            }
-        }
-    }
-    getSessionStoreProfile() {
-        return this.options.sessionStoreProfile ?? CLAUDE_CODE_SESSION_STORE_PROFILE;
-    }
-}
-function writeClaudeStreamingInput(proc, options, isClosed) {
-    if (isClosed || proc.killed || proc.stdin.destroyed || !proc.stdin.writable) {
-        return Promise.reject(new Error("IN_RUN_INPUT_NOT_SUPPORTED"));
-    }
-    const payload = JSON.stringify(buildClaudeStreamingUserInput(options));
-    return new Promise((resolve, reject) => {
-        proc.stdin.write(`${payload}\n`, "utf8", (error) => {
-            if (error) {
-                reject(error);
-                return;
-            }
-            resolve();
-        });
-    });
-}
-function buildClaudeStreamingUserInput(options) {
-    return {
-        type: "user",
-        message: {
-            role: "user",
-            content: [
-                {
-                    type: "text",
-                    text: options.providerPrompt ?? options.content
-                }
-            ]
-        }
-    };
-}
-function normalizeOptionalInstructionFilePath(value) {
-    const normalized = value?.trim();
-    if (!normalized) {
-        return null;
-    }
-    return normalized;
-}
-export function buildClaudePermissionArgs(permissionMode) {
-    if (permissionMode === "default" ||
-        permissionMode === "acceptEdits" ||
-        permissionMode === "bypassPermissions") {
-        return ["--permission-mode", permissionMode];
-    }
-    return [];
-}
-function shouldInjectClaudeHookBridge(permissionMode) {
-    return permissionMode !== "bypassPermissions";
-}
-function buildClaudeRuntimeEnv(homeDir) {
-    const resolvedHomeDir = join(homeDir);
-    const xdgConfigHome = join(resolvedHomeDir, "xdg-config");
-    const xdgDataHome = join(resolvedHomeDir, "xdg-data");
-    const xdgStateHome = join(resolvedHomeDir, "xdg-state");
-    const xdgCacheHome = join(resolvedHomeDir, "xdg-cache");
-    const appDataHome = join(resolvedHomeDir, "appdata");
-    const localAppDataHome = join(resolvedHomeDir, "localappdata");
-    [
-        resolvedHomeDir,
-        xdgConfigHome,
-        xdgDataHome,
-        xdgStateHome,
-        xdgCacheHome,
-        appDataHome,
-        localAppDataHome
-    ].forEach((directoryPath) => {
-        ensureDirectory(directoryPath);
-    });
-    return {
-        ...process.env,
-        CLAUDE_CONFIG_DIR: resolvedHomeDir,
-        HOME: resolvedHomeDir,
-        USERPROFILE: resolvedHomeDir,
-        XDG_CONFIG_HOME: xdgConfigHome,
-        XDG_DATA_HOME: xdgDataHome,
-        XDG_STATE_HOME: xdgStateHome,
-        XDG_CACHE_HOME: xdgCacheHome,
-        APPDATA: appDataHome,
-        LOCALAPPDATA: localAppDataHome
-    };
-}
-function createClaudeHookSettingsFile(input) {
-    const tempDir = mkdtempSync(join(tmpdir(), "codingns-claude-hooks-"));
-    const filePath = join(tempDir, "settings.json");
-    const debugLogPath = join(tmpdir(), "codingns-claude-hook-bridge.log");
-    const command = buildClaudeHookBridgeCommand(input, tempDir, debugLogPath);
-    const settings = {
-        hooks: {
-            PreToolUse: ["Bash", "Edit", "Write", "MultiEdit", "NotebookEdit"].map((matcher) => ({
-                matcher,
-                hooks: [
-                    {
-                        type: "command",
-                        command
-                    }
-                ]
-            }))
-        }
-    };
-    const settingsJson = JSON.stringify(settings);
-    writeFileSync(filePath, settingsJson, "utf8");
-    return {
-        filePath,
-        debugLogPath,
-        json: settingsJson,
-        cleanup: () => {
-            rmSync(tempDir, { recursive: true, force: true });
-        }
-    };
-}
-function buildClaudeHookBridgeCommand(input, tempDir, debugLogPath) {
-    if (process.platform === "win32") {
-        void tempDir;
-        return `${quoteShellArgument(process.execPath)} ${quoteShellArgument(input.scriptPath)} --url ${quoteShellArgument(input.url)} --token ${quoteShellArgument(input.token)} --debug-log ${quoteShellArgument(debugLogPath)}`;
-    }
-    return `${quoteShellArgument(process.execPath)} ${quoteShellArgument(input.scriptPath)} --url ${quoteShellArgument(input.url)} --token ${quoteShellArgument(input.token)} --debug-log ${quoteShellArgument(debugLogPath)}`;
-}
-function quoteShellArgument(value) {
-    return `"${value.replace(/"/g, '\\"')}"`;
-}
-function resolveClaudeCommand(explicitPath) {
-    const explicitCandidate = pickFirstNonEmpty(explicitPath, process.env.CODINGNS_CLAUDE_CODE_COMMAND, process.env.CLAUDE_CODE_COMMAND);
-    if (explicitCandidate) {
-        return resolveExecutableCandidate(explicitCandidate) ?? explicitCandidate;
-    }
-    const candidates = process.platform === "win32"
-        ? [
-            "claude.cmd",
-            process.env.APPDATA ? join(process.env.APPDATA, "npm", "claude.cmd") : "",
-            process.env.USERPROFILE
-                ? join(process.env.USERPROFILE, "AppData", "Roaming", "npm", "claude.cmd")
-                : "",
-            "claude"
-        ]
-        : ["claude", "/opt/homebrew/bin/claude", "/usr/local/bin/claude", "/usr/bin/claude"];
-    for (const candidate of candidates) {
-        const resolved = resolveExecutableCandidate(candidate);
-        if (resolved) {
-            return resolved;
-        }
-    }
-    return process.platform === "win32" ? "claude.cmd" : "claude";
-}
-function shouldSpawnClaudeViaShell(commandPath) {
-    return process.platform === "win32" && /\.(cmd|bat)$/i.test(commandPath);
-}
-async function buildClaudeRuntimeSeed(input) {
-    const seed = {
-        maxSequence: 0,
-        stableMessageRefByIdentity: new Map(),
-        emittedSignatureByMessageId: new Map()
-    };
-    if (!input.providerSessionId.trim()
-        || isPendingClaudeSessionId(input.providerSessionId)
-        || !existsSync(input.rawStoreRef)) {
-        return seed;
-    }
-    try {
-        const historyAdapter = new ClaudeCodeAdapter({
-            homeDir: input.homeDir,
-            providerId: input.providerId,
-            sessionStoreProfile: input.sessionStoreProfile
-        });
-        let cursor = null;
-        while (true) {
-            const page = await historyAdapter.readSessionHistory(input.providerSessionId, input.rawStoreRef, cursor, 100, "forward");
-            for (const message of page.messages) {
-                const identity = readClaudeStableRawRefIdentity(message.rawRef);
-                if (identity) {
-                    seed.stableMessageRefByIdentity.set(identity, {
-                        rawRef: message.rawRef,
-                        sequence: message.sequence
-                    });
-                }
-                seed.emittedSignatureByMessageId.set(message.messageId, buildClaudeMessageSignature(message));
-                seed.maxSequence = Math.max(seed.maxSequence, message.sequence);
-            }
-            if (!page.nextCursor) {
-                break;
-            }
-            cursor = page.nextCursor;
-        }
-    }
-    catch {
-        return seed;
-    }
-    return seed;
-}
-const CLAUDE_RUNTIME_DEBUG_ENABLED = /^(1|true|yes)$/i.test(process.env.CODINGNS_PERMISSION_DEBUG?.trim() ?? "");
-function logClaudeRuntimeDebug(scope, detail) {
-    if (!CLAUDE_RUNTIME_DEBUG_ENABLED) {
-        return;
-    }
-    const suffix = Object.entries(detail)
-        .filter(([, value]) => value !== undefined)
-        .map(([key, value]) => {
-        if (value === null) {
-            return `${key}=null`;
-        }
-        if (typeof value === "string") {
-            return `${key}=${JSON.stringify(value.length > 400 ? `${value.slice(0, 400)}...` : value)}`;
-        }
-        try {
-            const json = JSON.stringify(value);
-            return `${key}=${json.length > 400 ? `${json.slice(0, 400)}...` : json}`;
-        }
-        catch {
-            return `${key}=${String(value)}`;
-        }
-    })
-        .join(" ");
-    console.info(`[permission-debug][claude-runtime] ${scope}${suffix ? ` ${suffix}` : ""}`);
-}
-function resolveExecutableCandidate(candidate) {
-    const trimmed = candidate.trim();
-    if (!trimmed) {
-        return null;
-    }
-    if (hasPathSegment(trimmed)) {
-        return isExecutableFile(trimmed) ? trimmed : null;
-    }
-    return resolveExecutableOnPath(trimmed);
-}
-function resolveExecutableOnPath(command) {
-    const pathValue = process.env.PATH ?? "";
-    if (!pathValue.trim()) {
-        return null;
-    }
-    const extensions = process.platform === "win32"
-        ? buildWindowsExecutableExtensions(command)
-        : [""];
-    for (const entry of pathValue.split(delimiter)) {
-        const trimmedEntry = entry.trim();
-        if (!trimmedEntry) {
-            continue;
-        }
-        for (const extension of extensions) {
-            const candidatePath = join(trimmedEntry, `${command}${extension}`);
-            if (isExecutableFile(candidatePath)) {
-                return candidatePath;
-            }
-        }
-    }
-    return null;
-}
-function buildWindowsExecutableExtensions(command) {
-    if (/\.[^./\\]+$/.test(command)) {
-        return [""];
-    }
-    const pathExtensions = (process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD")
-        .split(";")
-        .map((value) => value.trim())
-        .filter((value) => value.length > 0);
-    return ["", ...pathExtensions];
-}
-function hasPathSegment(value) {
-    return isAbsolute(value) || value.includes(sep) || value.includes("/") || value.includes("\\");
-}
-function isExecutableFile(filePath) {
-    if (!existsSync(filePath)) {
-        return false;
-    }
-    if (process.platform === "win32") {
-        return true;
-    }
-    try {
-        accessSync(filePath, constants.X_OK);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function pickFirstNonEmpty(...values) {
-    for (const value of values) {
-        if (value && value.trim().length > 0) {
-            return value.trim();
-        }
-    }
-    return null;
-}
-function buildPendingClaudeSessionId(providerId, sessionId) {
-    return `pending://${providerId}/${sessionId}`;
-}
-function isPendingClaudeSessionId(sessionId) {
-    return sessionId.startsWith("pending://");
-}
-function buildClaudeRawStoreRef(profile, homeDir, workspacePath, sessionId) {
-    return profile.resolveSessionFilePath(homeDir, workspacePath, sessionId);
-}
-function buildClaudePendingRawStoreRef(profile, homeDir, workspacePath, sessionId) {
-    return profile.resolvePendingSessionFilePath(homeDir, workspacePath, sessionId);
-}
-function findClaudeSessionFile(profile, homeDir, workspacePath, sessionId) {
-    return profile.findSessionFile(homeDir, workspacePath, sessionId);
-}
-function extractClaudeSessionId(parsed) {
-    const directSessionId = ensureText(parsed?.session_id).trim();
-    if (directSessionId.length > 0) {
-        return directSessionId;
-    }
-    const resultSessionId = ensureText((parsed?.result ?? {}).session_id).trim();
-    if (resultSessionId.length > 0) {
-        return resultSessionId;
-    }
-    return null;
-}
-function ensureNonEmpty(value, errorCode) {
-    if (!value || value.trim().length === 0) {
-        throw new Error(errorCode);
-    }
-    return value.trim();
-}
-function readClaudeResultOutcome(record) {
-    if (ensureText(record.type).trim() !== "result") {
-        return null;
-    }
-    const subtype = ensureText(record.subtype).trim().toLowerCase();
-    const stopReason = ensureText(record.stop_reason).trim();
-    const resultRecord = (record.result ?? {});
-    const nestedStopReason = ensureText(resultRecord.stop_reason).trim();
-    const detailCandidate = ensureText(record.error).trim()
-        || ensureText(record.message).trim()
-        || ensureText(resultRecord.error).trim()
-        || ensureText(resultRecord.message).trim()
-        || stopReason
-        || nestedStopReason;
-    if (!subtype || subtype === "success" || subtype === "completed") {
-        return {
-            kind: "complete",
-            detail: detailCandidate || "claude turn completed"
-        };
-    }
-    return {
-        kind: "error",
-        detail: detailCandidate || `claude result ${subtype}`,
-        errorCode: `CLAUDE_RESULT_${subtype.toUpperCase().replace(/[^A-Z0-9]+/g, "_")}`
-    };
-}
-function collectMessageEnvelopes(record, streamEventState) {
-    if (ensureText(record.type).trim() === "stream_event") {
-        return collectStreamEventEnvelopes(record, streamEventState);
-    }
-    const envelopes = [];
-    const directType = ensureText(record.type).trim();
-    const directMessage = toClaudeRecord(record.message);
-    if (directType === "user" || directType === "assistant") {
-        envelopes.push({
-            type: directType,
-            source: "direct",
-            messageId: readClaudeMessageId(directMessage, record),
-            timestamp: record.timestamp,
-            message: directMessage
-        });
-    }
-    const progressMessage = readProgressEnvelope(record);
-    if (progressMessage) {
-        envelopes.push(progressMessage);
-    }
-    return envelopes;
-}
-function readProgressEnvelope(record) {
-    if (ensureText(record.type) !== "progress") {
-        return null;
-    }
-    const nested = toClaudeRecord(toClaudeRecord(record.data).message);
-    const nestedType = ensureText(nested.type).trim();
-    const nestedMessage = toClaudeRecord(nested.message);
-    if (nestedType !== "user" && nestedType !== "assistant") {
-        return null;
-    }
-    return {
-        type: nestedType,
-        source: "progress",
-        messageId: readClaudeMessageId(nestedMessage, nested),
-        timestamp: nested.timestamp ?? record.timestamp,
-        message: nestedMessage
-    };
-}
-function collectStreamEventEnvelopes(record, state) {
-    const event = toClaudeRecord(record.event);
-    const eventType = ensureText(event.type).trim();
-    if (!eventType) {
-        return [];
-    }
-    if (eventType === "message_start") {
-        const message = toClaudeRecord(event.message);
-        const role = ensureText(message.role).trim();
-        if (role !== "user" && role !== "assistant") {
-            return [];
-        }
-        const messageId = readClaudeMessageId(message, message);
-        const messageKey = messageId || `stream:${randomUUID()}`;
-        const messageState = {
-            type: role,
-            messageId,
-            timestamp: message.timestamp ?? record.timestamp,
-            partsByIndex: new Map()
-        };
-        const initialParts = normalizeClaudeMessageParts(message.content);
-        initialParts.forEach((part, partIndex) => {
-            messageState.partsByIndex.set(partIndex, {
-                part: { ...part }
-            });
-        });
-        state.currentMessageKey = messageKey;
-        state.messages.set(messageKey, messageState);
-        return [];
-    }
-    const messageKey = resolveClaudeStreamMessageKey(record, state);
-    if (!messageKey) {
-        return [];
-    }
-    const messageState = state.messages.get(messageKey);
-    if (!messageState) {
-        return [];
-    }
-    if (record.timestamp !== undefined && record.timestamp !== null) {
-        messageState.timestamp = record.timestamp;
-    }
-    if (eventType === "content_block_start") {
-        const partIndex = readClaudeContentBlockIndex(event);
-        if (partIndex < 0) {
-            return [];
-        }
-        const contentBlock = toClaudeRecord(event.content_block);
-        const partState = {
-            part: { ...contentBlock }
-        };
-        if (ensureText(contentBlock.type).trim() === "tool_use") {
-            partState.jsonBuffer = serializeClaudeToolInput(contentBlock.input);
-        }
-        messageState.partsByIndex.set(partIndex, partState);
-        return [buildClaudeStreamEnvelope(messageState, partIndex, messageKey)];
-    }
-    if (eventType === "content_block_delta") {
-        const partIndex = readClaudeContentBlockIndex(event);
-        if (partIndex < 0) {
-            return [];
-        }
-        const partState = messageState.partsByIndex.get(partIndex);
-        if (!partState) {
-            return [];
-        }
-        applyClaudeContentBlockDelta(partState, toClaudeRecord(event.delta));
-        return [buildClaudeStreamEnvelope(messageState, partIndex, messageKey)];
-    }
-    if (eventType === "content_block_stop") {
-        const partIndex = readClaudeContentBlockIndex(event);
-        if (partIndex < 0 || !messageState.partsByIndex.has(partIndex)) {
-            return [];
-        }
-        return [buildClaudeStreamEnvelope(messageState, partIndex, messageKey)];
-    }
-    if (eventType === "message_delta") {
-        const delta = toClaudeRecord(event.delta);
-        messageState.stopReason = ensureText(delta.stop_reason).trim() || null;
-        return [];
-    }
-    if (eventType === "message_stop") {
-        state.messages.delete(messageKey);
-        if (state.currentMessageKey === messageKey) {
-            state.currentMessageKey = null;
-        }
-    }
-    return [];
-}
-function resolveClaudeStreamMessageKey(record, state) {
-    const event = toClaudeRecord(record.event);
-    const eventMessage = toClaudeRecord(event.message);
-    const eventDelta = toClaudeRecord(event.delta);
-    const directKey = readClaudeMessageId(eventMessage, eventMessage)
-        || ensureText(event.message_id).trim()
-        || ensureText(eventDelta.message_id).trim()
-        || ensureText(record.message_id).trim();
-    if (directKey.length > 0 && state.messages.has(directKey)) {
-        state.currentMessageKey = directKey;
-        return directKey;
-    }
-    if (state.currentMessageKey && state.messages.has(state.currentMessageKey)) {
-        return state.currentMessageKey;
-    }
-    return directKey.length > 0 ? directKey : null;
-}
-function readClaudeContentBlockIndex(event) {
-    const candidates = [event.index, event.content_block_index, event.contentBlockIndex];
-    for (const candidate of candidates) {
-        if (typeof candidate === "number" && Number.isInteger(candidate) && candidate >= 0) {
-            return candidate;
-        }
-    }
-    return -1;
-}
-function buildClaudeStreamEnvelope(messageState, partIndex, messageKey) {
-    const content = Array.from({ length: partIndex + 1 }, (_, index) => index === partIndex ? { ...(messageState.partsByIndex.get(partIndex)?.part ?? {}) } : "");
-    return {
-        type: messageState.type,
-        source: "stream_event",
-        messageId: messageState.messageId,
-        envelopeKey: messageKey ?? null,
-        timestamp: messageState.timestamp,
-        message: {
-            content
-        }
-    };
-}
-function applyClaudeContentBlockDelta(partState, delta) {
-    const deltaType = ensureText(delta.type).trim();
-    if (deltaType === "text_delta") {
-        partState.part.text = `${ensureText(partState.part.text)}${ensureText(delta.text)}`;
-        return;
-    }
-    if (deltaType === "thinking_delta") {
-        partState.part.type = ensureText(partState.part.type).trim() || "thinking";
-        partState.part.thinking = `${ensureText(partState.part.thinking)}${ensureText(delta.thinking)}`;
-        return;
-    }
-    if (deltaType === "input_json_delta") {
-        partState.part.type = ensureText(partState.part.type).trim() || "tool_use";
-        const nextBuffer = `${partState.jsonBuffer ?? ""}${ensureText(delta.partial_json)}`;
-        partState.jsonBuffer = nextBuffer;
-        partState.part.input = parseClaudePartialJson(nextBuffer);
-        return;
-    }
-    if (deltaType === "signature_delta") {
-        partState.part.signature = `${ensureText(partState.part.signature)}${ensureText(delta.signature)}`;
-    }
-}
-function parseClaudePartialJson(value) {
-    const trimmed = value.trim();
-    if (!trimmed) {
-        return "";
-    }
-    try {
-        return JSON.parse(trimmed);
-    }
-    catch {
-        return trimmed;
-    }
-}
-function serializeClaudeToolInput(value) {
-    if (typeof value === "string") {
-        return value;
-    }
-    if (value === undefined || value === null) {
-        return "";
-    }
-    return stringifyStructuredValue(value);
-}
-//# sourceMappingURL=claude-runtime.js.map