@kaitranntt/ccs 3.3.0 → 3.4.1

package/bin/glmt/glmt-proxy.js

@@ -0,0 +1,488 @@
+#!/usr/bin/env node
+'use strict';
+
+const http = require('http');
+const https = require('https');
+const GlmtTransformer = require('./glmt-transformer');
+const SSEParser = require('./sse-parser');
+const DeltaAccumulator = require('./delta-accumulator');
+
+/**
+ * GlmtProxy - Embedded HTTP proxy for GLM thinking support
+ *
+ * Architecture:
+ * - Intercepts Claude CLI → Z.AI calls
+ * - Transforms Anthropic format → OpenAI format
+ * - Converts reasoning_content → thinking blocks
+ * - Supports both streaming and buffered modes
+ *
+ * Lifecycle:
+ * - Spawned by bin/ccs.js when 'glmt' profile detected
+ * - Binds to 127.0.0.1:random_port (security + avoid conflicts)
+ * - Terminates when parent process exits
+ *
+ * Debugging:
+ * - Verbose: Pass --verbose to see request/response logs
+ * - Debug: Set CCS_DEBUG_LOG=1 to write logs to ~/.ccs/logs/
+ *
+ * Usage:
+ *   const proxy = new GlmtProxy({ verbose: true });
+ *   await proxy.start();
+ */
+class GlmtProxy {
+  constructor(config = {}) {
+    this.transformer = new GlmtTransformer({
+      verbose: config.verbose,
+      debugLog: config.debugLog || process.env.CCS_DEBUG_LOG === '1'
+    });
+    // Use ANTHROPIC_BASE_URL from environment (set by settings.json) or fallback to Z.AI default
+    this.upstreamUrl = process.env.ANTHROPIC_BASE_URL || 'https://api.z.ai/api/coding/paas/v4/chat/completions';
+    this.server = null;
+    this.port = null;
+    this.verbose = config.verbose || false;
+    this.timeout = config.timeout || 120000; // 120s default
+    this.streamingEnabled = process.env.CCS_GLMT_STREAMING !== 'disabled';
+    this.forceStreaming = process.env.CCS_GLMT_STREAMING === 'force';
+  }
+
+  /**
+   * Start HTTP server on random port
+   * @returns {Promise<number>} Port number
+   */
+  async start() {
+    return new Promise((resolve, reject) => {
+      this.server = http.createServer((req, res) => {
+        this.handleRequest(req, res);
+      });
+
+      // Bind to 127.0.0.1:0 (random port for security + avoid conflicts)
+      this.server.listen(0, '127.0.0.1', () => {
+        this.port = this.server.address().port;
+        // Signal parent process
+        console.log(`PROXY_READY:${this.port}`);
+
+        // Info message (only show in verbose mode)
+        if (this.verbose) {
+          const mode = this.streamingEnabled ? 'streaming mode' : 'buffered mode';
+          console.error(`[glmt] Proxy listening on port ${this.port} (${mode})`);
+        }
+
+        // Debug mode notice
+        if (this.transformer.debugLog) {
+          console.error(`[glmt] Debug logging enabled: ${this.transformer.debugLogDir}`);
+          console.error(`[glmt] WARNING: Debug logs contain full request/response data`);
+        }
+
+        this.log(`Verbose logging enabled`);
+        resolve(this.port);
+      });
+
+      this.server.on('error', (error) => {
+        console.error('[glmt-proxy] Server error:', error);
+        reject(error);
+      });
+    });
+  }
+
+  /**
+   * Handle incoming HTTP request
+   * @param {http.IncomingMessage} req - Request
+   * @param {http.ServerResponse} res - Response
+   */
+  async handleRequest(req, res) {
+    const startTime = Date.now();
+    this.log(`Request: ${req.method} ${req.url}`);
+
+    try {
+      // Only accept POST requests
+      if (req.method !== 'POST') {
+        res.writeHead(405, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Method not allowed' }));
+        return;
+      }
+
+      // Read request body
+      const body = await this._readBody(req);
+      this.log(`Request body size: ${body.length} bytes`);
+
+      // Parse JSON with error handling
+      let anthropicRequest;
+      try {
+        anthropicRequest = JSON.parse(body);
+      } catch (jsonError) {
+        res.writeHead(400, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({
+          error: {
+            type: 'invalid_request_error',
+            message: 'Invalid JSON in request body: ' + jsonError.message
+          }
+        }));
+        return;
+      }
+
+      // Log thinking parameter for debugging
+      if (anthropicRequest.thinking) {
+        this.log(`Request contains thinking parameter: ${JSON.stringify(anthropicRequest.thinking)}`);
+      } else {
+        this.log(`Request does NOT contain thinking parameter (will use message tags or default)`);
+      }
+
+      // Branch: streaming or buffered
+      const useStreaming = (anthropicRequest.stream && this.streamingEnabled) || this.forceStreaming;
+
+      if (useStreaming) {
+        await this._handleStreamingRequest(req, res, anthropicRequest, startTime);
+      } else {
+        await this._handleBufferedRequest(req, res, anthropicRequest, startTime);
+      }
+
+    } catch (error) {
+      console.error('[glmt-proxy] Request error:', error.message);
+      const duration = Date.now() - startTime;
+      this.log(`Request failed after ${duration}ms: ${error.message}`);
+
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({
+        error: {
+          type: 'proxy_error',
+          message: error.message
+        }
+      }));
+    }
+  }
+
+  /**
+   * Handle buffered (non-streaming) request
+   * @private
+   */
+  async _handleBufferedRequest(req, res, anthropicRequest, startTime) {
+    // Transform to OpenAI format
+    const { openaiRequest, thinkingConfig } =
+      this.transformer.transformRequest(anthropicRequest);
+
+    this.log(`Transformed request, thinking: ${thinkingConfig.thinking}`);
+
+    // Forward to Z.AI
+    const openaiResponse = await this._forwardToUpstream(
+      openaiRequest,
+      req.headers
+    );
+
+    this.log(`Received response from upstream`);
+
+    // Transform back to Anthropic format
+    const anthropicResponse = this.transformer.transformResponse(
+      openaiResponse,
+      thinkingConfig
+    );
+
+    // Return to Claude CLI
+    res.writeHead(200, {
+      'Content-Type': 'application/json',
+      'Access-Control-Allow-Origin': '*'
+    });
+    res.end(JSON.stringify(anthropicResponse));
+
+    const duration = Date.now() - startTime;
+    this.log(`Request completed in ${duration}ms`);
+  }
+
+  /**
+   * Handle streaming request
+   * @private
+   */
+  async _handleStreamingRequest(req, res, anthropicRequest, startTime) {
+    this.log('Using streaming mode');
+
+    // Transform request
+    const { openaiRequest, thinkingConfig } =
+      this.transformer.transformRequest(anthropicRequest);
+
+    // Force streaming
+    openaiRequest.stream = true;
+
+    // Set SSE headers
+    res.writeHead(200, {
+      'Content-Type': 'text/event-stream',
+      'Cache-Control': 'no-cache',
+      'Connection': 'keep-alive',
+      'Access-Control-Allow-Origin': '*',
+      'X-Accel-Buffering': 'no' // Disable proxy buffering
+    });
+
+    // Disable Nagle's algorithm to prevent buffering at socket level
+    if (res.socket) {
+      res.socket.setNoDelay(true);
+    }
+
+    this.log('Starting SSE stream to Claude CLI (socket buffering disabled)');
+
+    // Forward and stream
+    await this._forwardAndStreamUpstream(
+      openaiRequest,
+      req.headers,
+      res,
+      thinkingConfig,
+      startTime
+    );
+  }
+
+  /**
+   * Read request body
+   * @param {http.IncomingMessage} req - Request
+   * @returns {Promise<string>} Body content
+   * @private
+   */
+  _readBody(req) {
+    return new Promise((resolve, reject) => {
+      const chunks = [];
+      const maxSize = 10 * 1024 * 1024; // 10MB limit
+      let totalSize = 0;
+
+      req.on('data', chunk => {
+        totalSize += chunk.length;
+        if (totalSize > maxSize) {
+          reject(new Error('Request body too large (max 10MB)'));
+          return;
+        }
+        chunks.push(chunk);
+      });
+
+      req.on('end', () => resolve(Buffer.concat(chunks).toString()));
+      req.on('error', reject);
+    });
+  }
+
+  /**
+   * Forward request to Z.AI upstream
+   * @param {Object} openaiRequest - OpenAI format request
+   * @param {Object} originalHeaders - Original request headers
+   * @returns {Promise<Object>} OpenAI response
+   * @private
+   */
+  _forwardToUpstream(openaiRequest, originalHeaders) {
+    return new Promise((resolve, reject) => {
+      const url = new URL(this.upstreamUrl);
+      const requestBody = JSON.stringify(openaiRequest);
+
+      const options = {
+        hostname: url.hostname,
+        port: url.port || 443,
+        path: url.pathname || '/api/coding/paas/v4/chat/completions',
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Content-Length': Buffer.byteLength(requestBody),
+          // Preserve auth header from original request
+          'Authorization': originalHeaders['authorization'] || '',
+          'User-Agent': 'CCS-GLMT-Proxy/1.0'
+        }
+      };
+
+      // Debug logging
+      this.log(`Forwarding to: ${url.hostname}${url.pathname}`);
+
+      // Set timeout
+      const timeoutHandle = setTimeout(() => {
+        req.destroy();
+        reject(new Error('Upstream request timeout'));
+      }, this.timeout);
+
+      const req = https.request(options, (res) => {
+        clearTimeout(timeoutHandle);
+
+        const chunks = [];
+        res.on('data', chunk => chunks.push(chunk));
+
+        res.on('end', () => {
+          try {
+            const body = Buffer.concat(chunks).toString();
+            this.log(`Upstream response size: ${body.length} bytes`);
+
+            // Check for non-200 status
+            if (res.statusCode !== 200) {
+              reject(new Error(
+                `Upstream error: ${res.statusCode} ${res.statusMessage}\n${body}`
+              ));
+              return;
+            }
+
+            const response = JSON.parse(body);
+            resolve(response);
+          } catch (error) {
+            reject(new Error('Invalid JSON from upstream: ' + error.message));
+          }
+        });
+      });
+
+      req.on('error', (error) => {
+        clearTimeout(timeoutHandle);
+        reject(error);
+      });
+
+      req.write(requestBody);
+      req.end();
+    });
+  }
+
+  /**
+   * Forward request to Z.AI and stream response
+   * @param {Object} openaiRequest - OpenAI format request
+   * @param {Object} originalHeaders - Original request headers
+   * @param {http.ServerResponse} clientRes - Response to Claude CLI
+   * @param {Object} thinkingConfig - Thinking configuration
+   * @param {number} startTime - Request start time
+   * @returns {Promise<void>}
+   * @private
+   */
+  async _forwardAndStreamUpstream(openaiRequest, originalHeaders, clientRes, thinkingConfig, startTime) {
+    return new Promise((resolve, reject) => {
+      const url = new URL(this.upstreamUrl);
+      const requestBody = JSON.stringify(openaiRequest);
+
+      const options = {
+        hostname: url.hostname,
+        port: url.port || 443,
+        path: url.pathname || '/api/coding/paas/v4/chat/completions',
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Content-Length': Buffer.byteLength(requestBody),
+          'Authorization': originalHeaders['authorization'] || '',
+          'User-Agent': 'CCS-GLMT-Proxy/1.0',
+          'Accept': 'text/event-stream'
+        }
+      };
+
+      this.log(`Forwarding streaming request to: ${url.hostname}${url.pathname}`);
+
+      // C-03 Fix: Apply timeout to streaming requests
+      const timeoutHandle = setTimeout(() => {
+        req.destroy();
+        reject(new Error(`Streaming request timeout after ${this.timeout}ms`));
+      }, this.timeout);
+
+      const req = https.request(options, (upstreamRes) => {
+        clearTimeout(timeoutHandle);
+        if (upstreamRes.statusCode !== 200) {
+          let body = '';
+          upstreamRes.on('data', chunk => body += chunk);
+          upstreamRes.on('end', () => {
+            reject(new Error(`Upstream error: ${upstreamRes.statusCode}\n${body}`));
+          });
+          return;
+        }
+
+        const parser = new SSEParser();
+        const accumulator = new DeltaAccumulator(thinkingConfig);
+
+        upstreamRes.on('data', (chunk) => {
+          try {
+            const events = parser.parse(chunk);
+
+            events.forEach(event => {
+              // Transform OpenAI delta → Anthropic events
+              const anthropicEvents = this.transformer.transformDelta(event, accumulator);
+
+              // Forward to Claude CLI with immediate flush
+              anthropicEvents.forEach(evt => {
+                const eventLine = `event: ${evt.event}\n`;
+                const dataLine = `data: ${JSON.stringify(evt.data)}\n\n`;
+                clientRes.write(eventLine + dataLine);
+
+                // Flush immediately if method available (HTTP/2 or custom servers)
+                if (typeof clientRes.flush === 'function') {
+                  clientRes.flush();
+                }
+              });
+            });
+          } catch (error) {
+            this.log(`Error processing chunk: ${error.message}`);
+          }
+        });
+
+        upstreamRes.on('end', () => {
+          const duration = Date.now() - startTime;
+          this.log(`Streaming completed in ${duration}ms`);
+          clientRes.end();
+          resolve();
+        });
+
+        upstreamRes.on('error', (error) => {
+          clearTimeout(timeoutHandle);
+          this.log(`Upstream stream error: ${error.message}`);
+          clientRes.write(`event: error\n`);
+          clientRes.write(`data: ${JSON.stringify({ error: error.message })}\n\n`);
+          clientRes.end();
+          reject(error);
+        });
+      });
+
+      req.on('error', (error) => {
+        clearTimeout(timeoutHandle);
+        this.log(`Request error: ${error.message}`);
+        clientRes.write(`event: error\n`);
+        clientRes.write(`data: ${JSON.stringify({ error: error.message })}\n\n`);
+        clientRes.end();
+        reject(error);
+      });
+
+      req.write(requestBody);
+      req.end();
+    });
+  }
+
+  /**
+   * Stop proxy server
+   */
+  stop() {
+    if (this.server) {
+      this.log('Stopping proxy server');
+      this.server.close();
+    }
+  }
+
+  /**
+   * Log message if verbose
+   * @param {string} message - Message to log
+   * @private
+   */
+  log(message) {
+    if (this.verbose) {
+      console.error(`[glmt-proxy] ${message}`);
+    }
+  }
+}
+
+// Main entry point
+if (require.main === module) {
+  const args = process.argv.slice(2);
+  const verbose = args.includes('--verbose') || args.includes('-v');
+
+  const proxy = new GlmtProxy({ verbose });
+
+  proxy.start().catch(error => {
+    console.error('[glmt-proxy] Failed to start:', error);
+    process.exit(1);
+  });
+
+  // Cleanup on signals
+  process.on('SIGTERM', () => {
+    proxy.stop();
+    process.exit(0);
+  });
+
+  process.on('SIGINT', () => {
+    proxy.stop();
+    process.exit(0);
+  });
+
+  // Keep process alive
+  process.on('uncaughtException', (error) => {
+    console.error('[glmt-proxy] Uncaught exception:', error);
+    proxy.stop();
+    process.exit(1);
+  });
+}
+
+module.exports = GlmtProxy;