@varveai/adit-cli 0.3.1 → 0.3.2

package/dist/commands/cli-agent/claude-code-provider.js

@@ -0,0 +1,1347 @@
+import { EventEmitter } from "node:events";
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import fs from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+import { AbortError, query, } from "@anthropic-ai/claude-agent-sdk";
+const RECLAIM_COMMAND = "/local";
+const ASK_USER_QUESTION_TOOL = "AskUserQuestion";
+const EXIT_PLAN_MODE_TOOL = "ExitPlanMode";
+export class ClaudeCodeProvider extends EventEmitter {
+    opts;
+    provider = "claude-code";
+    local = null;
+    remoteQuery = null;
+    remoteAbortController = null;
+    remoteLoopGeneration = 0;
+    ownerValue = "stopped";
+    busyValue = false;
+    thinkingValue = false;
+    activeSessionId = null;
+    resumeSessionId = null;
+    sdkSessionId = null;
+    remoteSdkSessionId = null;
+    remoteSdkSessionIdsByActiveSession = new Map();
+    activeModelId = null;
+    promptQueue = [];
+    promptResolvers = [];
+    activePromptEvent = null;
+    pendingPermissions = new Map();
+    pendingQuestions = new Map();
+    boundPendingSessionIds = new Set();
+    lastAssistantMessageBySession = new Map();
+    reclaimingToLocal = false;
+    reclaimBuffer = "";
+    reclaimAttached = false;
+    suppressNextLocalExit = false;
+    constructor(opts) {
+        super();
+        this.opts = opts;
+        this.startLocal();
+    }
+    get state() {
+        return {
+            owner: this.ownerValue,
+            busy: this.busyValue,
+            thinking: this.thinkingValue,
+            activeSessionId: this.activeSessionId,
+            resumeSessionId: this.resumeSessionId,
+            sdkSessionId: this.sdkSessionId,
+            activeModelId: this.activeModelId,
+        };
+    }
+    get permissions() {
+        return [...this.pendingPermissions.values()].map((item) => item.request);
+    }
+    noteModel(modelId) {
+        if (!modelId || modelId === this.activeModelId)
+            return;
+        this.activeModelId = modelId;
+        this.emitState();
+    }
+    noteLocalSession(id) {
+        if (!id)
+            return;
+        const changed = this.activeSessionId !== id || this.resumeSessionId !== id;
+        this.activeSessionId = id;
+        this.resumeSessionId = id;
+        this.sdkSessionId = null;
+        this.remoteSdkSessionId = null;
+        this.refreshActiveModel({ sessionId: id });
+        if (!changed)
+            return;
+        this.emitState();
+    }
+    markLocalBusy() {
+        this.setBusy(true);
+        this.setThinking(true);
+    }
+    markLocalIdle() {
+        this.setThinking(false);
+        this.setBusy(false);
+    }
+    async takeover() {
+        if (this.ownerValue === "web")
+            return;
+        if (this.ownerValue !== "local") {
+            throw Object.assign(new Error("local Claude owner is not available"), {
+                statusCode: 409,
+            });
+        }
+        if (this.busyValue || this.thinkingValue) {
+            throw Object.assign(new Error("local Claude is busy"), {
+                statusCode: 409,
+            });
+        }
+        this.suppressNextLocalExit = true;
+        const oldLocal = this.local;
+        this.local = null;
+        try {
+            oldLocal?.kill("SIGTERM");
+        }
+        catch { }
+        this.ownerValue = "web";
+        this.reclaimingToLocal = false;
+        this.emitState();
+        process.stderr.write(`\n[adit cloud claude] Web has taken over Claude Code. Type ${RECLAIM_COMMAND} here to reclaim local control.\n`);
+        this.attachReclaimInput();
+        void this.runRemoteLoop(++this.remoteLoopGeneration);
+    }
+    async releaseToLocal() {
+        if (this.ownerValue !== "web")
+            return;
+        if (this.reclaimingToLocal)
+            return;
+        this.reclaimingToLocal = true;
+        this.detachReclaimInput();
+        process.stderr.write("\n[adit cloud claude] releasing Web control back to local Claude CLI...\n");
+        this.finishWebPrompts(new Error("Web control released to local CLI"));
+        for (const pending of this.pendingPermissions.values()) {
+            pending.reject(new Error("Web control released to local CLI"));
+        }
+        this.pendingPermissions.clear();
+        for (const pending of this.pendingQuestions.values()) {
+            pending.reject(new Error("Web control released to local CLI"));
+        }
+        this.pendingQuestions.clear();
+        this.pushEvent("permission-resolved", { id: "all", approved: false });
+        this.pushEvent("question.rejected", { id: "all" });
+        this.remoteAbortController?.abort();
+        try {
+            await this.remoteQuery?.interrupt?.();
+        }
+        catch { }
+        this.remoteQuery?.close?.();
+        this.remoteQuery = null;
+        this.remoteAbortController = null;
+        this.mergeRemoteTranscriptsIntoActive();
+        const resumeId = this.pickResumeSessionId({ fallbackToLatest: true });
+        this.startLocal(resumeId ? ["--resume", resumeId] : []);
+    }
+    async switchSession(sessionId) {
+        if (!isUuid(sessionId)) {
+            throw Object.assign(new Error("Claude session not found for this project"), {
+                statusCode: 404,
+            });
+        }
+        const hasLocalTranscript = isValidClaudeSession(sessionId, this.opts.cwd);
+        if (!hasLocalTranscript && this.ownerValue !== "web") {
+            throw Object.assign(new Error("Claude session not found for this project"), {
+                statusCode: 404,
+            });
+        }
+        this.activeSessionId = sessionId;
+        this.resumeSessionId = sessionId;
+        this.sdkSessionId = null;
+        this.remoteSdkSessionId = null;
+        this.refreshActiveModel({ sessionId });
+        this.emitState();
+        if (this.ownerValue === "local") {
+            this.suppressNextLocalExit = true;
+            const oldLocal = this.local;
+            this.local = null;
+            try {
+                oldLocal?.kill("SIGTERM");
+            }
+            catch { }
+            this.startLocal(["--resume", sessionId]);
+            return;
+        }
+        if (this.ownerValue === "web") {
+            const generation = ++this.remoteLoopGeneration;
+            this.finishWebPrompts(new Error("Claude session switched"));
+            this.remoteAbortController?.abort();
+            try {
+                await this.remoteQuery?.interrupt?.();
+            }
+            catch { }
+            this.remoteQuery?.close?.();
+            this.remoteQuery = null;
+            this.remoteAbortController = null;
+            this.setThinking(false);
+            this.setBusy(false);
+            void this.runRemoteLoop(generation);
+        }
+    }
+    async sendPrompt(prompt, opts = {}) {
+        if (this.ownerValue !== "web") {
+            throw Object.assign(new Error("Web has not taken over this Claude session"), {
+                statusCode: 409,
+            });
+        }
+        const trimmed = prompt.trim();
+        if (!trimmed)
+            return;
+        const sessionId = this.activeSessionId ?? this.resumeSessionId;
+        this.refreshActiveModel({ sessionId });
+        await new Promise((resolve, reject) => {
+            this.promptQueue.push({
+                message: trimmed,
+                mode: opts.mode === "plan" ? "plan" : "build",
+                pendingSessionId: opts.pendingSessionId ?? null,
+                promptEvent: {
+                    text: trimmed,
+                    createdAt: Date.now(),
+                },
+                resolve,
+                reject,
+            });
+            this.drainPromptResolvers();
+        });
+    }
+    async answerPermission(id, approved, reason) {
+        const pending = this.pendingPermissions.get(id);
+        if (!pending) {
+            throw Object.assign(new Error("permission request not found"), {
+                statusCode: 404,
+            });
+        }
+        this.pendingPermissions.delete(id);
+        this.pushEvent("permission-resolved", { id, approved });
+        const result = approved
+            ? {
+                behavior: "allow",
+                updatedInput: asRecord(pending.request.input),
+                toolUseID: id,
+            }
+            : {
+                behavior: "deny",
+                message: reason || "The user rejected this tool use from adit-cloud.",
+                toolUseID: id,
+            };
+        if (pending.request.toolName === EXIT_PLAN_MODE_TOOL) {
+            this.pushEvent("plan.approval.resolved", {
+                id,
+                requestID: id,
+                approved,
+                sessionId: this.activeSessionId ?? this.resumeSessionId,
+            });
+        }
+        pending.resolve(result);
+    }
+    async answerQuestion(response) {
+        const pending = this.pendingQuestions.get(response.id);
+        if (!pending) {
+            const pendingPermission = this.pendingPermissions.get(response.id);
+            if (pendingPermission?.request.toolName === ASK_USER_QUESTION_TOOL) {
+                this.pendingPermissions.delete(response.id);
+                this.resolveAskUserQuestionPermission(response, pendingPermission.request, pendingPermission.resolve);
+                return;
+            }
+            throw Object.assign(new Error("question request not found"), {
+                statusCode: 404,
+            });
+        }
+        this.pendingQuestions.delete(response.id);
+        this.resolveAskUserQuestionPermission(response, pending.request, pending.resolve);
+    }
+    resolveAskUserQuestionPermission(response, request, resolve) {
+        if (response.rejected) {
+            this.pushEvent("question.rejected", {
+                id: response.id,
+                requestID: response.id,
+            });
+            resolve({
+                behavior: "deny",
+                message: "The user ignored this question from adit-cloud.",
+                toolUseID: response.id,
+            });
+            return;
+        }
+        const inputRecord = asRecord(request.input);
+        const questions = normalizeQuestionInput(inputRecord);
+        const answers = buildQuestionAnswerMap(questions, response.answers);
+        this.pushEvent("question.replied", {
+            id: response.id,
+            requestID: response.id,
+        });
+        resolve({
+            behavior: "allow",
+            updatedInput: {
+                ...inputRecord,
+                answers,
+            },
+            toolUseID: response.id,
+        });
+    }
+    async abort() {
+        if (this.ownerValue !== "web")
+            return;
+        this.finishWebPrompts(new Error("Claude run aborted"));
+        this.remoteAbortController?.abort();
+        try {
+            await this.remoteQuery?.interrupt?.();
+        }
+        catch { }
+        this.remoteQuery?.close?.();
+        this.remoteQuery = null;
+        this.remoteAbortController = null;
+        this.setThinking(false);
+        this.setBusy(false);
+        this.pushEvent("error", { message: "Claude run aborted." });
+    }
+    stop() {
+        this.finishWebPrompts(new Error("Claude provider stopped"));
+        this.remoteAbortController?.abort();
+        this.remoteQuery?.close?.();
+        this.remoteQuery = null;
+        this.remoteAbortController = null;
+        for (const pending of this.pendingPermissions.values()) {
+            pending.reject(new Error("Claude provider stopped"));
+        }
+        this.pendingPermissions.clear();
+        for (const pending of this.pendingQuestions.values()) {
+            pending.reject(new Error("Claude provider stopped"));
+        }
+        this.pendingQuestions.clear();
+        this.detachReclaimInput();
+        try {
+            this.local?.kill("SIGTERM");
+        }
+        catch { }
+        this.local = null;
+        this.ownerValue = "stopped";
+        this.setThinking(false);
+        this.setBusy(false);
+        this.emitState();
+    }
+    startLocal(extraArgs = []) {
+        this.detachReclaimInput();
+        this.reclaimingToLocal = false;
+        this.finishWebPrompts(new Error("local mode active"));
+        this.remoteQuery = null;
+        this.remoteAbortController = null;
+        const args = [
+            ...extraArgs,
+            ...this.opts.args,
+            ...(this.opts.hookSettingsPath ? ["--settings", this.opts.hookSettingsPath] : []),
+        ];
+        const child = spawn(this.opts.bin, args, {
+            cwd: this.opts.cwd,
+            env: this.buildEnv(),
+            stdio: "inherit",
+            windowsHide: true,
+        });
+        this.local = child;
+        this.ownerValue = "local";
+        this.emitState();
+        child.on("error", (error) => {
+            this.pushEvent("error", { message: error.message });
+            process.stderr.write(`\n[adit cloud claude] failed to start Claude CLI: ${error.message}\n`);
+        });
+        child.on("exit", (code, signal) => {
+            this.setThinking(false);
+            this.setBusy(false);
+            if (this.suppressNextLocalExit) {
+                this.suppressNextLocalExit = false;
+                return;
+            }
+            if (this.local === child) {
+                this.local = null;
+                this.ownerValue = "stopped";
+                this.emitState();
+                this.emit("exit", { code, signal });
+            }
+        });
+    }
+    async runRemoteLoop(generation) {
+        while (this.ownerValue === "web" && this.remoteLoopGeneration === generation) {
+            let first;
+            try {
+                first = await this.nextPrompt();
+            }
+            catch {
+                return;
+            }
+            if (!first || this.ownerValue !== "web" || this.remoteLoopGeneration !== generation)
+                return;
+            const pendingSessionId = first.pendingSessionId;
+            const pendingClaudeSessionId = pendingSessionId ? randomUUID() : null;
+            const canonicalSessionId = pendingSessionId
+                ? pendingClaudeSessionId
+                : this.activeSessionId ?? this.resumeSessionId;
+            const resumeId = pendingSessionId
+                ? null
+                : this.pickResumeSessionId({ fallbackToLatest: false });
+            this.refreshActiveModel({
+                sessionId: canonicalSessionId ?? resumeId,
+            });
+            const abortController = new AbortController();
+            this.remoteAbortController = abortController;
+            this.activePromptEvent = first.promptEvent;
+            const permissionMode = first.mode === "plan" ? "plan" : "bypassPermissions";
+            const explicitSessionId = !resumeId && canonicalSessionId && isUuid(canonicalSessionId)
+                ? canonicalSessionId
+                : undefined;
+            const options = {
+                cwd: this.opts.cwd,
+                pathToClaudeCodeExecutable: this.opts.bin,
+                env: this.buildEnv(),
+                resume: resumeId ?? undefined,
+                sessionId: explicitSessionId,
+                settings: this.opts.hookSettingsPath,
+                permissionMode,
+                ...(permissionMode === "bypassPermissions" ? { allowDangerouslySkipPermissions: true } : {}),
+                forkSession: false,
+                abortController,
+                includePartialMessages: true,
+                forwardSubagentText: true,
+                ...(permissionMode === "bypassPermissions"
+                    ? {}
+                    : {
+                        canUseTool: (toolName, input, requestOptions) => this.handleToolPermission(toolName, input, requestOptions.toolUseID, requestOptions.signal),
+                    }),
+            };
+            this.remoteQuery = query({
+                prompt: this.createPromptStream(toUserMessage(first.message, pendingClaudeSessionId ?? undefined)),
+                options,
+            });
+            this.setBusy(true);
+            this.setThinking(true);
+            this.emitState();
+            let observedSdkSessionId = null;
+            try {
+                for await (const message of this.remoteQuery) {
+                    if (this.remoteLoopGeneration !== generation)
+                        break;
+                    const sdkSessionId = this.handleSdkMessage(message, canonicalSessionId ?? resumeId, {
+                        suppressActiveFallback: Boolean(pendingSessionId),
+                    });
+                    const boundSessionId = sdkSessionId ?? pendingClaudeSessionId;
+                    if (pendingSessionId && boundSessionId) {
+                        this.bindPendingSession(pendingSessionId, boundSessionId);
+                    }
+                    if (sdkSessionId &&
+                        canonicalSessionId &&
+                        sdkSessionId !== canonicalSessionId) {
+                        observedSdkSessionId = sdkSessionId;
+                    }
+                }
+            }
+            catch (error) {
+                if (!(error instanceof AbortError)) {
+                    const messageText = error instanceof Error ? error.message : String(error);
+                    this.pushEvent("error", { message: messageText });
+                    process.stderr.write(`\n[adit cloud claude] SDK error: ${messageText}\n`);
+                }
+            }
+            finally {
+                if (!pendingSessionId) {
+                    this.mergeRemoteTranscriptsIntoActive(canonicalSessionId, observedSdkSessionId);
+                }
+                if (this.activePromptEvent === first.promptEvent) {
+                    this.activePromptEvent = null;
+                }
+                this.setThinking(false);
+                this.setBusy(false);
+                this.remoteQuery = null;
+                this.remoteAbortController = null;
+            }
+        }
+    }
+    async *createPromptStream(first) {
+        yield first;
+    }
+    nextPrompt() {
+        if (this.promptQueue.length > 0) {
+            const item = this.promptQueue.shift();
+            if (!item)
+                return Promise.resolve(null);
+            item.resolve();
+            return Promise.resolve({
+                message: item.message,
+                mode: item.mode,
+                pendingSessionId: item.pendingSessionId,
+                promptEvent: item.promptEvent,
+            });
+        }
+        return new Promise((resolve) => {
+            this.promptResolvers.push(resolve);
+        });
+    }
+    drainPromptResolvers() {
+        while (this.promptResolvers.length > 0 && this.promptQueue.length > 0) {
+            const resolve = this.promptResolvers.shift();
+            const item = this.promptQueue.shift();
+            if (!resolve || !item)
+                return;
+            item.resolve();
+            resolve({
+                message: item.message,
+                mode: item.mode,
+                pendingSessionId: item.pendingSessionId,
+                promptEvent: item.promptEvent,
+            });
+        }
+    }
+    finishWebPrompts(error) {
+        this.activePromptEvent = null;
+        for (const item of this.promptQueue.splice(0)) {
+            item.reject(error);
+        }
+        for (const resolve of this.promptResolvers.splice(0)) {
+            resolve(null);
+        }
+    }
+    handleSdkMessage(message, canonicalSessionId, opts = {}) {
+        const sdkSessionId = extractSessionId(message);
+        if (sdkSessionId) {
+            this.noteSdkSession(sdkSessionId, {
+                keepActiveSession: Boolean(canonicalSessionId && sdkSessionId !== canonicalSessionId),
+            });
+        }
+        const sessionId = canonicalSessionId ??
+            (opts.suppressActiveFallback ? null : this.activeSessionId) ??
+            (opts.suppressActiveFallback ? null : this.resumeSessionId) ??
+            sdkSessionId ??
+            "pending";
+        if (sdkSessionId)
+            this.flushActivePromptEvent(sessionId);
+        const messageModelId = extractModelId(message);
+        if (messageModelId)
+            this.activeModelId = messageModelId;
+        this.emitState();
+        if (message.type === "system" && message.subtype === "init") {
+            const init = message;
+            if (init.session_id) {
+                this.noteSdkSession(init.session_id, {
+                    keepActiveSession: Boolean(canonicalSessionId && init.session_id !== canonicalSessionId),
+                });
+                this.flushActivePromptEvent(sessionId);
+            }
+            return sdkSessionId;
+        }
+        if (message.type === "assistant") {
+            this.emitAssistantMessage(message, sessionId);
+            return sdkSessionId;
+        }
+        if (message.type === "user") {
+            this.emitToolResults(message, sessionId);
+            return sdkSessionId;
+        }
+        if (message.type === "result") {
+            this.emitResultUsage(message, sessionId);
+            this.setThinking(false);
+            this.setBusy(false);
+        }
+        return sdkSessionId;
+    }
+    noteSdkSession(id, opts = {}) {
+        if (!id)
+            return;
+        const nextActiveSessionId = opts.keepActiveSession
+            ? this.activeSessionId ?? this.resumeSessionId
+            : id;
+        const nextResumeSessionId = opts.keepActiveSession
+            ? this.resumeSessionId ?? this.activeSessionId
+            : id;
+        const changed = this.sdkSessionId !== id ||
+            this.remoteSdkSessionId !== id ||
+            this.activeSessionId !== nextActiveSessionId ||
+            this.resumeSessionId !== nextResumeSessionId;
+        this.sdkSessionId = id;
+        this.remoteSdkSessionId = id;
+        this.activeSessionId = nextActiveSessionId;
+        this.resumeSessionId = nextResumeSessionId;
+        if (nextActiveSessionId) {
+            this.rememberRemoteSdkSession(nextActiveSessionId, id);
+        }
+        this.refreshActiveModel({ sessionId: id });
+        if (changed)
+            this.emitState();
+    }
+    bindPendingSession(pendingSessionId, sessionId) {
+        if (!pendingSessionId || !sessionId)
+            return;
+        const changed = this.activeSessionId !== sessionId ||
+            this.resumeSessionId !== sessionId ||
+            this.sdkSessionId !== sessionId ||
+            this.remoteSdkSessionId !== sessionId;
+        this.activeSessionId = sessionId;
+        this.resumeSessionId = sessionId;
+        this.sdkSessionId = sessionId;
+        this.remoteSdkSessionId = sessionId;
+        this.refreshActiveModel({ sessionId });
+        if (!this.boundPendingSessionIds.has(pendingSessionId)) {
+            this.boundPendingSessionIds.add(pendingSessionId);
+            this.pushEvent("session-bound", {
+                pendingSessionId,
+                sessionId,
+                createdAt: Date.now(),
+            });
+        }
+        if (changed)
+            this.emitState();
+    }
+    flushActivePromptEvent(sessionId) {
+        if (!this.activePromptEvent)
+            return;
+        const prompt = this.activePromptEvent;
+        this.activePromptEvent = null;
+        this.pushEvent("message", {
+            role: "user",
+            sessionId,
+            text: prompt.text,
+            createdAt: prompt.createdAt,
+        });
+    }
+    emitAssistantMessage(message, sessionId) {
+        const content = message.message?.content;
+        if (!Array.isArray(content))
+            return;
+        const messageId = makeMessageId(message, sessionId);
+        const modelId = typeof message.message?.model === "string"
+            ? message.message.model
+            : undefined;
+        if (modelId)
+            this.activeModelId = modelId;
+        const usage = normalizeClaudeUsage(message.message.usage);
+        this.lastAssistantMessageBySession.set(sessionId, messageId);
+        for (const part of content) {
+            if (part.type === "text" && typeof part.text === "string" && part.text) {
+                this.pushEvent("message", {
+                    role: "assistant",
+                    sessionId,
+                    messageId,
+                    modelId,
+                    usage,
+                    text: part.text,
+                    createdAt: Date.now(),
+                });
+            }
+            else if (part.type === "thinking" &&
+                typeof part.thinking === "string" &&
+                part.thinking) {
+                this.pushEvent("reasoning", {
+                    sessionId,
+                    messageId,
+                    modelId,
+                    usage,
+                    text: part.thinking,
+                    createdAt: Date.now(),
+                });
+            }
+            else if (part.type === "tool_use" || part.type === "server_tool_use") {
+                this.pushEvent("tool", {
+                    sessionId,
+                    messageId,
+                    modelId,
+                    usage,
+                    toolUseId: typeof part.id === "string" ? part.id : undefined,
+                    toolName: typeof part.name === "string" ? part.name : "tool",
+                    input: part.input ?? {},
+                    status: "running",
+                    createdAt: Date.now(),
+                });
+            }
+        }
+    }
+    emitResultUsage(message, fallbackSessionId) {
+        const result = message;
+        const usage = normalizeClaudeUsage(result.usage);
+        if (!usage)
+            return;
+        const sessionId = fallbackSessionId ||
+            (typeof result.session_id === "string"
+                ? result.session_id
+                : typeof result.sessionId === "string"
+                    ? result.sessionId
+                    : fallbackSessionId);
+        this.pushEvent("usage", {
+            sessionId,
+            messageId: this.lastAssistantMessageBySession.get(sessionId),
+            usage,
+            cost: typeof result.total_cost_usd === "number" && Number.isFinite(result.total_cost_usd)
+                ? result.total_cost_usd
+                : undefined,
+            createdAt: Date.now(),
+        });
+    }
+    emitToolResults(message, sessionId) {
+        const content = message.message?.content;
+        if (!Array.isArray(content))
+            return;
+        const messageId = makeMessageId(message, sessionId);
+        for (const part of content) {
+            if (part.type !== "tool_result")
+                continue;
+            const toolUseId = typeof part.tool_use_id === "string"
+                ? part.tool_use_id
+                : typeof part.toolUseID === "string"
+                    ? part.toolUseID
+                    : "tool";
+            this.pushEvent("tool", {
+                sessionId,
+                messageId,
+                toolUseId,
+                toolName: "tool",
+                input: {},
+                output: formatToolResult(part.content),
+                status: "completed",
+                createdAt: Date.now(),
+            });
+        }
+    }
+    handleToolPermission(toolName, input, id, signal) {
+        if (toolName === ASK_USER_QUESTION_TOOL) {
+            return this.handleUserQuestion(input, id, signal);
+        }
+        if (toolName === EXIT_PLAN_MODE_TOOL) {
+            return this.handlePlanApproval(input, id, signal);
+        }
+        return new Promise((resolve, reject) => {
+            const request = {
+                id,
+                toolName,
+                input,
+                createdAt: Date.now(),
+            };
+            const abort = () => {
+                this.pendingPermissions.delete(id);
+                this.pushEvent("permission-resolved", { id, approved: false });
+                reject(new Error("permission request aborted"));
+            };
+            signal.addEventListener("abort", abort, { once: true });
+            this.pendingPermissions.set(id, {
+                request,
+                resolve: (result) => {
+                    signal.removeEventListener("abort", abort);
+                    resolve(result);
+                },
+                reject: (error) => {
+                    signal.removeEventListener("abort", abort);
+                    reject(error);
+                },
+            });
+            this.pushEvent("permission", {
+                id,
+                toolName,
+                input,
+                createdAt: request.createdAt,
+                sessionId: this.activeSessionId ?? this.resumeSessionId,
+            });
+            this.emitState();
+        });
+    }
+    handlePlanApproval(input, id, signal) {
+        return new Promise((resolve, reject) => {
+            const request = {
+                id,
+                toolName: EXIT_PLAN_MODE_TOOL,
+                input,
+                createdAt: Date.now(),
+            };
+            const abort = () => {
+                this.pendingPermissions.delete(id);
+                this.pushEvent("permission-resolved", { id, approved: false });
+                this.pushEvent("plan.approval.resolved", {
+                    id,
+                    requestID: id,
+                    approved: false,
+                    sessionId: this.activeSessionId ?? this.resumeSessionId,
+                });
+                reject(new Error("plan approval request aborted"));
+            };
+            signal.addEventListener("abort", abort, { once: true });
+            this.pendingPermissions.set(id, {
+                request,
+                resolve: (result) => {
+                    signal.removeEventListener("abort", abort);
+                    resolve(result);
+                },
+                reject: (error) => {
+                    signal.removeEventListener("abort", abort);
+                    reject(error);
+                },
+            });
+            const inputRecord = asRecord(input);
+            this.pushEvent("plan.approval.requested", {
+                id,
+                requestID: id,
+                sessionID: this.activeSessionId ?? this.resumeSessionId,
+                sessionId: this.activeSessionId ?? this.resumeSessionId,
+                input: inputRecord,
+                plan: readString(inputRecord.plan),
+                allowedPrompts: Array.isArray(inputRecord.allowedPrompts)
+                    ? inputRecord.allowedPrompts
+                    : undefined,
+                tool: {
+                    messageID: this.lastAssistantMessageBySession.get(this.activeSessionId ?? this.resumeSessionId ?? "") ?? "",
+                    callID: id,
+                },
+                createdAt: request.createdAt,
+            });
+            this.pushEvent("permission", {
+                id,
+                toolName: EXIT_PLAN_MODE_TOOL,
+                input,
+                createdAt: request.createdAt,
+                sessionId: this.activeSessionId ?? this.resumeSessionId,
+            });
+            this.emitState();
+        });
+    }
+    handleUserQuestion(input, id, signal) {
+        const inputRecord = asRecord(input);
+        const questions = normalizeQuestionInput(inputRecord);
+        if (questions.length === 0) {
+            return Promise.resolve({
+                behavior: "deny",
+                message: "AskUserQuestion did not include any valid questions.",
+                toolUseID: id,
+            });
+        }
+        return new Promise((resolve, reject) => {
+            const request = {
+                id,
+                input: inputRecord,
+                createdAt: Date.now(),
+            };
+            const abort = () => {
+                this.pendingQuestions.delete(id);
+                this.pushEvent("question.rejected", {
+                    id,
+                    requestID: id,
+                    sessionId: this.activeSessionId ?? this.resumeSessionId,
+                });
+                reject(new Error("question request aborted"));
+            };
+            signal.addEventListener("abort", abort, { once: true });
+            this.pendingQuestions.set(id, {
+                request,
+                resolve: (result) => {
+                    signal.removeEventListener("abort", abort);
+                    resolve(result);
+                },
+                reject: (error) => {
+                    signal.removeEventListener("abort", abort);
+                    reject(error);
+                },
+            });
+            this.pushEvent("question.asked", {
+                id,
+                sessionID: this.activeSessionId ?? this.resumeSessionId,
+                sessionId: this.activeSessionId ?? this.resumeSessionId,
+                questions,
+                tool: {
+                    messageID: this.lastAssistantMessageBySession.get(this.activeSessionId ?? this.resumeSessionId ?? "") ?? "",
+                    callID: id,
+                },
+                createdAt: request.createdAt,
+            });
+            this.emitState();
+        });
+    }
+    attachReclaimInput() {
+        if (this.reclaimAttached || !process.stdin.isTTY)
+            return;
+        this.reclaimAttached = true;
+        this.reclaimBuffer = "";
+        try {
+            process.stdin.setEncoding("utf8");
+            process.stdin.resume();
+            process.stdin.on("data", this.onReclaimInput);
+        }
+        catch {
+            this.reclaimAttached = false;
+        }
+    }
+    detachReclaimInput() {
+        if (!this.reclaimAttached)
+            return;
+        this.reclaimAttached = false;
+        process.stdin.off("data", this.onReclaimInput);
+        this.reclaimBuffer = "";
+        try {
+            process.stdin.pause();
+            if (process.stdin.isTTY && typeof process.stdin.setRawMode === "function") {
+                process.stdin.setRawMode(false);
+            }
+        }
+        catch { }
+    }
+    onReclaimInput = (chunk) => {
+        const text = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+        if (text === "\u0003") {
+            this.stop();
+            return;
+        }
+        this.reclaimBuffer += text;
+        if (this.reclaimBuffer.length > 200) {
+            this.reclaimBuffer = this.reclaimBuffer.slice(-200);
+        }
+        if (this.reclaimBuffer.includes(RECLAIM_COMMAND)) {
+            this.reclaimBuffer = "";
+            void this.releaseToLocal();
+            return;
+        }
+        if (text.includes("\n") || text.includes("\r")) {
+            process.stderr.write(`[adit cloud claude] Web owns this session. Type ${RECLAIM_COMMAND} to reclaim.\n`);
+        }
+    };
+    pickResumeSessionId(opts) {
+        const candidates = [
+            this.resumeSessionId,
+            this.activeSessionId,
+            this.remoteSdkSessionId,
+            this.sdkSessionId,
+        ];
+        for (const id of candidates) {
+            if (id && isValidClaudeSession(id, this.opts.cwd)) {
+                this.resumeSessionId = id;
+                this.activeSessionId = id;
+                this.refreshActiveModel({ sessionId: id });
+                return id;
+            }
+        }
+        if (!opts.fallbackToLatest)
+            return null;
+        const latest = findLastClaudeSession(this.opts.cwd);
+        if (latest) {
+            this.resumeSessionId = latest;
+            this.activeSessionId = latest;
+            this.refreshActiveModel({ sessionId: latest });
+            this.emitState();
+            return latest;
+        }
+        this.resumeSessionId = null;
+        return null;
+    }
+    setBusy(value) {
+        if (this.busyValue === value)
+            return;
+        this.busyValue = value;
+        this.emitState();
+    }
+    setThinking(value) {
+        if (this.thinkingValue === value)
+            return;
+        this.thinkingValue = value;
+        this.emitState();
+    }
+    emitState() {
+        this.emit("state", this.state);
+        this.pushEvent("state", {
+            owner: this.ownerValue,
+            busy: this.busyValue,
+            thinking: this.thinkingValue,
+            activeSessionId: this.activeSessionId,
+            resumeSessionId: this.resumeSessionId,
+            sdkSessionId: this.sdkSessionId,
+            activeModelId: this.activeModelId,
+            createdAt: Date.now(),
+        });
+    }
+    pushEvent(type, payload) {
+        this.opts.onEvent?.({ type, payload });
+    }
+    buildEnv() {
+        return {
+            ...process.env,
+            TERM: process.env.TERM || "xterm-256color",
+            COLORTERM: process.env.COLORTERM || "truecolor",
+            FORCE_COLOR: process.env.FORCE_COLOR || "3",
+            DISABLE_AUTOUPDATER: "1",
+        };
+    }
+    refreshActiveModel(opts = {}) {
+        const modelId = resolveClaudeModel({
+            cwd: this.opts.cwd,
+            sessionId: opts.sessionId ?? this.activeSessionId ?? this.resumeSessionId,
+        });
+        if (modelId && modelId !== this.activeModelId) {
+            this.activeModelId = modelId;
+        }
+        return this.activeModelId;
+    }
+    rememberRemoteSdkSession(activeSessionId, sdkSessionId) {
+        if (!activeSessionId || !sdkSessionId || activeSessionId === sdkSessionId)
+            return;
+        let ids = this.remoteSdkSessionIdsByActiveSession.get(activeSessionId);
+        if (!ids) {
+            ids = new Set();
+            this.remoteSdkSessionIdsByActiveSession.set(activeSessionId, ids);
+        }
+        ids.add(sdkSessionId);
+    }
+    mergeRemoteTranscriptsIntoActive(activeSessionId = this.activeSessionId, remoteSessionId = this.remoteSdkSessionId ?? this.sdkSessionId) {
+        if (!activeSessionId)
+            return;
+        const remoteSessionIds = new Set();
+        const remembered = this.remoteSdkSessionIdsByActiveSession.get(activeSessionId);
+        if (remembered) {
+            for (const id of remembered)
+                remoteSessionIds.add(id);
+        }
+        if (remoteSessionId)
+            remoteSessionIds.add(remoteSessionId);
+        if (this.remoteSdkSessionId)
+            remoteSessionIds.add(this.remoteSdkSessionId);
+        if (this.sdkSessionId)
+            remoteSessionIds.add(this.sdkSessionId);
+        for (const id of remoteSessionIds) {
+            if (!id || id === activeSessionId)
+                continue;
+            mergeClaudeSessionTranscript({
+                cwd: this.opts.cwd,
+                sourceSessionId: id,
+                targetSessionId: activeSessionId,
+            });
+        }
+    }
+}
+function toUserMessage(message, sessionId) {
+    return {
+        type: "user",
+        ...(sessionId ? { session_id: sessionId } : {}),
+        parent_tool_use_id: null,
+        message: {
+            role: "user",
+            content: message,
+        },
+    };
+}
+function extractSessionId(message) {
+    const maybe = message;
+    if (typeof maybe.session_id === "string")
+        return maybe.session_id;
+    if (typeof maybe.sessionId === "string")
+        return maybe.sessionId;
+    return null;
+}
+function extractModelId(message) {
+    const maybe = message;
+    if (typeof maybe.message?.model === "string" && maybe.message.model.trim()) {
+        return maybe.message.model.trim();
+    }
+    if (typeof maybe.model === "string" && maybe.model.trim()) {
+        return maybe.model.trim();
+    }
+    return null;
+}
+function makeMessageId(message, sessionId) {
+    const maybe = message;
+    if (typeof maybe.message?.id === "string")
+        return maybe.message.id;
+    if (typeof maybe.uuid === "string")
+        return maybe.uuid;
+    return `claude-${sessionId}-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+}
+function normalizeClaudeUsage(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const usage = value;
+    const normalized = {};
+    for (const key of [
+        "input_tokens",
+        "output_tokens",
+        "cache_read_input_tokens",
+        "cache_creation_input_tokens",
+        "reasoning_tokens",
+    ]) {
+        const numberValue = usage[key];
+        if (typeof numberValue === "number" && Number.isFinite(numberValue)) {
+            normalized[key] = numberValue;
+        }
+    }
+    return Object.keys(normalized).length > 0 ? normalized : undefined;
+}
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+function normalizeQuestionInput(input) {
+    const rawQuestions = Array.isArray(input.questions) ? input.questions : [];
+    const questions = [];
+    for (const rawQuestion of rawQuestions) {
+        const questionRecord = asRecord(rawQuestion);
+        const question = readString(questionRecord.question);
+        if (!question)
+            continue;
+        const options = (Array.isArray(questionRecord.options) ? questionRecord.options : [])
+            .map((rawOption) => {
+            const optionRecord = asRecord(rawOption);
+            const label = readString(optionRecord.label);
+            if (!label)
+                return null;
+            return {
+                label,
+                description: readString(optionRecord.description) ?? "",
+            };
+        })
+            .filter((option) => Boolean(option));
+        if (options.length === 0)
+            continue;
+        questions.push({
+            question,
+            header: readString(questionRecord.header) ?? "Question",
+            options,
+            multiple: questionRecord.multiSelect === true,
+        });
+    }
+    return questions;
+}
+function buildQuestionAnswerMap(questions, answers) {
+    const result = {};
+    questions.forEach((question, index) => {
+        const answer = answers[index] ?? [];
+        result[question.question] = answer.filter(Boolean).join(", ");
+    });
+    return result;
+}
+function formatToolResult(content) {
+    if (typeof content === "string")
+        return content;
+    try {
+        return JSON.stringify(content, null, 2);
+    }
+    catch {
+        return String(content);
+    }
+}
+function getClaudeProjectDir(cwd) {
+    const projectId = path.resolve(cwd).replace(/[^a-zA-Z0-9-]/g, "-");
+    const claudeConfigDir = process.env.CLAUDE_CONFIG_DIR || path.join(homedir(), ".claude");
+    return path.join(claudeConfigDir, "projects", projectId);
+}
+function getClaudeConfigDir() {
+    return process.env.CLAUDE_CONFIG_DIR || path.join(homedir(), ".claude");
+}
+function resolveClaudeModel(input) {
+    return (readLastSessionModel(input.cwd, input.sessionId) ??
+        readSettingsModel(path.join(input.cwd, ".claude", "settings.local.json")) ??
+        readSettingsModel(path.join(input.cwd, ".claude", "settings.json")) ??
+        readSettingsModel(path.join(getClaudeConfigDir(), "settings.json")) ??
+        readString(process.env.ANTHROPIC_MODEL));
+}
+function readLastSessionModel(cwd, sessionId) {
+    if (!sessionId || !isUuid(sessionId))
+        return null;
+    const file = path.join(getClaudeProjectDir(cwd), `${sessionId}.jsonl`);
+    let text;
+    try {
+        text = fs.readFileSync(file, "utf8");
+    }
+    catch {
+        return null;
+    }
+    let lastModel = null;
+    for (const line of text.split("\n")) {
+        if (!line.trim())
+            continue;
+        try {
+            const parsed = JSON.parse(line);
+            const obj = asRecord(parsed);
+            const message = asRecord(obj.message);
+            const model = readString(message.model) ?? readString(obj.model);
+            if (model)
+                lastModel = model;
+        }
+        catch { }
+    }
+    return lastModel;
+}
+function readSettingsModel(file) {
+    let parsed;
+    try {
+        parsed = JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    catch {
+        return null;
+    }
+    const settings = asRecord(parsed);
+    const env = asRecord(settings.env);
+    return (readString(env.ANTHROPIC_MODEL) ??
+        readString(settings.model) ??
+        readString(env.ANTHROPIC_DEFAULT_SONNET_MODEL) ??
+        readString(env.ANTHROPIC_DEFAULT_OPUS_MODEL) ??
+        readString(env.ANTHROPIC_DEFAULT_HAIKU_MODEL));
+}
+function readString(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function isUuid(value) {
+    return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value);
+}
+function isValidClaudeSession(sessionId, cwd) {
+    if (!isUuid(sessionId))
+        return false;
+    const file = path.join(getClaudeProjectDir(cwd), `${sessionId}.jsonl`);
+    let text;
+    try {
+        text = fs.readFileSync(file, "utf8");
+    }
+    catch {
+        return false;
+    }
+    for (const line of text.split("\n")) {
+        if (!line.trim())
+            continue;
+        try {
+            const obj = JSON.parse(line);
+            if (typeof obj?.uuid === "string" && obj.uuid.length > 0)
+                return true;
+            if (typeof obj?.messageId === "string" && obj.messageId.length > 0)
+                return true;
+            if (typeof obj?.leafUuid === "string" && obj.leafUuid.length > 0)
+                return true;
+            if (typeof obj?.message?.id === "string" && obj.message.id.length > 0)
+                return true;
+        }
+        catch { }
+    }
+    return false;
+}
+function mergeClaudeSessionTranscript(input) {
+    if (!isUuid(input.sourceSessionId) ||
+        !isUuid(input.targetSessionId) ||
+        input.sourceSessionId === input.targetSessionId) {
+        return;
+    }
+    const projectDir = getClaudeProjectDir(input.cwd);
+    const sourceFile = path.join(projectDir, `${input.sourceSessionId}.jsonl`);
+    const targetFile = path.join(projectDir, `${input.targetSessionId}.jsonl`);
+    let sourceText;
+    try {
+        sourceText = fs.readFileSync(sourceFile, "utf8");
+    }
+    catch {
+        return;
+    }
+    let targetText = "";
+    try {
+        targetText = fs.readFileSync(targetFile, "utf8");
+    }
+    catch { }
+    const targetKeys = new Set();
+    for (const line of targetText.split("\n")) {
+        const key = transcriptLineKey(line);
+        if (key)
+            targetKeys.add(key);
+    }
+    const linesToAppend = [];
+    let lastTargetUuid = readLastTranscriptUuid(targetText);
+    for (const line of sourceText.split("\n")) {
+        if (!line.trim())
+            continue;
+        const normalized = normalizeTranscriptLineForSession(line, input.sourceSessionId, input.targetSessionId, lastTargetUuid);
+        if (!normalized)
+            continue;
+        const key = transcriptLineKey(normalized);
+        if (key && targetKeys.has(key))
+            continue;
+        if (key)
+            targetKeys.add(key);
+        linesToAppend.push(normalized);
+        const uuid = readTranscriptUuid(normalized);
+        if (uuid)
+            lastTargetUuid = uuid;
+    }
+    if (linesToAppend.length === 0)
+        return;
+    fs.mkdirSync(projectDir, { recursive: true });
+    const prefix = targetText && !targetText.endsWith("\n") ? "\n" : "";
+    fs.appendFileSync(targetFile, `${prefix}${linesToAppend.join("\n")}\n`);
+}
+function normalizeTranscriptLineForSession(line, sourceSessionId, targetSessionId, fallbackParentUuid) {
+    let parsed;
+    try {
+        parsed = JSON.parse(line);
+    }
+    catch {
+        return null;
+    }
+    const obj = asRecord(parsed);
+    if (readString(obj.sessionId) !== sourceSessionId)
+        return null;
+    obj.sessionId = targetSessionId;
+    if (obj.parentUuid === null && fallbackParentUuid) {
+        obj.parentUuid = fallbackParentUuid;
+    }
+    return JSON.stringify(obj);
+}
+function transcriptLineKey(line) {
+    if (!line.trim())
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(line);
+    }
+    catch {
+        return line.trim();
+    }
+    const obj = asRecord(parsed);
+    return (readString(obj.uuid) ??
+        readString(obj.messageId) ??
+        readString(obj.leafUuid) ??
+        readString(obj.promptId) ??
+        line.trim());
+}
+function readTranscriptUuid(line) {
+    let parsed;
+    try {
+        parsed = JSON.parse(line);
+    }
+    catch {
+        return null;
+    }
+    return readString(asRecord(parsed).uuid);
+}
+function readLastTranscriptUuid(text) {
+    let uuid = null;
+    for (const line of text.split("\n")) {
+        const next = readTranscriptUuid(line);
+        if (next)
+            uuid = next;
+    }
+    return uuid;
+}
+function findLastClaudeSession(cwd) {
+    const projectDir = getClaudeProjectDir(cwd);
+    let files;
+    try {
+        files = fs.readdirSync(projectDir);
+    }
+    catch {
+        return null;
+    }
+    const candidates = files
+        .filter((name) => name.endsWith(".jsonl"))
+        .map((name) => {
+        const id = name.slice(0, -".jsonl".length);
+        if (!isUuid(id) || !isValidClaudeSession(id, cwd))
+            return null;
+        try {
+            return { id, mtime: fs.statSync(path.join(projectDir, name)).mtimeMs };
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((item) => Boolean(item))
+        .sort((a, b) => b.mtime - a.mtime);
+    return candidates[0]?.id ?? null;
+}
+//# sourceMappingURL=claude-code-provider.js.map