codebuff 1.0.249 → 1.0.250

package/dist/client.js

@@ -0,0 +1,836 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Client = void 0;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const actions_1 = require("./common/actions");
+const constants_1 = require("./common/api-keys/constants");
+const constants_2 = require("./common/constants");
+const analytics_events_1 = require("./common/constants/analytics-events");
+const constants_3 = require("./common/json-config/constants");
+const agent_state_1 = require("./common/types/agent-state");
+const array_1 = require("./common/util/array");
+const string_1 = require("./common/util/string");
+const websocket_client_1 = require("./common/websockets/websocket-client");
+const picocolors_1 = require("picocolors");
+const ts_pattern_1 = require("ts-pattern");
+const zod_1 = require("zod");
+const background_process_manager_1 = require("./background-process-manager");
+const browser_runner_1 = require("./browser-runner");
+const chat_storage_1 = require("./chat-storage");
+const checkpoint_manager_1 = require("./checkpoints/checkpoint-manager");
+const config_1 = require("./config");
+const credentials_1 = require("./credentials");
+const fingerprint_1 = require("./fingerprint");
+const menu_1 = require("./menu");
+const project_files_1 = require("./project-files");
+const tool_handlers_1 = require("./tool-handlers");
+const analytics_1 = require("./utils/analytics");
+const logger_1 = require("./utils/logger");
+const spinner_1 = require("./utils/spinner");
+const tool_renderers_1 = require("./utils/tool-renderers");
+const xml_stream_parser_1 = require("./utils/xml-stream-parser");
+const web_scraper_1 = require("./web-scraper");
+const LOW_BALANCE_THRESHOLD = 100;
+const WARNING_CONFIG = {
+    [constants_2.UserState.LOGGED_OUT]: {
+        message: () => `Type "login" to unlock full access and get free credits!`,
+        threshold: 100,
+    },
+    [constants_2.UserState.DEPLETED]: {
+        message: () => [
+            (0, picocolors_1.red)(`\n❌ You have used all your credits.`),
+            `Visit ${(0, picocolors_1.bold)((0, picocolors_1.blue)(config_1.websiteUrl + '/usage'))} to add more credits and continue coding.`,
+        ].join('\n'),
+        threshold: 100,
+    },
+    [constants_2.UserState.CRITICAL]: {
+        message: (credits) => [
+            (0, picocolors_1.yellow)(`\n🪫 Only ${(0, picocolors_1.bold)((0, string_1.pluralize)(credits, 'credit'))} remaining!`),
+            (0, picocolors_1.yellow)(`Visit ${(0, picocolors_1.bold)(config_1.websiteUrl + '/usage')} to add more credits.`),
+        ].join('\n'),
+        threshold: 85,
+    },
+    [constants_2.UserState.ATTENTION_NEEDED]: {
+        message: (credits) => [
+            (0, picocolors_1.yellow)(`\n⚠️ ${(0, picocolors_1.bold)((0, string_1.pluralize)(credits, 'credit'))} remaining. Consider topping up soon.`),
+        ].join('\n'),
+        threshold: 75,
+    },
+    [constants_2.UserState.GOOD_STANDING]: {
+        message: () => '',
+        threshold: 0,
+    },
+};
+class Client {
+    webSocket;
+    freshPrompt;
+    reconnectWhenNextIdle;
+    fingerprintId;
+    costMode;
+    hadFileChanges = false;
+    git;
+    rl;
+    responseComplete = false;
+    responseBuffer = '';
+    oneTimeFlags = Object.fromEntries(constants_2.ONE_TIME_LABELS.map((tag) => [tag, false]));
+    usageData = {
+        usage: 0,
+        remainingBalance: null,
+        balanceBreakdown: undefined,
+        next_quota_reset: null,
+    };
+    pendingTopUpMessageAmount = 0;
+    fileContext;
+    lastChanges = [];
+    agentState;
+    originalFileVersions = {};
+    creditsByPromptId = {};
+    user;
+    lastWarnedPct = 0;
+    storedApiKeyTypes = [];
+    lastToolResults = [];
+    model;
+    constructor({ websocketUrl, onWebSocketError, onWebSocketReconnect, freshPrompt, reconnectWhenNextIdle, costMode, git, rl, model, }) {
+        this.costMode = costMode;
+        this.model = model;
+        this.git = git;
+        this.webSocket = new websocket_client_1.APIRealtimeClient(websocketUrl, onWebSocketError, onWebSocketReconnect);
+        this.user = this.getUser();
+        this.initFingerprintId();
+        this.freshPrompt = freshPrompt;
+        this.reconnectWhenNextIdle = reconnectWhenNextIdle;
+        this.rl = rl;
+        logger_1.logger.info({ eventId: analytics_events_1.AnalyticsEvent.APP_LAUNCHED }, 'App launched');
+    }
+    async exit() {
+        if (browser_runner_1.activeBrowserRunner) {
+            browser_runner_1.activeBrowserRunner.shutdown();
+        }
+        process.exit(0);
+    }
+    initAgentState(projectFileContext) {
+        this.agentState = (0, agent_state_1.getInitialAgentState)(projectFileContext);
+        this.fileContext = projectFileContext;
+    }
+    initFingerprintId() {
+        if (!this.fingerprintId) {
+            this.fingerprintId = this.user?.fingerprintId ?? (0, fingerprint_1.calculateFingerprint)();
+        }
+        return this.fingerprintId;
+    }
+    getUser() {
+        if (!(0, fs_1.existsSync)(credentials_1.CREDENTIALS_PATH)) {
+            return;
+        }
+        const credentialsFile = (0, fs_1.readFileSync)(credentials_1.CREDENTIALS_PATH, 'utf8');
+        const user = (0, credentials_1.userFromJson)(credentialsFile);
+        if (user) {
+            (0, analytics_1.identifyUser)(user.id, {
+                email: user.email,
+                name: user.name,
+                fingerprintId: this.fingerprintId,
+            });
+            logger_1.loggerContext.userId = user.id;
+            logger_1.loggerContext.userEmail = user.email;
+            logger_1.loggerContext.fingerprintId = user.fingerprintId;
+        }
+        return user;
+    }
+    async connect() {
+        await this.webSocket.connect();
+        this.setupSubscriptions();
+        await this.fetchStoredApiKeyTypes();
+    }
+    async fetchStoredApiKeyTypes() {
+        if (!this.user || !this.user.authToken) {
+            return;
+        }
+        // const TIMEOUT_MS = 5_000
+        //   try {
+        //     const timeoutPromise = new Promise<Response>((_, reject) => {
+        //       setTimeout(() => reject(new Error('Request timed out')), TIMEOUT_MS)
+        //     })
+        //     const fetchPromise = fetch(
+        //       `${process.env.NEXT_PUBLIC_APP_URL}/api/api-keys`,
+        //       {
+        //         method: 'GET',
+        //         headers: {
+        //           'Content-Type': 'application/json',
+        //           Cookie: `next-auth.session-token=${this.user.authToken}`,
+        //           Authorization: `Bearer ${this.user.authToken}`,
+        //         },
+        //       }
+        //     )
+        //     const response = await Promise.race([fetchPromise, timeoutPromise])
+        //     if (response.ok) {
+        //       const { keyTypes } = await response.json()
+        //       this.storedApiKeyTypes = keyTypes as ApiKeyType[]
+        //     } else {
+        //       this.storedApiKeyTypes = []
+        //     }
+        //   } catch (error) {
+        //     if (process.env.NODE_ENV !== 'production') {
+        //       console.error(
+        //         'Error fetching stored API key types (is there something else on port 3000?):',
+        //         error
+        //       )
+        //     }
+        //     this.storedApiKeyTypes = []
+        //   }
+        this.storedApiKeyTypes = [];
+    }
+    async handleAddApiKey(keyType, apiKey) {
+        if (!this.user || !this.user.authToken) {
+            console.log((0, picocolors_1.yellow)("Please log in first using 'login'."));
+            this.freshPrompt();
+            return;
+        }
+        const readableKeyType = constants_1.READABLE_NAME[keyType];
+        spinner_1.Spinner.get().start();
+        try {
+            const response = await fetch(`${process.env.NEXT_PUBLIC_APP_URL}/api/api-keys`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Cookie: `next-auth.session-token=${this.user.authToken}`,
+                },
+                body: JSON.stringify({
+                    keyType,
+                    apiKey,
+                    authToken: this.user.authToken,
+                }),
+            });
+            spinner_1.Spinner.get().stop();
+            const respJson = await response.json();
+            if (response.ok) {
+                console.log((0, picocolors_1.green)(`Successfully added ${readableKeyType} API key.`));
+                if (!this.storedApiKeyTypes.includes(keyType)) {
+                    this.storedApiKeyTypes.push(keyType);
+                }
+            }
+            else {
+                throw new Error(respJson.message);
+            }
+        }
+        catch (e) {
+            spinner_1.Spinner.get().stop();
+            const error = e;
+            console.error((0, picocolors_1.red)('Error adding API key: ' + error.message));
+        }
+        finally {
+            this.freshPrompt();
+        }
+    }
+    async handleReferralCode(referralCode) {
+        if (this.user) {
+            try {
+                const redeemReferralResp = await fetch(`${process.env.NEXT_PUBLIC_APP_URL}/api/referrals`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        Cookie: `next-auth.session-token=${this.user.authToken};`,
+                    },
+                    body: JSON.stringify({
+                        referralCode,
+                        authToken: this.user.authToken,
+                    }),
+                });
+                const respJson = await redeemReferralResp.json();
+                if (redeemReferralResp.ok) {
+                    console.log([
+                        (0, picocolors_1.green)(`Noice, you've earned an extra ${respJson.credits_redeemed} credits!`),
+                        `(pssst: you can also refer new users and earn ${constants_2.CREDITS_REFERRAL_BONUS} credits for each referral at: ${process.env.NEXT_PUBLIC_APP_URL}/referrals)`,
+                    ].join('\n'));
+                    this.getUsage();
+                }
+                else {
+                    throw new Error(respJson.error);
+                }
+            }
+            catch (e) {
+                const error = e;
+                console.error((0, picocolors_1.red)('Error: ' + error.message));
+                this.freshPrompt();
+            }
+        }
+        else {
+            await this.login(referralCode);
+        }
+    }
+    async logout() {
+        if (this.user) {
+            try {
+                const response = await fetch(`${config_1.websiteUrl}/api/auth/cli/logout`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        authToken: this.user.authToken,
+                        userId: this.user.id,
+                        fingerprintId: this.user.fingerprintId,
+                        fingerprintHash: this.user.fingerprintHash,
+                    }),
+                });
+                if (!response.ok) {
+                    const error = await response.text();
+                    console.error((0, picocolors_1.red)('Failed to log out: ' + error));
+                }
+                try {
+                    (0, fs_1.unlinkSync)(credentials_1.CREDENTIALS_PATH);
+                    console.log(`You (${this.user.name}) have been logged out.`);
+                    this.user = undefined;
+                    this.pendingTopUpMessageAmount = 0;
+                    this.usageData = {
+                        usage: 0,
+                        remainingBalance: null,
+                        balanceBreakdown: undefined,
+                        next_quota_reset: null,
+                    };
+                    this.oneTimeFlags = Object.fromEntries(constants_2.ONE_TIME_LABELS.map((tag) => [tag, false]));
+                }
+                catch (error) {
+                    console.error('Error removing credentials file:', error);
+                }
+            }
+            catch (error) {
+                console.error('Error during logout:', error);
+            }
+        }
+    }
+    async login(referralCode) {
+        if (this.user) {
+            console.log(`You are currently logged in as ${this.user.name}. Please enter "logout" first if you want to login as a different user.`);
+            this.freshPrompt();
+            return;
+        }
+        try {
+            const response = await fetch(`${config_1.websiteUrl}/api/auth/cli/code`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    fingerprintId: await this.fingerprintId,
+                    referralCode,
+                }),
+            });
+            if (!response.ok) {
+                const error = await response.text();
+                console.error((0, picocolors_1.red)('Login code request failed: ' + error));
+                this.freshPrompt();
+                return;
+            }
+            const { loginUrl, fingerprintHash, expiresAt } = await response.json();
+            const responseToUser = [
+                '\n',
+                `Press ${(0, picocolors_1.blue)('ENTER')} to open your browser and finish logging in...`,
+            ];
+            console.log(responseToUser.join('\n'));
+            let shouldRequestLogin = true;
+            this.rl.once('line', () => {
+                if (shouldRequestLogin) {
+                    (0, child_process_1.spawn)(`open ${loginUrl}`, { shell: true });
+                    console.log("Opened a browser window to log you in! If it doesn't open automatically, you can click this link:");
+                    console.log();
+                    console.log((0, picocolors_1.blue)((0, picocolors_1.bold)((0, picocolors_1.underline)(loginUrl))));
+                }
+            });
+            const initialTime = Date.now();
+            const pollInterval = setInterval(async () => {
+                if (Date.now() - initialTime > 5 * 60 * 1000 && shouldRequestLogin) {
+                    shouldRequestLogin = false;
+                    console.log('Unable to login. Please try again by typing "login" in the terminal.');
+                    this.freshPrompt();
+                    clearInterval(pollInterval);
+                    return;
+                }
+                if (!shouldRequestLogin) {
+                    clearInterval(pollInterval);
+                    return;
+                }
+                try {
+                    const fingerprintId = await this.fingerprintId;
+                    const statusResponse = await fetch(`${config_1.websiteUrl}/api/auth/cli/status?fingerprintId=${fingerprintId}&fingerprintHash=${fingerprintHash}&expiresAt=${expiresAt}`);
+                    if (!statusResponse.ok) {
+                        if (statusResponse.status !== 401) {
+                            // Ignore 401s during polling
+                            console.error('Error checking login status:', await statusResponse.text());
+                        }
+                        return;
+                    }
+                    const { user, message } = await statusResponse.json();
+                    if (user) {
+                        shouldRequestLogin = false;
+                        this.user = user;
+                        (0, analytics_1.identifyUser)(user.id, {
+                            email: user.email,
+                            name: user.name,
+                            fingerprintId: fingerprintId,
+                        });
+                        logger_1.loggerContext.userId = user.id;
+                        logger_1.loggerContext.userEmail = user.email;
+                        logger_1.loggerContext.fingerprintId = fingerprintId;
+                        logger_1.logger.info({
+                            eventId: analytics_events_1.AnalyticsEvent.LOGIN,
+                        }, 'login');
+                        const credentialsPathDir = path_1.default.dirname(credentials_1.CREDENTIALS_PATH);
+                        (0, fs_1.mkdirSync)(credentialsPathDir, { recursive: true });
+                        (0, fs_1.writeFileSync)(credentials_1.CREDENTIALS_PATH, JSON.stringify({ default: user }));
+                        const referralLink = `${process.env.NEXT_PUBLIC_APP_URL}/referrals`;
+                        const responseToUser = [
+                            'Authentication successful! 🎉',
+                            (0, picocolors_1.bold)(`Hey there, ${user.name}.`),
+                            `Refer new users and earn ${constants_2.CREDITS_REFERRAL_BONUS} credits per month: ${(0, picocolors_1.blueBright)(referralLink)}`,
+                        ];
+                        console.log('\n' + responseToUser.join('\n'));
+                        this.lastWarnedPct = 0;
+                        this.oneTimeFlags = Object.fromEntries(constants_2.ONE_TIME_LABELS.map((tag) => [tag, false]));
+                        (0, menu_1.displayGreeting)(this.costMode, null);
+                        clearInterval(pollInterval);
+                        this.freshPrompt();
+                    }
+                }
+                catch (error) {
+                    console.error('Error checking login status:', error);
+                }
+            }, 5000);
+        }
+        catch (error) {
+            console.error('Error during login:', error);
+            this.freshPrompt();
+        }
+    }
+    setUsage(usageData) {
+        this.usageData = usageData;
+    }
+    reconnect() {
+        this.webSocket.forceReconnect();
+    }
+    setupSubscriptions() {
+        this.webSocket.subscribe('action-error', (action) => {
+            if (action.error === 'Insufficient credits') {
+                console.error(['', (0, picocolors_1.red)(`Error: ${action.message}`)].join('\n'));
+                console.error(`Visit ${(0, picocolors_1.blue)((0, picocolors_1.bold)(process.env.NEXT_PUBLIC_APP_URL + '/usage'))} to add credits.`);
+            }
+            else if (action.error === 'Auto top-up disabled') {
+                console.error(['', (0, picocolors_1.red)(`Error: ${action.message}`)].join('\n'));
+                console.error((0, picocolors_1.yellow)(`Visit ${(0, picocolors_1.blue)((0, picocolors_1.bold)(process.env.NEXT_PUBLIC_APP_URL + '/usage'))} to update your payment settings.`));
+            }
+            else {
+                console.error(['', (0, picocolors_1.red)(`Error: ${action.message}`)].join('\n'));
+            }
+            this.freshPrompt();
+            return;
+        });
+        this.webSocket.subscribe('read-files', (a) => {
+            const { filePaths, requestId } = a;
+            const files = (0, project_files_1.getFiles)(filePaths);
+            this.webSocket.sendAction({
+                type: 'read-files-response',
+                files,
+                requestId,
+            });
+        });
+        this.webSocket.subscribe('npm-version-status', (action) => {
+            const { isUpToDate } = action;
+            if (!isUpToDate) {
+                console.warn((0, picocolors_1.yellow)(`\nThere's a new version of Codebuff! Please update to ensure proper functionality.\nUpdate now by running: npm install -g codebuff`));
+            }
+        });
+        this.webSocket.subscribe('message-cost-response', (action) => {
+            const parsedAction = actions_1.MessageCostResponseSchema.safeParse(action);
+            if (!parsedAction.success)
+                return;
+            const response = parsedAction.data;
+            // Store credits used for this prompt
+            if (!this.creditsByPromptId[response.promptId]) {
+                this.creditsByPromptId[response.promptId] = [];
+            }
+            this.creditsByPromptId[response.promptId].push(response.credits);
+        });
+        this.webSocket.subscribe('usage-response', (action) => {
+            const parsedAction = actions_1.UsageReponseSchema.safeParse(action);
+            if (!parsedAction.success) {
+                console.error((0, picocolors_1.red)('Received invalid usage data from server:'), parsedAction.error.errors);
+                return;
+            }
+            this.setUsage(parsedAction.data);
+            // Store auto-topup amount if present, to be displayed when returning control to user
+            if (parsedAction.data.autoTopupAdded) {
+                this.pendingTopUpMessageAmount += parsedAction.data.autoTopupAdded;
+            }
+            // Only show warning if the response is complete
+            if (this.responseComplete) {
+                this.showUsageWarning();
+            }
+        });
+        // Used to handle server restarts gracefully
+        this.webSocket.subscribe('request-reconnect', () => {
+            this.reconnectWhenNextIdle();
+        });
+    }
+    showUsageWarning() {
+        // Determine user state based on login status and credit balance
+        const state = (0, ts_pattern_1.match)({
+            isLoggedIn: !!this.user,
+            credits: this.usageData.remainingBalance,
+        })
+            .with({ isLoggedIn: false }, () => constants_2.UserState.LOGGED_OUT)
+            .with({ credits: ts_pattern_1.P.number.gte(100) }, () => constants_2.UserState.GOOD_STANDING)
+            .with({ credits: ts_pattern_1.P.number.gte(20) }, () => constants_2.UserState.ATTENTION_NEEDED)
+            .with({ credits: ts_pattern_1.P.number.gte(1) }, () => constants_2.UserState.CRITICAL)
+            .otherwise(() => constants_2.UserState.DEPLETED);
+        const config = WARNING_CONFIG[state];
+        // Reset warning percentage if in good standing
+        if (state === constants_2.UserState.GOOD_STANDING) {
+            this.lastWarnedPct = 0;
+            return;
+        }
+        // Show warning if we haven't warned at this threshold yet
+        if (this.lastWarnedPct < config.threshold &&
+            this.usageData.remainingBalance) {
+            const message = config.message(this.usageData.remainingBalance);
+            console.warn(message);
+            this.lastWarnedPct = config.threshold;
+            this.freshPrompt();
+        }
+    }
+    async generateCommitMessage(stagedChanges) {
+        return new Promise(async (resolve, reject) => {
+            const unsubscribe = this.webSocket.subscribe('commit-message-response', (action) => {
+                unsubscribe();
+                resolve(action.commitMessage);
+            });
+            this.webSocket.sendAction({
+                type: 'generate-commit-message',
+                fingerprintId: await this.fingerprintId,
+                authToken: this.user?.authToken,
+                stagedChanges,
+            });
+        });
+    }
+    async sendUserInput(prompt) {
+        if (!this.agentState) {
+            throw new Error('Agent state not initialized');
+        }
+        const userInputId = `mc-input-` + Math.random().toString(36).substring(2, 15);
+        logger_1.loggerContext.clientRequestId = userInputId;
+        const { responsePromise, stopResponse } = this.subscribeToResponse((chunk) => {
+            spinner_1.Spinner.get().stop();
+            this.displayChunk(chunk);
+        }, userInputId, () => {
+            spinner_1.Spinner.get().stop();
+            this.displayChunk((0, picocolors_1.green)((0, picocolors_1.underline)('\nCodebuff') + ':') + ' ');
+        }, prompt);
+        const urls = (0, web_scraper_1.parseUrlsFromContent)(prompt);
+        const scrapedBlocks = await (0, web_scraper_1.getScrapedContentBlocks)(urls);
+        const scrapedContent = scrapedBlocks.length > 0 ? scrapedBlocks.join('\n\n') + '\n\n' : '';
+        // Append process updates to existing tool results
+        const toolResults = (0, array_1.buildArray)(...(this.lastToolResults || []), ...(0, background_process_manager_1.getBackgroundProcessUpdates)(), scrapedContent && {
+            id: 'scraped-content',
+            name: 'web-scraper',
+            result: scrapedContent,
+        });
+        spinner_1.Spinner.get().start();
+        this.webSocket.sendAction({
+            type: 'prompt',
+            promptId: userInputId,
+            prompt,
+            agentState: this.agentState,
+            toolResults,
+            fingerprintId: await this.fingerprintId,
+            authToken: this.user?.authToken,
+            costMode: this.costMode,
+            model: this.model,
+        });
+        return {
+            responsePromise,
+            stopResponse,
+        };
+    }
+    /**
+     * Shrinks all instances of more than 2 newlines in a row.
+     * Note: don't start or end colored text with newlines
+     * @param chunk chunk to display
+     */
+    displayChunk(chunk) {
+        // Process chunk to limit consecutive newlines
+        const combinedContent = this.responseBuffer + chunk;
+        const processedContent = combinedContent.replace(/\n{3,}/g, '\n\n');
+        const processedChunk = processedContent.slice(this.responseBuffer.length);
+        this.responseBuffer = processedContent;
+        process.stdout.write(processedChunk);
+    }
+    subscribeToResponse(onChunk, userInputId, onStreamStart, prompt) {
+        const rawChunkBuffer = [];
+        this.responseBuffer = '';
+        let streamStarted = false;
+        let responseStopped = false;
+        let resolveResponse;
+        let rejectResponse;
+        let unsubscribeChunks;
+        let unsubscribeComplete;
+        const responsePromise = new Promise((resolve, reject) => {
+            resolveResponse = resolve;
+            rejectResponse = reject;
+        });
+        const stopResponse = () => {
+            responseStopped = true;
+            unsubscribeChunks();
+            unsubscribeComplete();
+            const additionalMessages = [
+                { role: 'user', content: prompt },
+                {
+                    role: 'user',
+                    content: `<system><assistant_message>${rawChunkBuffer.join('')}</assistant_message>[RESPONSE_CANCELED_BY_USER]</system>`,
+                },
+            ];
+            // Update the agent state with just the assistant's response
+            const { messageHistory } = this.agentState;
+            const newMessages = [...messageHistory, ...additionalMessages];
+            this.agentState = {
+                ...this.agentState,
+                messageHistory: newMessages,
+            };
+            (0, chat_storage_1.setMessages)(newMessages);
+            resolveResponse({
+                type: 'prompt-response',
+                promptId: userInputId,
+                agentState: this.agentState,
+                toolCalls: [],
+                toolResults: [],
+                wasStoppedByUser: true,
+            });
+        };
+        const xmlStreamParser = (0, xml_stream_parser_1.createXMLStreamParser)(tool_renderers_1.toolRenderers, (chunk) => {
+            onChunk(chunk);
+        });
+        unsubscribeChunks = this.webSocket.subscribe('response-chunk', (a) => {
+            if (a.userInputId !== userInputId)
+                return;
+            const { chunk } = a;
+            rawChunkBuffer.push(chunk);
+            const trimmed = chunk.trim();
+            for (const tag of constants_2.ONE_TIME_TAGS) {
+                if (trimmed.startsWith(`<${tag}>`) && trimmed.endsWith(`</${tag}>`)) {
+                    if (this.oneTimeFlags[tag]) {
+                        return;
+                    }
+                    spinner_1.Spinner.get().stop();
+                    const warningMessage = trimmed
+                        .replace(`<${tag}>`, '')
+                        .replace(`</${tag}>`, '');
+                    this.displayChunk((0, picocolors_1.yellow)(`\n\n${warningMessage}\n\n`));
+                    this.oneTimeFlags[tag] = true;
+                    return;
+                }
+            }
+            if (chunk && chunk.trim()) {
+                if (!streamStarted && chunk.trim()) {
+                    streamStarted = true;
+                    onStreamStart();
+                }
+            }
+            try {
+                xmlStreamParser.write(chunk, 'utf8');
+            }
+            catch (e) {
+                // console.error('Error writing chunk', e)
+            }
+        });
+        unsubscribeComplete = this.webSocket.subscribe('prompt-response', async (action) => {
+            const parsedAction = actions_1.PromptResponseSchema.safeParse(action);
+            if (!parsedAction.success)
+                return;
+            if (action.promptId !== userInputId)
+                return;
+            const a = parsedAction.data;
+            let isComplete = false;
+            spinner_1.Spinner.get().stop();
+            this.agentState = a.agentState;
+            const toolResults = [...a.toolResults];
+            for (const toolCall of a.toolCalls) {
+                try {
+                    if (toolCall.name === 'end_turn') {
+                        this.responseComplete = true;
+                        isComplete = true;
+                        continue;
+                    }
+                    if (toolCall.name === 'write_file') {
+                        // Save lastChanges for `diff` command
+                        this.lastChanges.push(actions_1.FileChangeSchema.parse(toolCall.parameters));
+                        this.hadFileChanges = true;
+                    }
+                    if (toolCall.name === 'run_terminal_command' &&
+                        toolCall.parameters.mode === 'user') {
+                        // Special case: when terminal command is run it as a user command, then no need to reprompt assistant.
+                        this.responseComplete = true;
+                        isComplete = true;
+                    }
+                    if (toolCall.name === 'run_terminal_command' &&
+                        toolCall.parameters.mode === 'assistant' &&
+                        toolCall.parameters.process_type === 'BACKGROUND') {
+                        this.oneTimeFlags[constants_2.SHOULD_ASK_CONFIG] = true;
+                    }
+                    if (toolCall.name === 'run_terminal_command') {
+                        this.displayChunk('\n\n');
+                        this.responseBuffer = '\n';
+                    }
+                    const toolResult = await (0, tool_handlers_1.handleToolCall)(toolCall, (0, project_files_1.getProjectRoot)());
+                    toolResults.push(toolResult);
+                }
+                catch (error) {
+                    this.displayChunk('\n\n' +
+                        (0, picocolors_1.red)(`Error parsing tool call ${toolCall.name}:\n${error}`) +
+                        '\n\n');
+                }
+            }
+            this.displayChunk('\n\n');
+            // If we had any file changes, update the project context
+            if (this.hadFileChanges) {
+                this.fileContext = await (0, project_files_1.getProjectFileContext)((0, project_files_1.getProjectRoot)(), {});
+            }
+            if (!isComplete) {
+                // Append process updates to existing tool results
+                toolResults.push(...(0, background_process_manager_1.getBackgroundProcessUpdates)());
+                // Continue the prompt with the tool results.
+                this.webSocket.sendAction({
+                    type: 'prompt',
+                    promptId: userInputId,
+                    prompt: undefined,
+                    agentState: this.agentState,
+                    toolResults,
+                    fingerprintId: await this.fingerprintId,
+                    authToken: this.user?.authToken,
+                    costMode: this.costMode,
+                    model: this.model,
+                });
+                return;
+            }
+            this.lastToolResults = toolResults;
+            xmlStreamParser.end();
+            askConfig: if (this.oneTimeFlags[constants_2.SHOULD_ASK_CONFIG] &&
+                !this.oneTimeFlags[constants_2.ASKED_CONFIG]) {
+                this.oneTimeFlags[constants_2.ASKED_CONFIG] = true;
+                if ((0, fs_1.existsSync)(path_1.default.join((0, project_files_1.getProjectRoot)(), constants_3.codebuffConfigFile))) {
+                    break askConfig;
+                }
+                this.displayChunk('\n\n' +
+                    (0, picocolors_1.yellow)(`✨ Recommended: run the 'init' command in order to create a configuration file!
+
+If you would like background processes (like this one) to run automatically whenever Codebuff starts, creating a ${constants_3.codebuffConfigFile} config file can improve your workflow.
+Go to https://www.codebuff.com/config for more information.`) +
+                    '\n\n');
+            }
+            if (this.agentState) {
+                (0, chat_storage_1.setMessages)(this.agentState.messageHistory);
+            }
+            // Show total credits used for this prompt if significant
+            const credits = this.creditsByPromptId[userInputId]?.reduce((a, b) => a + b, 0) ?? 0;
+            if (credits >= constants_2.REQUEST_CREDIT_SHOW_THRESHOLD) {
+                this.displayChunk(`\n\n${(0, string_1.pluralize)(credits, 'credit')} used for this request.\n`);
+            }
+            if (this.hadFileChanges) {
+                let checkpointAddendum = '';
+                try {
+                    checkpointAddendum = ` or "checkpoint ${checkpoint_manager_1.checkpointManager.getLatestCheckpoint().id}" to revert`;
+                }
+                catch (error) {
+                    // No latest checkpoint, don't show addendum
+                }
+                this.displayChunk(`\n\nComplete! Type "diff" to review changes${checkpointAddendum}.\n\n`);
+                this.hadFileChanges = false;
+                this.freshPrompt();
+            }
+            unsubscribeChunks();
+            unsubscribeComplete();
+            resolveResponse({ ...a, wasStoppedByUser: false });
+        });
+        // Reset flags at the start of each response
+        this.responseComplete = false;
+        return {
+            responsePromise,
+            stopResponse,
+        };
+    }
+    async getUsage() {
+        try {
+            const response = await fetch(`${config_1.backendUrl}/api/usage`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    fingerprintId: await this.fingerprintId,
+                    authToken: this.user?.authToken,
+                }),
+            });
+            const data = await response.json();
+            // Use zod schema to validate response
+            const parsedResponse = actions_1.UsageReponseSchema.parse(data);
+            if (data.type === 'action-error') {
+                console.error((0, picocolors_1.red)(data.message));
+                return;
+            }
+            this.setUsage(parsedResponse);
+            const usageLink = `${config_1.websiteUrl}/usage`;
+            const remainingColor = this.usageData.remainingBalance === null
+                ? picocolors_1.yellow
+                : this.usageData.remainingBalance <= 0
+                    ? picocolors_1.red
+                    : this.usageData.remainingBalance <= LOW_BALANCE_THRESHOLD
+                        ? picocolors_1.red
+                        : picocolors_1.green;
+            const totalCreditsUsedThisSession = Object.values(this.creditsByPromptId)
+                .flat()
+                .reduce((sum, credits) => sum + credits, 0);
+            console.log(`Session usage: ${totalCreditsUsedThisSession.toLocaleString()}${this.usageData.remainingBalance !== null
+                ? `. Credits Remaining: ${remainingColor(this.usageData.remainingBalance.toLocaleString())}`
+                : '.'}`);
+            if (this.usageData.next_quota_reset) {
+                const resetDate = new Date(this.usageData.next_quota_reset);
+                const today = new Date();
+                const isToday = resetDate.toDateString() === today.toDateString();
+                const dateDisplay = isToday
+                    ? resetDate.toLocaleString() // Show full date and time for today
+                    : resetDate.toLocaleDateString(); // Just show date otherwise
+                console.log(`Free credits will renew on ${dateDisplay}. Details: ${(0, picocolors_1.underline)((0, picocolors_1.blue)(usageLink))}`);
+            }
+            this.showUsageWarning();
+        }
+        catch (error) {
+            console.error((0, picocolors_1.red)(`Error checking usage: Please reach out to ${process.env.NEXT_PUBLIC_SUPPORT_EMAIL} for help.`));
+            // Check if it's a ZodError for more specific feedback
+            if (error instanceof zod_1.z.ZodError) {
+                console.error((0, picocolors_1.red)('Data validation failed:'), error.errors);
+            }
+            else {
+                console.error(error);
+            }
+        }
+        finally {
+            this.freshPrompt();
+        }
+    }
+    async warmContextCache() {
+        const fileContext = await (0, project_files_1.getProjectFileContext)((0, project_files_1.getProjectRoot)(), {});
+        this.webSocket.subscribe('init-response', (a) => {
+            const parsedAction = actions_1.InitResponseSchema.safeParse(a);
+            if (!parsedAction.success)
+                return;
+            // Set initial usage data from the init response
+            this.setUsage(parsedAction.data);
+        });
+        this.webSocket.sendAction({
+            type: 'init',
+            fingerprintId: await this.fingerprintId,
+            authToken: this.user?.authToken,
+            fileContext,
+        });
+        await this.fetchStoredApiKeyTypes();
+    }
+}
+exports.Client = Client;
+//# sourceMappingURL=client.js.map