gemkit-cli 0.2.3 → 0.3.1

package/dist/services/pty-client.js

@@ -0,0 +1,154 @@
+/**
+ * PTY Client - Sends commands to the PTY server
+ * Ported from claude-pty-wrapper/client.js
+ */
+import net from 'net';
+const DEFAULT_PORT = 3377;
+const DEFAULT_HOST = '127.0.0.1';
+export class PtyClient {
+    port;
+    host;
+    constructor(port = DEFAULT_PORT, host = DEFAULT_HOST) {
+        this.port = port;
+        this.host = host;
+    }
+    /**
+     * Send command to server and get response
+     */
+    sendCommand(command) {
+        return new Promise((resolve, reject) => {
+            const client = new net.Socket();
+            let response = '';
+            client.setTimeout(10000);
+            client.connect(this.port, this.host, () => {
+                client.write(command + '\n');
+            });
+            client.on('data', (data) => {
+                response += data.toString();
+                client.destroy();
+            });
+            client.on('close', () => {
+                resolve(response.trim());
+            });
+            client.on('error', (err) => {
+                if (err.code === 'ECONNREFUSED') {
+                    reject(new Error('No server running. Use "gk agent start" first.'));
+                }
+                else {
+                    reject(err);
+                }
+            });
+            client.on('timeout', () => {
+                client.destroy();
+                reject(new Error('Connection timeout'));
+            });
+        });
+    }
+    /**
+     * Check if server is running
+     */
+    async isServerRunning() {
+        try {
+            await this.sendCommand('status');
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Get server status
+     */
+    async status() {
+        const response = await this.sendCommand('status');
+        return JSON.parse(response);
+    }
+    /**
+     * Send prompt to session
+     */
+    async send(prompt) {
+        const response = await this.sendCommand('send ' + prompt);
+        return JSON.parse(response);
+    }
+    /**
+     * Wait for completion
+     */
+    async waitForCompletion(timeout = 120) {
+        const startTime = Date.now();
+        const timeoutMs = timeout * 1000;
+        while (Date.now() - startTime < timeoutMs) {
+            try {
+                const result = await this.complete();
+                if (result.complete) {
+                    return true;
+                }
+                if (result.reason === 'pending_tool') {
+                    // Tool confirmation needed, return early
+                    return false;
+                }
+            }
+            catch (err) {
+                throw err;
+            }
+            await this.sleep(2000);
+        }
+        return false;
+    }
+    /**
+     * Check if response is complete
+     */
+    async complete() {
+        const response = await this.sendCommand('complete');
+        return JSON.parse(response);
+    }
+    /**
+     * Get structured exchange output
+     */
+    async exchange() {
+        const response = await this.sendCommand('exchange');
+        return JSON.parse(response);
+    }
+    /**
+     * Check for pending tool confirmations
+     */
+    async pending() {
+        const response = await this.sendCommand('pending');
+        return JSON.parse(response);
+    }
+    /**
+     * Read raw output
+     */
+    async read(lines = 200) {
+        return await this.sendCommand('read ' + lines);
+    }
+    /**
+     * Get exchange history
+     */
+    async history() {
+        const response = await this.sendCommand('history');
+        return JSON.parse(response);
+    }
+    /**
+     * Clear exchange history
+     */
+    async clearHistory() {
+        await this.sendCommand('history clear');
+    }
+    /**
+     * Stop the server
+     */
+    async stop() {
+        try {
+            await this.sendCommand('stop');
+        }
+        catch {
+            // Server may have already stopped
+        }
+    }
+    /**
+     * Sleep helper
+     */
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+}

package/dist/services/pty-server.d.ts

@@ -0,0 +1,102 @@
+/**
+ * PTY Server - Maintains AI session and accepts commands via TCP
+ * Ported from claude-pty-wrapper/server.js
+ */
+import type { CliProvider } from '../domains/agent/types.js';
+import type { PtySessionState, PtyExchange, PtyToolResult, PtyCompleteResponse, PtyPendingResponse } from '../domains/agent/pty-types.js';
+export interface PtyServerOptions {
+    provider: CliProvider;
+    model: string;
+    tools: string[];
+    sessionState: PtySessionState;
+    port?: number;
+    debug?: boolean;
+}
+export declare class PtyServer {
+    private options;
+    private ai;
+    private server;
+    private outputHistory;
+    private lastPromptIndex;
+    private lastSentPrompt;
+    private lastDataReceivedTime;
+    private currentExchangeId;
+    private exchangeHistory;
+    private streamClients;
+    private port;
+    private debug;
+    pid: number;
+    constructor(options: PtyServerOptions);
+    /**
+     * Start the server
+     */
+    start(): Promise<void>;
+    /**
+     * Start TCP server for client commands
+     */
+    private startTcpServer;
+    /**
+     * Handle client command
+     */
+    handleCommand(cmd: string, args: string): string;
+    /**
+     * Handle send command
+     */
+    private handleSend;
+    /**
+     * Get server status
+     */
+    private getStatus;
+    /**
+     * Clean ANSI codes from output
+     */
+    private cleanAnsi;
+    /**
+     * Extract answer based on provider
+     */
+    extractAnswer(): string;
+    /**
+     * Extract answer from Claude output
+     */
+    private extractAnswerClaude;
+    /**
+     * Extract answer from Gemini output
+     */
+    private extractAnswerGemini;
+    /**
+     * Detect pending tool confirmations
+     */
+    detectPendingTools(): PtyPendingResponse;
+    /**
+     * Clean tool detail string
+     */
+    private cleanToolDetail;
+    /**
+     * Extract tool results from output
+     */
+    extractToolResults(): PtyToolResult[];
+    /**
+     * Get structured exchange data
+     */
+    getStructuredExchange(): PtyExchange;
+    /**
+     * Check if response is complete
+     */
+    isComplete(): PtyCompleteResponse;
+    /**
+     * Parse output for stream events
+     */
+    private parseOutputForEvents;
+    /**
+     * Emit event to stream clients
+     */
+    private emitStreamEvent;
+    /**
+     * Stop the server
+     */
+    stop(): Promise<void>;
+}
+/**
+ * Start server as standalone process
+ */
+export declare function startPtyServerProcess(options: PtyServerOptions): Promise<void>;