vibekit-agent 1.0.0

package/dist/agent.js

@@ -0,0 +1,741 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentClient = void 0;
+const ws_1 = __importDefault(require("ws"));
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+/**
+ * Find the claude binary by checking common installation locations
+ */
+function findClaudeBinary() {
+    // Check for CLAUDE_PATH environment variable first (allows user override)
+    if (process.env.CLAUDE_PATH && fs.existsSync(process.env.CLAUDE_PATH)) {
+        return process.env.CLAUDE_PATH;
+    }
+    const homedir = os.homedir();
+    // Build list of possible paths
+    const possiblePaths = [
+        // Homebrew on macOS (Apple Silicon and Intel)
+        '/opt/homebrew/bin/claude',
+        '/usr/local/bin/claude',
+        // npm global installs with common prefixes
+        path.join(homedir, '.npm-global', 'bin', 'claude'),
+        '/usr/local/lib/node_modules/.bin/claude',
+        // Claude desktop app location on macOS
+        '/Applications/Claude.app/Contents/Resources/claude',
+    ];
+    // Try to get npm global bin directory dynamically
+    try {
+        const npmBin = (0, child_process_1.execSync)('npm bin -g 2>/dev/null', {
+            encoding: 'utf-8',
+            env: { ...process.env, PATH: '/usr/local/bin:/opt/homebrew/bin:/usr/bin:' + (process.env.PATH || '') }
+        }).trim();
+        if (npmBin) {
+            possiblePaths.unshift(path.join(npmBin, 'claude'));
+        }
+    }
+    catch {
+        // Ignore
+    }
+    // Check nvm paths
+    const nvmDir = process.env.NVM_DIR || path.join(homedir, '.nvm');
+    if (fs.existsSync(nvmDir)) {
+        // Check common node versions
+        const versionsDir = path.join(nvmDir, 'versions', 'node');
+        if (fs.existsSync(versionsDir)) {
+            try {
+                const versions = fs.readdirSync(versionsDir);
+                for (const v of versions) {
+                    possiblePaths.push(path.join(versionsDir, v, 'bin', 'claude'));
+                }
+            }
+            catch {
+                // Ignore
+            }
+        }
+    }
+    // Also check fnm (Fast Node Manager) paths
+    const fnmDir = process.env.FNM_MULTISHELL_PATH || path.join(homedir, '.fnm');
+    if (fs.existsSync(fnmDir)) {
+        possiblePaths.push(path.join(fnmDir, 'bin', 'claude'));
+    }
+    // Check each path
+    for (const p of possiblePaths) {
+        try {
+            if (fs.existsSync(p)) {
+                // Verify it's executable
+                fs.accessSync(p, fs.constants.X_OK);
+                console.log(`Found claude at: ${p}`);
+                return p;
+            }
+        }
+        catch {
+            // Not accessible, continue
+        }
+    }
+    // Last resort: try which command with enhanced PATH
+    try {
+        const enhancedPath = [
+            '/opt/homebrew/bin',
+            '/usr/local/bin',
+            path.join(homedir, '.npm-global', 'bin'),
+            process.env.PATH || ''
+        ].join(':');
+        const result = (0, child_process_1.execSync)('which claude', {
+            encoding: 'utf-8',
+            env: { ...process.env, PATH: enhancedPath }
+        }).trim();
+        if (result && fs.existsSync(result)) {
+            console.log(`Found claude via which: ${result}`);
+            return result;
+        }
+    }
+    catch {
+        // Not found
+    }
+    return null;
+}
+// Strip ANSI escape codes
+function stripAnsi(str) {
+    // eslint-disable-next-line no-control-regex
+    return str.replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, '');
+}
+class AgentClient {
+    config;
+    ws = null;
+    claudeProcess = null;
+    reconnectTimeout = null;
+    reconnectDelay = 1000;
+    isConnected = false;
+    currentChatId = null;
+    currentTelegramId = null;
+    currentReplyToMessageId = null;
+    outputBuffer = '';
+    streamingInterval = null;
+    lastFlushedLength = 0;
+    currentMessageId = null;
+    workingDirectory = process.cwd();
+    // Conversation memory: track if we should continue the previous conversation
+    hasActiveConversation = false;
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * Link this computer to a Telegram account
+     */
+    async link() {
+        console.log('Connecting to VibeKit...\n');
+        // Request a link from the server
+        const serverUrl = process.env.VIBEKIT_SERVER || 'https://vibekit.bot';
+        try {
+            // Generate a temporary link code request
+            console.log('To link your computer:');
+            console.log('');
+            console.log('1. Go to @the_vibe_kit_bot on Telegram');
+            console.log('2. Send: /remote');
+            console.log('3. Copy the 6-character code it gives you');
+            console.log('');
+            // Wait for user to enter the code
+            const readline = await Promise.resolve().then(() => __importStar(require('readline')));
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+            });
+            const code = await new Promise((resolve) => {
+                rl.question('Enter the code from Telegram: ', (answer) => {
+                    rl.close();
+                    resolve(answer.trim().toUpperCase());
+                });
+            });
+            if (!code || code.length !== 6) {
+                console.error('Invalid code. Please try again.');
+                process.exit(1);
+            }
+            // Submit the code to the server
+            console.log('\nValidating code...');
+            const response = await fetch(`${serverUrl}/api/agent/link`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ code }),
+            });
+            if (!response.ok) {
+                const errorData = (await response.json().catch(() => ({ error: 'Unknown error' })));
+                console.error(`Link failed: ${errorData.error || 'Invalid code'}`);
+                process.exit(1);
+            }
+            const result = (await response.json());
+            this.config.setCredentials(result.token, result.wsUrl);
+            console.log('\nLinked successfully!');
+            console.log('');
+            console.log('Start the agent with:');
+            console.log('  npx vibekit-agent start');
+            console.log('');
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error('Link failed:', message);
+            process.exit(1);
+        }
+    }
+    /**
+     * Start the agent and connect to VibeKit
+     */
+    async start(directory, autoMode = false) {
+        this.workingDirectory = path.resolve(directory);
+        // Don't persist directory in auto mode (ephemeral container)
+        if (!autoMode) {
+            this.config.setLastDirectory(this.workingDirectory);
+        }
+        console.log(`Starting VibeKit Remote Agent...`);
+        console.log(`Working directory: ${this.workingDirectory}`);
+        // In auto mode, set up Claude credentials from the credentials file
+        if (autoMode) {
+            await this.setupAutoModeCredentials();
+        }
+        // Check for claude binary at startup
+        const claudePath = findClaudeBinary();
+        if (claudePath) {
+            console.log(`Claude Code found: ${claudePath}`);
+        }
+        else {
+            console.error('\nClaude Code not found!');
+            console.error('Please install it: npm install -g @anthropic-ai/claude-code');
+            console.error('Then restart this agent.\n');
+        }
+        console.log('');
+        // Connect to VibeKit WebSocket
+        this.connect();
+        // Handle process signals
+        process.on('SIGINT', () => this.shutdown());
+        process.on('SIGTERM', () => this.shutdown());
+        // Keep the process running
+        await new Promise(() => { });
+    }
+    /**
+     * Run claude command with the given prompt
+     */
+    runClaude(prompt) {
+        // Find the claude binary
+        const claudeBinary = findClaudeBinary();
+        if (!claudeBinary) {
+            console.error('\nClaude Code not found!');
+            console.error('Searched in common locations but could not find the claude binary.');
+            console.error('\nPlease ensure Claude Code is installed:');
+            console.error('  npm install -g @anthropic-ai/claude-code');
+            console.error('\nOr specify the path by running:');
+            console.error('  which claude');
+            if (this.currentChatId && this.currentTelegramId) {
+                this.sendResponse(this.currentChatId, `Error: Claude Code not found on this computer.\n\nPlease install it:\n\`npm install -g @anthropic-ai/claude-code\`\n\nThen restart the agent.`, 'complete');
+            }
+            return;
+        }
+        // Kill any existing process
+        if (this.claudeProcess) {
+            this.claudeProcess.kill();
+        }
+        // Clear streaming state
+        this.stopStreaming();
+        this.outputBuffer = '';
+        this.lastFlushedLength = 0;
+        this.currentMessageId = null;
+        // Build command arguments
+        const allowedTools = this.config.getAllowedTools();
+        const args = ['-p', prompt];
+        // Use --continue flag if we have an active conversation (for context memory)
+        if (this.hasActiveConversation) {
+            args.push('--continue');
+        }
+        if (allowedTools.length === 0) {
+            // No restrictions - allow everything
+            args.push('--dangerously-skip-permissions');
+            console.log(`\nRunning: ${claudeBinary} -p "..."${this.hasActiveConversation ? ' --continue' : ''} --dangerously-skip-permissions`);
+        }
+        else {
+            // Use specific allowed tools
+            args.push('--allowedTools', allowedTools.join(','));
+            console.log(`\nRunning: ${claudeBinary} -p "..."${this.hasActiveConversation ? ' --continue' : ''} --allowedTools ${allowedTools.join(',')}`);
+        }
+        // Spawn claude directly with the full path (no shell needed)
+        this.claudeProcess = (0, child_process_1.spawn)(claudeBinary, args, {
+            cwd: this.workingDirectory,
+            env: process.env,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        // Start streaming interval to send partial output periodically
+        this.startStreaming();
+        this.claudeProcess.stdout?.on('data', (data) => {
+            const text = data.toString();
+            process.stdout.write(text);
+            this.outputBuffer += text;
+        });
+        this.claudeProcess.stderr?.on('data', (data) => {
+            const text = data.toString();
+            process.stderr.write(text);
+            this.outputBuffer += text;
+        });
+        this.claudeProcess.on('close', (code) => {
+            console.log(`\nClaude exited with code ${code}`);
+            this.stopStreaming();
+            this.flushOutput();
+            this.claudeProcess = null;
+            // Mark that we now have an active conversation for --continue on next message
+            if (code === 0) {
+                this.hasActiveConversation = true;
+            }
+        });
+        this.claudeProcess.on('error', (err) => {
+            console.error('Failed to start claude:', err.message);
+            this.stopStreaming();
+            if (this.currentChatId && this.currentTelegramId) {
+                this.sendResponse(this.currentChatId, `Error: Could not start Claude Code.\n\nPath: ${claudeBinary}\nError: ${err.message}`, 'complete');
+            }
+        });
+    }
+    /**
+     * Start streaming interval to send partial output
+     */
+    startStreaming() {
+        // Clear any existing interval
+        this.stopStreaming();
+        // Send updates every 500ms
+        this.streamingInterval = setInterval(() => {
+            this.flushPartialOutput();
+        }, 500);
+    }
+    /**
+     * Stop streaming interval
+     */
+    stopStreaming() {
+        if (this.streamingInterval) {
+            clearInterval(this.streamingInterval);
+            this.streamingInterval = null;
+        }
+    }
+    /**
+     * Flush partial output if buffer has grown since last flush
+     */
+    flushPartialOutput() {
+        if (!this.currentChatId || !this.currentTelegramId) {
+            return;
+        }
+        // Check if buffer has new content
+        if (this.outputBuffer.length <= this.lastFlushedLength) {
+            return;
+        }
+        // Update last flushed length
+        this.lastFlushedLength = this.outputBuffer.length;
+        // Clean the output
+        let cleaned = stripAnsi(this.outputBuffer);
+        // Truncate if too long for Telegram
+        if (cleaned.length > 4000) {
+            cleaned = '...\n' + cleaned.slice(-3900);
+        }
+        if (cleaned.trim().length > 0) {
+            this.sendStreaming(this.currentChatId, cleaned.trim());
+        }
+    }
+    /**
+     * Flush final buffered output to Telegram
+     */
+    flushOutput() {
+        if (!this.outputBuffer.trim() || !this.currentChatId || !this.currentTelegramId) {
+            this.outputBuffer = '';
+            return;
+        }
+        // Clean the output
+        let cleaned = stripAnsi(this.outputBuffer);
+        // Truncate if too long for Telegram
+        if (cleaned.length > 4000) {
+            cleaned = cleaned.slice(-4000) + '\n\n(output truncated)';
+        }
+        if (cleaned.trim().length > 0) {
+            this.sendResponse(this.currentChatId, cleaned.trim(), 'complete');
+        }
+        this.outputBuffer = '';
+        this.lastFlushedLength = 0;
+        this.currentMessageId = null;
+    }
+    /**
+     * Connect to VibeKit WebSocket server
+     */
+    connect() {
+        const wsUrl = this.config.getWsUrl();
+        const token = this.config.getToken();
+        if (!wsUrl || !token) {
+            console.error('No credentials found. Run "vibekit-agent link" first.');
+            process.exit(1);
+        }
+        console.log('Connecting to VibeKit...');
+        this.ws = new ws_1.default(wsUrl);
+        this.ws.on('open', () => {
+            console.log('Connected to VibeKit');
+            this.isConnected = true;
+            this.reconnectDelay = 1000;
+            // Authenticate
+            this.send({
+                type: 'auth',
+                payload: {
+                    token,
+                    agentVersion: '1.0.8',
+                    platform: os.platform(),
+                    workingDirectory: this.workingDirectory,
+                },
+                timestamp: Date.now(),
+                messageId: this.generateId(),
+            });
+        });
+        this.ws.on('message', (data) => {
+            try {
+                const message = JSON.parse(data.toString());
+                this.handleMessage(message);
+            }
+            catch (error) {
+                console.error('Error parsing message:', error);
+            }
+        });
+        this.ws.on('close', () => {
+            console.log('Disconnected from VibeKit');
+            this.isConnected = false;
+            this.scheduleReconnect();
+        });
+        this.ws.on('error', (error) => {
+            console.error('WebSocket error:', error.message);
+            this.isConnected = false;
+        });
+    }
+    /**
+     * Handle incoming WebSocket messages
+     */
+    handleMessage(message) {
+        switch (message.type) {
+            case 'auth_success':
+                console.log('Authenticated successfully');
+                console.log('');
+                console.log('Ready! Send messages to @the_vibe_kit_bot on Telegram.');
+                console.log('Press Ctrl+C to stop.');
+                console.log('');
+                this.sendStatus('idle');
+                break;
+            case 'auth_error':
+                console.error('Authentication failed:', message.payload.message);
+                this.config.clear();
+                process.exit(1);
+                break;
+            case 'message':
+                this.handleUserMessage(message);
+                break;
+            case 'ping':
+                this.send({ type: 'pong', timestamp: Date.now(), messageId: this.generateId() });
+                break;
+            case 'cd':
+                this.handleCdCommand(message.payload.path);
+                break;
+            case 'new_conversation':
+                this.handleNewConversation();
+                break;
+            case 'streaming_ack':
+                // Server acknowledged streaming message and sent back Telegram messageId
+                const ack = message.payload;
+                if (ack.messageId) {
+                    this.currentMessageId = ack.messageId;
+                }
+                break;
+            default:
+                // Ignore unknown messages
+                break;
+        }
+    }
+    /**
+     * Handle user message from Telegram
+     */
+    handleUserMessage(message) {
+        const { chatId, text, telegramId, messageId, attachments } = message.payload;
+        this.currentChatId = chatId;
+        this.currentTelegramId = telegramId;
+        this.currentReplyToMessageId = messageId;
+        let prompt = text || '';
+        const attachmentInfo = attachments?.length ? ` with ${attachments.length} attachment(s)` : '';
+        console.log(`\nReceived from Telegram: ${text || '(no text)'}${attachmentInfo}`);
+        // Process attachments if present
+        if (attachments && attachments.length > 0) {
+            const savedFiles = this.saveAttachments(attachments);
+            if (savedFiles.length > 0) {
+                // Build prompt with attachment references
+                for (const file of savedFiles) {
+                    if (file.type === 'voice') {
+                        // For voice, ask Claude to listen and respond
+                        prompt = `[Voice message saved to: ${file.path}]\n\nPlease listen to this voice message and respond to it.\n\n${prompt}`.trim();
+                    }
+                    else if (file.type === 'image') {
+                        // For images, ask Claude to analyze
+                        prompt = `[Image saved to: ${file.path}]\n\nPlease analyze this image.\n\n${prompt}`.trim();
+                    }
+                    else {
+                        // For documents, mention the file
+                        prompt = `[File saved to: ${file.path}]\n\n${prompt}`.trim();
+                    }
+                }
+            }
+        }
+        // Ensure we have something to process
+        if (!prompt.trim()) {
+            this.sendResponse(chatId, 'No message content received.', 'complete');
+            return;
+        }
+        this.sendStatus('busy');
+        // Send initial streaming status to trigger loading animation
+        this.sendResponse(chatId, '', 'streaming');
+        // Run claude with the prompt (streaming will send updates)
+        this.runClaude(prompt);
+    }
+    /**
+     * Save attachments to temp directory and return file paths
+     */
+    saveAttachments(attachments) {
+        const savedFiles = [];
+        // Create temp directory in working directory
+        const attachmentsDir = path.join(this.workingDirectory, '.vibekit-attachments');
+        if (!fs.existsSync(attachmentsDir)) {
+            fs.mkdirSync(attachmentsDir, { recursive: true });
+        }
+        for (const attachment of attachments) {
+            try {
+                // Decode base64 data
+                const buffer = Buffer.from(attachment.data, 'base64');
+                // Generate unique filename
+                const timestamp = Date.now();
+                const filename = `${timestamp}-${attachment.filename}`;
+                const filePath = path.join(attachmentsDir, filename);
+                // Write file
+                fs.writeFileSync(filePath, buffer);
+                console.log(`Saved ${attachment.type}: ${filePath}`);
+                savedFiles.push({
+                    type: attachment.type,
+                    path: filePath,
+                });
+            }
+            catch (error) {
+                console.error(`Failed to save attachment ${attachment.filename}:`, error);
+            }
+        }
+        return savedFiles;
+    }
+    /**
+     * Handle new conversation command - reset conversation memory
+     */
+    handleNewConversation() {
+        this.hasActiveConversation = false;
+        console.log('Conversation reset - next message will start fresh');
+    }
+    /**
+     * Handle change directory command
+     */
+    handleCdCommand(newPath) {
+        const resolved = path.resolve(this.workingDirectory, newPath);
+        try {
+            const fs = require('fs');
+            if (!fs.existsSync(resolved) || !fs.statSync(resolved).isDirectory()) {
+                this.send({
+                    type: 'cd_result',
+                    payload: { success: false, error: 'Directory not found' },
+                    timestamp: Date.now(),
+                    messageId: this.generateId(),
+                });
+                return;
+            }
+            this.workingDirectory = resolved;
+            this.config.setLastDirectory(resolved);
+            this.send({
+                type: 'cd_result',
+                payload: { success: true, path: resolved },
+                timestamp: Date.now(),
+                messageId: this.generateId(),
+            });
+            console.log(`Changed directory to: ${resolved}`);
+        }
+        catch (error) {
+            this.send({
+                type: 'cd_result',
+                payload: { success: false, error: 'Failed to change directory' },
+                timestamp: Date.now(),
+                messageId: this.generateId(),
+            });
+        }
+    }
+    /**
+     * Send streaming update to Telegram
+     */
+    sendStreaming(chatId, text) {
+        this.send({
+            type: 'streaming',
+            payload: {
+                chatId,
+                messageId: this.currentMessageId,
+                text,
+                workingDirectory: this.workingDirectory,
+            },
+            timestamp: Date.now(),
+            messageId: this.generateId(),
+        });
+    }
+    /**
+     * Send a response back to Telegram
+     */
+    sendResponse(chatId, text, status) {
+        if (!this.currentTelegramId) {
+            console.error('Cannot send response: no telegram ID');
+            return;
+        }
+        this.send({
+            type: 'response',
+            payload: {
+                telegramId: this.currentTelegramId,
+                chatId,
+                text,
+                status,
+                replyToMessageId: this.currentReplyToMessageId || undefined,
+            },
+            timestamp: Date.now(),
+            messageId: this.generateId(),
+        });
+        if (status === 'complete') {
+            this.sendStatus('idle');
+        }
+    }
+    /**
+     * Send status update
+     */
+    sendStatus(status) {
+        this.send({
+            type: 'status',
+            payload: { status, workingDirectory: this.workingDirectory },
+            timestamp: Date.now(),
+            messageId: this.generateId(),
+        });
+    }
+    /**
+     * Send a message to the WebSocket
+     */
+    send(message) {
+        if (this.ws?.readyState === ws_1.default.OPEN) {
+            this.ws.send(JSON.stringify(message));
+        }
+    }
+    /**
+     * Schedule reconnection
+     */
+    scheduleReconnect() {
+        if (this.reconnectTimeout)
+            return;
+        console.log(`Reconnecting in ${this.reconnectDelay / 1000}s...`);
+        this.reconnectTimeout = setTimeout(() => {
+            this.reconnectTimeout = null;
+            this.reconnectDelay = Math.min(this.reconnectDelay * 2, 30000);
+            this.connect();
+        }, this.reconnectDelay);
+    }
+    /**
+     * Generate a unique message ID
+     */
+    generateId() {
+        return `${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+    }
+    /**
+     * Shutdown the agent
+     */
+    shutdown() {
+        console.log('\nShutting down...');
+        this.stopStreaming();
+        if (this.claudeProcess) {
+            this.claudeProcess.kill();
+        }
+        if (this.ws) {
+            this.ws.close();
+        }
+        process.exit(0);
+    }
+    /**
+     * Set up Claude credentials for auto mode
+     * In auto mode, credentials come from CLAUDE_OAUTH_JSON env var or credentials file
+     */
+    async setupAutoModeCredentials() {
+        const credentialsFile = this.config.getCredentialsFile();
+        const oauthJson = process.env.CLAUDE_OAUTH_JSON;
+        // Determine where to get credentials from
+        let credentialsData = null;
+        if (credentialsFile && fs.existsSync(credentialsFile)) {
+            // Read from file
+            console.log(`[AutoMode] Loading credentials from ${credentialsFile}`);
+            credentialsData = fs.readFileSync(credentialsFile, 'utf-8');
+        }
+        else if (oauthJson) {
+            // Decode from environment variable (base64)
+            console.log('[AutoMode] Loading credentials from CLAUDE_OAUTH_JSON env var');
+            credentialsData = Buffer.from(oauthJson, 'base64').toString('utf-8');
+        }
+        if (!credentialsData) {
+            console.error('[AutoMode] No credentials found. Set CLAUDE_OAUTH_JSON or --credentials-file');
+            process.exit(1);
+        }
+        // Write credentials to Claude's expected location
+        const homeDir = process.env.HOME || '/home/agent';
+        const claudeDir = path.join(homeDir, '.claude');
+        if (!fs.existsSync(claudeDir)) {
+            fs.mkdirSync(claudeDir, { recursive: true });
+        }
+        // Write credentials
+        const credentialsPath = path.join(claudeDir, 'credentials.json');
+        fs.writeFileSync(credentialsPath, credentialsData, { mode: 0o600 });
+        // Also write settings to indicate onboarding is complete
+        const settingsPath = path.join(claudeDir, 'settings.json');
+        if (!fs.existsSync(settingsPath)) {
+            const settings = {
+                hasCompletedOnboarding: true,
+                acceptedTerms: true,
+                permissions: { defaultMode: 'acceptEdits' }
+            };
+            fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2), { mode: 0o600 });
+        }
+        console.log('[AutoMode] Claude credentials configured');
+    }
+}
+exports.AgentClient = AgentClient;
+//# sourceMappingURL=agent.js.map