dev/cli-proxy/pty-proxy.js

#!/usr/bin/env node
/**
 * Claude CLI PTY Proxy
 *
 * Uses PTY to interact with Claude CLI in interactive mode,
 * which uses your Claude subscription instead of API credits.
 */

const http = require('http');
const pty = require('node-pty');

const PORT = parseInt(process.env.PORT || '9999');

// Track active PTY sessions
const sessions = new Map();

/**
 * Send a message to Claude via PTY and get response
 */
function sendToClaude(prompt) {
    return new Promise((resolve, reject) => {
        const timeout = 120000; // 2 minutes
        let output = '';
        let responseStarted = false;
        let lastDataTime = Date.now();

        // Spawn Claude in interactive mode
        const proc = pty.spawn('claude', ['--dangerously-skip-permissions'], {
            name: 'xterm-256color',
            cols: 120,
            rows: 40,
            cwd: process.cwd(),
            env: {
                ...process.env,
                TERM: 'xterm-256color',
                NO_COLOR: '1',  // Disable colors for easier parsing
            }
        });

        const timeoutId = setTimeout(() => {
            proc.kill();
            reject(new Error('Timeout waiting for Claude response'));
        }, timeout);

        // Detect when Claude is ready for input
        let ready = false;
        let sentPrompt = false;

        proc.onData((data) => {
            lastDataTime = Date.now();
            output += data;

            // Debug logging
            if (process.env.DEBUG) {
                console.log('[PTY DATA]:', JSON.stringify(data.substring(0, 100)));
            }

            // Detect ready state (Claude shows prompt)
            if (!ready && (output.includes('>') || output.includes('Claude'))) {
                ready = true;
            }

            // Send prompt once ready
            if (ready && !sentPrompt) {
                sentPrompt = true;
                setTimeout(() => {
                    proc.write(prompt + '\n');
                }, 500);
            }

            // Detect response completion (new prompt appears after response)
            if (sentPrompt && output.split(prompt).length > 1) {
                // Look for completion indicators
                const afterPrompt = output.split(prompt).pop();
                if (afterPrompt && afterPrompt.includes('>')) {
                    // Response complete
                    clearTimeout(timeoutId);
                    proc.kill();

                    // Extract response between prompt and next >
                    const response = extractResponse(output, prompt);
                    resolve(response);
                }
            }
        });

        proc.onExit(({ exitCode }) => {
            clearTimeout(timeoutId);
            if (exitCode !== 0 && !output) {
                reject(new Error(`Claude exited with code ${exitCode}`));
            } else {
                const response = extractResponse(output, prompt);
                resolve(response || 'No response received');
            }
        });
    });
}

/**
 * Extract Claude's response from PTY output
 */
function extractResponse(output, prompt) {
    // Remove ANSI escape codes
    const clean = output.replace(/\x1B\[[0-9;]*[a-zA-Z]/g, '')
                        .replace(/\x1B\][^\x07]*\x07/g, '')
                        .replace(/[\x00-\x1F]/g, ' ');

    // Find the response after the prompt
    const promptIndex = clean.indexOf(prompt);
    if (promptIndex === -1) return clean.trim();

    let response = clean.substring(promptIndex + prompt.length);

    // Remove trailing prompt indicator
    response = response.replace(/>\s*$/, '').trim();

    // Remove any leading/trailing whitespace and common artifacts
    response = response.split('\n')
        .filter(line => line.trim() && !line.includes('Claude') && !line.startsWith('>'))
        .join('\n')
        .trim();

    return response || 'Response received';
}

/**
 * Build prompt from messages
 */
function buildPrompt(messages) {
    const lastUserMsg = messages.filter(m => m.role === 'user').pop();
    return lastUserMsg?.content || messages[messages.length - 1]?.content || '';
}

/**
 * HTTP request handler
 */
async function handleRequest(req, res) {
    const url = new URL(req.url, `http://localhost:${PORT}`);

    res.setHeader('Access-Control-Allow-Origin', '*');
    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
    res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');

    if (req.method === 'OPTIONS') {
        res.writeHead(200);
        res.end();
        return;
    }

    if (url.pathname === '/health' || url.pathname === '/') {
        res.writeHead(200, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({ status: 'ok', mode: 'pty-interactive' }));
        return;
    }

    if (url.pathname === '/v1/chat/completions' && req.method === 'POST') {
        let body = '';
        req.on('data', chunk => { body += chunk.toString(); });
        req.on('end', async () => {
            try {
                const request = JSON.parse(body);
                const prompt = buildPrompt(request.messages || []);

                console.log(`[${new Date().toISOString()}] PTY Request: ${prompt.substring(0, 50)}...`);

                const response = await sendToClaude(prompt);

                console.log(`[${new Date().toISOString()}] PTY Response: ${response.substring(0, 100)}...`);

                res.writeHead(200, { 'Content-Type': 'application/json' });
                res.end(JSON.stringify({
                    id: `chatcmpl-${Date.now()}`,
                    object: 'chat.completion',
                    created: Math.floor(Date.now() / 1000),
                    model: request.model || 'claude-interactive',
                    choices: [{
                        index: 0,
                        message: { role: 'assistant', content: response },
                        finish_reason: 'stop'
                    }],
                    usage: {
                        prompt_tokens: Math.ceil(prompt.length / 4),
                        completion_tokens: Math.ceil(response.length / 4),
                        total_tokens: Math.ceil((prompt.length + response.length) / 4)
                    }
                }));
            } catch (error) {
                console.error(`[${new Date().toISOString()}] Error:`, error.message);
                res.writeHead(500, { 'Content-Type': 'application/json' });
                res.end(JSON.stringify({
                    error: { message: error.message, type: 'server_error' }
                }));
            }
        });
        return;
    }

    res.writeHead(404, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify({ error: { message: 'Not found' } }));
}

const server = http.createServer(handleRequest);

server.listen(PORT, () => {
    console.log(`
╔══════════════════════════════════════════════════════════════╗
║       Claude CLI PTY Proxy (Interactive Mode)                ║
╠══════════════════════════════════════════════════════════════╣
║  Listening: http://localhost:${PORT}                            ║
║  Mode:      PTY Interactive (uses subscription, not API)     ║
╠══════════════════════════════════════════════════════════════╣
║  This proxy spawns Claude CLI in interactive mode via PTY,   ║
║  which uses your Claude subscription instead of API credits. ║
╚══════════════════════════════════════════════════════════════╝
`);
});

process.on('SIGINT', () => {
    console.log('\nShutting down...');
    server.close(() => process.exit(0));
});