gemkit-cli 0.2.3 → 0.3.0

package/dist/services/pty-server.js

@@ -0,0 +1,613 @@
+/**
+ * PTY Server - Maintains AI session and accepts commands via TCP
+ * Ported from claude-pty-wrapper/server.js
+ */
+import net from 'net';
+import crypto from 'crypto';
+import { AIPTY } from './aipty.js';
+const DEFAULT_PORT = 3377;
+const DEFAULT_HOST = '127.0.0.1';
+const STABILITY_THRESHOLD_MS = 2000;
+export class PtyServer {
+    options;
+    ai = null;
+    server = null;
+    outputHistory = '';
+    lastPromptIndex = 0;
+    lastSentPrompt = '';
+    lastDataReceivedTime = 0;
+    currentExchangeId = null;
+    exchangeHistory = [];
+    streamClients = [];
+    port;
+    debug;
+    pid = 0;
+    constructor(options) {
+        this.options = options;
+        this.port = options.port || DEFAULT_PORT;
+        this.debug = options.debug || false;
+    }
+    /**
+     * Start the server
+     */
+    async start() {
+        const { provider, model, tools, sessionState } = this.options;
+        if (this.debug) {
+            console.log(`[Server] Starting ${provider} with model: ${model}`);
+        }
+        this.ai = new AIPTY({
+            provider,
+            model,
+            tools,
+            debug: this.debug
+        });
+        this.ai.on('data', (data) => {
+            this.outputHistory += data;
+            this.lastDataReceivedTime = Date.now();
+            // Emit events to stream clients
+            if (this.streamClients.length > 0) {
+                const events = this.parseOutputForEvents(data);
+                for (const event of events) {
+                    this.emitStreamEvent(event);
+                }
+            }
+        });
+        this.ai.on('ready', () => {
+            if (this.debug) {
+                console.log(`[Server] ${provider} is ready`);
+            }
+        });
+        this.ai.on('exit', (code) => {
+            if (this.debug) {
+                console.log(`[Server] ${provider} exited with code: ${code}`);
+            }
+            this.ai = null;
+        });
+        await this.ai.start();
+        // Start TCP server
+        await this.startTcpServer();
+    }
+    /**
+     * Start TCP server for client commands
+     */
+    startTcpServer() {
+        return new Promise((resolve, reject) => {
+            this.server = net.createServer((socket) => {
+                let isStreamMode = false;
+                socket.on('data', (data) => {
+                    const message = data.toString().trim();
+                    const [cmd, ...argParts] = message.split(' ');
+                    const args = argParts.join(' ');
+                    const response = this.handleCommand(cmd, args);
+                    // Handle stream mode
+                    if (response === '__STREAM_MODE__') {
+                        isStreamMode = true;
+                        this.streamClients.push(socket);
+                        socket.write(JSON.stringify({ type: 'stream_started' }) + '\n');
+                        return;
+                    }
+                    socket.write(response + '\n');
+                });
+                socket.on('error', () => {
+                    // Client disconnected, ignore
+                });
+                socket.on('close', () => {
+                    if (isStreamMode) {
+                        this.streamClients = this.streamClients.filter(c => c !== socket);
+                    }
+                });
+            });
+            this.server.listen(this.port, DEFAULT_HOST, () => {
+                if (this.debug) {
+                    console.log(`[Server] Listening on ${DEFAULT_HOST}:${this.port}`);
+                }
+                resolve();
+            });
+            this.server.on('error', (err) => {
+                if (err.code === 'EADDRINUSE') {
+                    reject(new Error(`Port ${this.port} is already in use`));
+                }
+                else {
+                    reject(err);
+                }
+            });
+        });
+    }
+    /**
+     * Handle client command
+     */
+    handleCommand(cmd, args) {
+        switch (cmd) {
+            case 'status':
+                return JSON.stringify(this.getStatus());
+            case 'send':
+                return this.handleSend(args);
+            case 'read':
+                const lines = parseInt(args) || 200;
+                const allLines = this.outputHistory.split('\n');
+                return allLines.slice(-lines).join('\n');
+            case 'extract':
+                return this.extractAnswer();
+            case 'exchange':
+                return JSON.stringify(this.getStructuredExchange());
+            case 'pending':
+                return JSON.stringify(this.detectPendingTools());
+            case 'complete':
+                return JSON.stringify(this.isComplete());
+            case 'history':
+                if (args === 'clear') {
+                    this.exchangeHistory = [];
+                    return JSON.stringify({ ok: true, message: 'History cleared' });
+                }
+                return JSON.stringify({
+                    provider: this.options.provider,
+                    count: this.exchangeHistory.length,
+                    exchanges: this.exchangeHistory
+                });
+            case 'stop':
+                if (this.ai) {
+                    this.ai.stop().then(() => {
+                        process.exit(0);
+                    });
+                    return JSON.stringify({ ok: true, message: 'Stopping...' });
+                }
+                return JSON.stringify({ error: 'Not running' });
+            case 'stream':
+                return '__STREAM_MODE__';
+            default:
+                return JSON.stringify({ error: 'Unknown command: ' + cmd });
+        }
+    }
+    /**
+     * Handle send command
+     */
+    handleSend(prompt) {
+        if (!this.ai || !this.ai.getIsReady()) {
+            return JSON.stringify({ error: 'Not ready' });
+        }
+        this.lastPromptIndex = this.outputHistory.length;
+        // Only update lastSentPrompt for actual prompts, not tool confirmations
+        const isToolConfirmation = /^[123yn]$/i.test(prompt.trim());
+        if (!isToolConfirmation) {
+            this.lastSentPrompt = prompt;
+            this.currentExchangeId = crypto.randomUUID();
+        }
+        this.lastDataReceivedTime = Date.now();
+        this.ai.write(prompt);
+        setTimeout(() => this.ai?.write('\r'), 300);
+        return JSON.stringify({ ok: true, exchangeId: this.currentExchangeId });
+    }
+    /**
+     * Get server status
+     */
+    getStatus() {
+        return {
+            running: this.ai !== null,
+            ready: this.ai?.getIsReady() || false,
+            provider: this.options.provider,
+            outputLength: this.outputHistory.length
+        };
+    }
+    /**
+     * Clean ANSI codes from output
+     */
+    cleanAnsi(output) {
+        return output
+            .replace(/\x1b\[\?[0-9;]*[a-z]/gi, '')
+            .replace(/\x1b\[1C/g, ' ')
+            .replace(/\x1b\[[0-9;]*[A-Za-z]/g, '')
+            .replace(/\x1b\][^\x07]*\x07/g, '')
+            .replace(/\r/g, '');
+    }
+    /**
+     * Extract answer based on provider
+     */
+    extractAnswer() {
+        if (this.options.provider === 'gemini') {
+            return this.extractAnswerGemini();
+        }
+        return this.extractAnswerClaude();
+    }
+    /**
+     * Extract answer from Claude output
+     */
+    extractAnswerClaude() {
+        const cleanOutput = this.cleanAnsi(this.outputHistory);
+        const matches = cleanOutput.match(/●\s*([\s\S]*?)(?=❯|$)/g);
+        if (matches && matches.length > 0) {
+            let lastMatch = matches[matches.length - 1];
+            lastMatch = lastMatch
+                .replace(/^●\s*/, '')
+                .replace(/[─╭╰│┌┐└┘├┤┬┴┼⎿⎾]+/g, '')
+                .replace(/\? for shortcuts/g, '')
+                .replace(/esc to interrupt/g, '')
+                .replace(/\w+ing…/g, '')
+                .replace(/\(thinking\)/g, '')
+                .replace(/·\s*/g, '')
+                .replace(/[✢✶✻✽*]/g, '')
+                .replace(/Tip:\s*Use\s+\/\w+[^.]*\./gi, '')
+                .trim();
+            const lines = lastMatch.split('\n')
+                .map(l => l.trim())
+                .filter(l => {
+                if (l.length === 0)
+                    return false;
+                if (l.match(/^[\s─╭╰│┌┐└┘├┤┬┴┼⎿⎾✢✶✻✽·*]+$/))
+                    return false;
+                if (l.match(/thinking|thought for/i))
+                    return false;
+                if (l.match(/^\d+s\)$/))
+                    return false;
+                if (l.match(/^IDE disconnected$/))
+                    return false;
+                if (l.match(/^Tip:\s*Use\s+\/\w+/i))
+                    return false;
+                return true;
+            });
+            return lines.join('\n').trim();
+        }
+        return '';
+    }
+    /**
+     * Extract answer from Gemini output
+     */
+    extractAnswerGemini() {
+        let clean = this.cleanAnsi(this.outputHistory);
+        // Find the LAST occurrence of the user's prompt
+        const promptPattern = `> ${this.lastSentPrompt}`;
+        const promptIdx = clean.lastIndexOf(promptPattern);
+        if (promptIdx === -1) {
+            return '';
+        }
+        // Get content after the prompt
+        let afterPrompt = clean.slice(promptIdx + promptPattern.length);
+        // Find the next user prompt indicator to stop
+        const nextPromptMatch = afterPrompt.match(/\n\s*>\s+(?!Type your message)[^\n]{10,}/);
+        if (nextPromptMatch) {
+            afterPrompt = afterPrompt.slice(0, nextPromptMatch.index);
+        }
+        // Extract content after ✦ markers (AI responses)
+        const answerParts = [];
+        const aiMatches = afterPrompt.split('✦');
+        for (let i = 1; i < aiMatches.length; i++) {
+            let part = aiMatches[i];
+            // Stop at tool markers
+            const toolMatch = part.match(/[✓⊶⊷x?]\s*(?:Shell|WriteFile|ReadFile|ReadFolder|GoogleSearch|Activate Skill)/i);
+            if (toolMatch) {
+                part = part.slice(0, toolMatch.index);
+            }
+            // Stop at spinner/status messages
+            const spinnerMatch = part.match(/[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]|\(esc to cancel/);
+            if (spinnerMatch) {
+                part = part.slice(0, spinnerMatch.index);
+            }
+            // Stop at file preview box
+            const fileBoxMatch = part.match(/╭─|│\s*\d+\s*│|│\s*\d+\s+[*#\-\w]/);
+            if (fileBoxMatch) {
+                part = part.slice(0, fileBoxMatch.index);
+            }
+            if (part.trim()) {
+                answerParts.push(part);
+            }
+        }
+        let answer = answerParts.join('\n\n').trim();
+        // Remove UI artifacts
+        answer = answer
+            .replace(/[█▀▄░▓▒│┃╭╮╯╰┌┐└┘├┤┬┴┼─━╱╲]+/g, '')
+            .replace(/[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]/g, '')
+            .replace(/\d+s\)/g, '')
+            .replace(/\(esc to cancel[^)]*\)/g, '')
+            .replace(/Action Required[^\n]*/gi, '')
+            .replace(/Waiting for user confirmation[^\n]*/gi, '')
+            .replace(/\d+\.\s*Allow[^\n]*/gi, '')
+            .replace(/>\s+[^\n]+/g, '')
+            .replace(/Type your message[^\n]*/gi, '');
+        // Remove duplicate lines
+        const lines = answer.split('\n');
+        const uniqueLines = [];
+        const seenLines = new Set();
+        for (const line of lines) {
+            const normalized = line.trim();
+            if (normalized.length === 0) {
+                if (uniqueLines.length === 0 || uniqueLines[uniqueLines.length - 1].trim() !== '') {
+                    uniqueLines.push(line);
+                }
+            }
+            else if (!seenLines.has(normalized)) {
+                seenLines.add(normalized);
+                uniqueLines.push(line);
+            }
+        }
+        return uniqueLines.join('\n').trim();
+    }
+    /**
+     * Detect pending tool confirmations
+     */
+    detectPendingTools() {
+        const cleanOutput = this.cleanAnsi(this.outputHistory);
+        const recentOutput = cleanOutput.slice(-8000);
+        const pending = [];
+        // Check for waiting confirmation indicators
+        const isWaiting = recentOutput.includes('Waiting for user confirmation') ||
+            recentOutput.includes('Action Required') ||
+            recentOutput.includes('Allow once') ||
+            recentOutput.includes('Allow for this session') ||
+            recentOutput.match(/●\s*1\.\s*Allow/) ||
+            recentOutput.match(/Apply this change\?/i);
+        if (this.options.provider === 'gemini') {
+            const pendingPatterns = [
+                { regex: /\?\s*Shell\s+([^\n│\[]+)/gi, type: 'shell', field: 'command' },
+                { regex: /\?\s*WriteFile\s+(?:Writing to\s+)?([^\n│]+)/gi, type: 'write_file', field: 'path' },
+                { regex: /\?\s*ReadFile\s+(?:Reading\s+)?([^\n│]+)/gi, type: 'read_file', field: 'path' },
+                { regex: /\?\s*ReadFolder\s+([^\n│]+)/gi, type: 'read_folder', field: 'path' },
+            ];
+            const seen = new Set();
+            for (const { regex, type, field } of pendingPatterns) {
+                const matches = recentOutput.matchAll(regex);
+                for (const match of matches) {
+                    const detail = this.cleanToolDetail(match[1]);
+                    const key = `${type}:${detail.slice(0, 30)}`;
+                    if (detail && !seen.has(key) && isWaiting) {
+                        seen.add(key);
+                        const tool = {
+                            type,
+                            [field]: detail,
+                            waiting: true,
+                            options: ['1. Allow once', '2. Allow for this session', '3. No, suggest changes']
+                        };
+                        pending.push(tool);
+                    }
+                }
+            }
+            // Check for "Apply this change?" pattern
+            if (recentOutput.match(/Apply this change\?/i) && isWaiting) {
+                pending.push({
+                    type: 'apply_change',
+                    waiting: true,
+                    options: ['1. Allow once', '2. Allow for this session', '3. No, suggest changes']
+                });
+            }
+            // Action Required indicator
+            const actionMatch = recentOutput.match(/Action Required\s*(\d+)\s*of\s*(\d+)/i);
+            if (actionMatch) {
+                pending.forEach(p => {
+                    p.actionRequired = { current: parseInt(actionMatch[1]), total: parseInt(actionMatch[2]) };
+                });
+            }
+        }
+        // Claude tool confirmation patterns
+        if (this.options.provider === 'claude') {
+            const runMatch = recentOutput.match(/Run\s+(.+?)\s*\?/i);
+            if (runMatch && isWaiting) {
+                pending.push({ type: 'shell', command: runMatch[1].trim(), waiting: true });
+            }
+            const writeMatch = recentOutput.match(/Write to\s+(.+?)\s*\?/i);
+            if (writeMatch && isWaiting) {
+                pending.push({ type: 'write_file', path: writeMatch[1].trim(), waiting: true });
+            }
+            const editMatch = recentOutput.match(/Edit\s+(.+?)\s*\?/i);
+            if (editMatch && isWaiting) {
+                pending.push({ type: 'edit_file', path: editMatch[1].trim(), waiting: true });
+            }
+        }
+        return {
+            hasPending: pending.length > 0 && !!isWaiting,
+            tools: pending,
+            hint: isWaiting ? 'Send "1" to allow once, "2" for session, "3" to suggest changes' : undefined
+        };
+    }
+    /**
+     * Clean tool detail string
+     */
+    cleanToolDetail(detail) {
+        return detail
+            .replace(/[│┃╭╮╯╰┌┐└┘├┤┬┴┼█▀▄░▓▒]+/g, '')
+            .replace(/[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]/g, '')
+            .replace(/\(esc to cancel[^)]*\)/g, '')
+            .replace(/\d+s\)/g, '')
+            .replace(/…\s*$/, '')
+            .replace(/\s+/g, ' ')
+            .trim();
+    }
+    /**
+     * Extract tool results from output
+     */
+    extractToolResults() {
+        const results = [];
+        const seen = new Set();
+        if (this.options.provider === 'gemini') {
+            const clean = this.cleanAnsi(this.outputHistory);
+            const promptPattern = `> ${this.lastSentPrompt}`;
+            const promptIdx = clean.lastIndexOf(promptPattern);
+            const searchArea = promptIdx !== -1 ? clean.slice(promptIdx) : clean.slice(-30000);
+            const completedPatterns = [
+                { regex: /✓\s*Shell\s+([^\n│]+)/gi, type: 'shell', status: 'completed' },
+                { regex: /✓\s*WriteFile\s+(?:Writing to\s+)?([^\n│]+)/gi, type: 'write_file', status: 'completed' },
+                { regex: /✓\s*ReadFile\s+(?:Reading\s+)?([^\n│]+)/gi, type: 'read_file', status: 'completed' },
+                { regex: /✓\s*ReadFolder\s+([^\n│]+)/gi, type: 'read_folder', status: 'completed' },
+                { regex: /✓\s*GoogleSearch\s+([^\n│]+)/gi, type: 'web_search', status: 'completed' },
+                { regex: /x\s*Shell\s+([^\n│]+)/gi, type: 'shell', status: 'failed' },
+                { regex: /x\s*WriteFile\s+([^\n│]+)/gi, type: 'write_file', status: 'failed' },
+            ];
+            for (const { regex, type, status } of completedPatterns) {
+                const matches = searchArea.matchAll(regex);
+                for (const match of matches) {
+                    const detail = this.cleanToolDetail(match[1]);
+                    const key = `${type}:${detail.slice(0, 50)}`;
+                    if (detail && !seen.has(key)) {
+                        seen.add(key);
+                        results.push({ type, detail, status });
+                    }
+                }
+            }
+        }
+        if (this.options.provider === 'claude') {
+            const cleanOutput = this.cleanAnsi(this.outputHistory);
+            const toolMatches = cleanOutput.matchAll(/Ran\s+(\w+):\s*([^\n]+)/g);
+            for (const match of toolMatches) {
+                const key = `${match[1]}:${match[2].slice(0, 50)}`;
+                if (!seen.has(key)) {
+                    seen.add(key);
+                    results.push({ type: match[1], detail: match[2].trim(), status: 'completed' });
+                }
+            }
+        }
+        return results;
+    }
+    /**
+     * Get structured exchange data
+     */
+    getStructuredExchange() {
+        const answer = this.extractAnswer();
+        const pending = this.detectPendingTools();
+        const toolResults = this.extractToolResults();
+        if (!this.currentExchangeId) {
+            this.currentExchangeId = crypto.randomUUID();
+        }
+        const exchange = {
+            id: this.currentExchangeId,
+            timestamp: new Date().toISOString(),
+            prompt: this.lastSentPrompt,
+            answer,
+            pending: pending.hasPending ? pending.tools : [],
+            toolResults,
+            status: pending.hasPending ? 'waiting_confirmation' : 'complete'
+        };
+        // Save to history when complete
+        if (exchange.status === 'complete' && answer.trim()) {
+            const existingIdx = this.exchangeHistory.findIndex(e => e.id === this.currentExchangeId);
+            if (existingIdx >= 0) {
+                this.exchangeHistory[existingIdx] = exchange;
+            }
+            else {
+                this.exchangeHistory.push(exchange);
+            }
+            this.currentExchangeId = null;
+        }
+        return exchange;
+    }
+    /**
+     * Check if response is complete
+     */
+    isComplete() {
+        const recentOutput = this.outputHistory.slice(this.lastPromptIndex);
+        const cleanOutput = this.cleanAnsi(recentOutput);
+        if (this.options.provider === 'claude') {
+            const hasResponse = cleanOutput.includes('●');
+            const lastResponseIdx = cleanOutput.lastIndexOf('●');
+            const lastPromptIdx = cleanOutput.lastIndexOf('❯');
+            if (hasResponse && lastPromptIdx > lastResponseIdx) {
+                return { complete: true };
+            }
+            return { complete: false, reason: 'streaming' };
+        }
+        else if (this.options.provider === 'gemini') {
+            const hasResponse = cleanOutput.includes('✦');
+            if (!hasResponse) {
+                return { complete: false, reason: 'no_response' };
+            }
+            // Check for pending tool confirmations
+            const tail = cleanOutput.slice(-3000);
+            const hasPendingText = tail.includes('Waiting for user confirmation') ||
+                tail.includes('Action Required') ||
+                (tail.includes('Allow once') && tail.includes('Allow for this session'));
+            const hasPendingMarker = /\?\s*(Shell|WriteFile|ReadFile|ReadFolder)/i.test(tail);
+            if (hasPendingText || hasPendingMarker) {
+                return {
+                    complete: false,
+                    reason: 'pending_tool',
+                    hint: 'Tool confirmation required. Use "gk agent send 1" to approve.'
+                };
+            }
+            // Check stability
+            const now = Date.now();
+            const timeSinceLastData = now - this.lastDataReceivedTime;
+            if (timeSinceLastData < STABILITY_THRESHOLD_MS) {
+                return { complete: false, reason: 'streaming' };
+            }
+            const lastStarIdx = cleanOutput.lastIndexOf('✦');
+            const contentAfterStar = cleanOutput.slice(lastStarIdx + 1);
+            const hasContent = contentAfterStar.trim().length > 50;
+            if (hasContent) {
+                return { complete: true };
+            }
+            return { complete: false, reason: 'waiting_content' };
+        }
+        return { complete: false, reason: 'unknown' };
+    }
+    /**
+     * Parse output for stream events
+     */
+    parseOutputForEvents(rawData) {
+        const cleanData = this.cleanAnsi(rawData);
+        const events = [];
+        // Tool confirmation request
+        if (cleanData.match(/\?\s*(Shell|WriteFile|ReadFile|ReadFolder)/i)) {
+            const match = cleanData.match(/\?\s*(Shell|WriteFile|ReadFile|ReadFolder)\s+([^\n\[]+)/i);
+            events.push({
+                type: 'tool_confirmation_required',
+                tool: match ? match[1] : 'unknown',
+                detail: match ? match[2].trim() : null
+            });
+        }
+        // Tool completion
+        const completionMatch = cleanData.match(/✓\s*(Shell|WriteFile|ReadFile|ReadFolder|GoogleSearch)\s+([^\n]+)/i);
+        if (completionMatch) {
+            events.push({
+                type: 'tool_completed',
+                tool: completionMatch[1],
+                detail: completionMatch[2].trim()
+            });
+        }
+        // Response marker
+        if (cleanData.includes('✦') || cleanData.includes('●')) {
+            events.push({ type: 'response_chunk' });
+        }
+        // Prompt ready
+        if (cleanData.match(/[❯>]\s*$/) || cleanData.includes('Type your message')) {
+            events.push({ type: 'prompt_ready' });
+        }
+        return events;
+    }
+    /**
+     * Emit event to stream clients
+     */
+    emitStreamEvent(event) {
+        const data = JSON.stringify(event) + '\n';
+        for (const client of this.streamClients) {
+            try {
+                client.write(data);
+            }
+            catch {
+                // Remove dead clients
+            }
+        }
+        this.streamClients = this.streamClients.filter(c => !c.destroyed);
+    }
+    /**
+     * Stop the server
+     */
+    async stop() {
+        if (this.server) {
+            this.server.close();
+        }
+        if (this.ai) {
+            await this.ai.stop();
+        }
+    }
+}
+/**
+ * Start server as standalone process
+ */
+export async function startPtyServerProcess(options) {
+    const server = new PtyServer(options);
+    await server.start();
+    process.on('SIGINT', async () => {
+        await server.stop();
+        process.exit(0);
+    });
+    process.on('SIGTERM', async () => {
+        await server.stop();
+        process.exit(0);
+    });
+}