@jingyi0605/codingns 0.8.0 → 0.8.5

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

@@ -0,0 +1,939 @@
+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