@hileeon/mcc 0.1.0

package/lib/proxy/config/config-loader-facade.js

@@ -0,0 +1,24 @@
+/**
+ * Stub for CCS config/config-loader-facade
+ * Provides getCcsDir pointing to ~/.mcc instead of ~/.ccs
+ */
+const path = require('path');
+const os = require('os');
+
+function getCcsDir() {
+  return process.env.MCC_HOME || path.join(os.homedir(), '.mcc');
+}
+
+function loadConfigSafe() {
+  return { profiles: {} };
+}
+
+function loadSettings(_settingsPath) {
+  return { env: {} };
+}
+
+function loadOrCreateUnifiedConfig() {
+  return {};
+}
+
+module.exports = { getCcsDir, loadConfigSafe, loadSettings, loadOrCreateUnifiedConfig };

package/lib/proxy/glmt/delta-accumulator.js

@@ -0,0 +1,363 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * DeltaAccumulator - Maintain state across streaming deltas
+ *
+ * Tracks:
+ * - Message metadata (id, model, role)
+ * - Content blocks (thinking, text)
+ * - Current block index
+ * - Accumulated content
+ *
+ * Usage:
+ *   const acc = new DeltaAccumulator(thinkingConfig);
+ *   const events = transformer.transformDelta(openaiEvent, acc);
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeltaAccumulator = void 0;
+class DeltaAccumulator {
+    constructor(_thinkingConfig = {}, options = {}) {
+        // ========== Finish Reason ==========
+        this.finishReason = null;
+        this.usageReceived = false;
+        this.messageId = 'msg_' + Date.now() + '_' + Math.random().toString(36).substring(7);
+        this.model = null;
+        this.role = 'assistant';
+        // Content blocks
+        this.contentBlocks = [];
+        this.currentBlockIndex = -1;
+        // Tool calls tracking
+        this.toolCalls = [];
+        this.toolCallsIndex = {};
+        // Buffers
+        this.thinkingBuffer = '';
+        this.textBuffer = '';
+        // C-02 Fix: Limits to prevent unbounded accumulation
+        this.maxBlocks = options.maxBlocks || 100;
+        this.maxBufferSize = options.maxBufferSize || 10 * 1024 * 1024; // 10MB
+        // Loop detection configuration
+        this.loopDetectionThreshold = options.loopDetectionThreshold || 3;
+        this.loopDetected = false;
+        // State flags
+        this.messageStarted = false;
+        this.finalized = false;
+        // Statistics
+        this.inputTokens = 0;
+        this.outputTokens = 0;
+    }
+    /**
+     * Get current content block
+     * @returns Current block or null
+     */
+    getCurrentBlock() {
+        if (this.currentBlockIndex >= 0 && this.currentBlockIndex < this.contentBlocks.length) {
+            return this.contentBlocks[this.currentBlockIndex];
+        }
+        return null;
+    }
+    /**
+     * Start new content block
+     * @param type - Block type ('thinking', 'text', or 'tool_use')
+     * @returns New block
+     */
+    startBlock(type) {
+        // C-02 Fix: Enforce max blocks limit
+        if (this.contentBlocks.length >= this.maxBlocks) {
+            throw new Error(`Maximum ${this.maxBlocks} content blocks exceeded (DoS protection)`);
+        }
+        this.currentBlockIndex++;
+        const block = {
+            index: this.currentBlockIndex,
+            type: type,
+            content: '',
+            started: true,
+            stopped: false,
+        };
+        this.contentBlocks.push(block);
+        // Reset buffer for new block (tool_use doesn't use buffers)
+        if (type === 'thinking') {
+            this.thinkingBuffer = '';
+        }
+        else if (type === 'text') {
+            this.textBuffer = '';
+        }
+        return block;
+    }
+    /**
+     * Add delta to current block
+     * @param delta - Content delta
+     */
+    addDelta(delta) {
+        const block = this.getCurrentBlock();
+        if (!block) {
+            // FIX: Guard against null block (should never happen, but defensive)
+            console.error('[DeltaAccumulator] ERROR: addDelta called with no current block');
+            return;
+        }
+        if (block.type === 'thinking') {
+            // C-02 Fix: Enforce buffer size limit
+            if (this.thinkingBuffer.length + delta.length > this.maxBufferSize) {
+                throw new Error(`Thinking buffer exceeded ${this.maxBufferSize} bytes (DoS protection)`);
+            }
+            this.thinkingBuffer += delta;
+            block.content = this.thinkingBuffer;
+            // FIX: Verify assignment succeeded (paranoid check for race conditions)
+            if (block.content.length !== this.thinkingBuffer.length) {
+                console.error('[DeltaAccumulator] ERROR: Block content assignment failed');
+                console.error(`Expected: ${this.thinkingBuffer.length}, Got: ${block.content.length}`);
+            }
+        }
+        else if (block.type === 'text') {
+            // C-02 Fix: Enforce buffer size limit
+            if (this.textBuffer.length + delta.length > this.maxBufferSize) {
+                throw new Error(`Text buffer exceeded ${this.maxBufferSize} bytes (DoS protection)`);
+            }
+            this.textBuffer += delta;
+            block.content = this.textBuffer;
+        }
+    }
+    /**
+     * Mark current block as stopped
+     */
+    stopCurrentBlock() {
+        const block = this.getCurrentBlock();
+        if (block) {
+            block.stopped = true;
+            // FIX: Log block closure for debugging (helps diagnose timing issues)
+            if (block.type === 'thinking' && process.env.CCS_DEBUG === '1') {
+                console.error(`[DeltaAccumulator] Stopped thinking block ${block.index}: ${block.content?.length || 0} chars`);
+            }
+        }
+    }
+    /**
+     * Update usage statistics
+     * @param usage - Usage object from OpenAI
+     */
+    updateUsage(usage) {
+        if (usage) {
+            this.inputTokens = usage.prompt_tokens || usage.input_tokens || 0;
+            this.outputTokens = usage.completion_tokens || usage.output_tokens || 0;
+        }
+    }
+    /**
+     * Add or update tool call delta
+     * @param toolCallDelta - Tool call delta from OpenAI
+     */
+    addToolCallDelta(toolCallDelta) {
+        const index = toolCallDelta.index;
+        if (!this.toolCallsIndex[index]) {
+            const toolCall = {
+                index: index,
+                id: '',
+                type: 'function',
+                function: {
+                    name: '',
+                    arguments: '',
+                },
+                blockIndex: -1,
+            };
+            this.toolCalls.push(toolCall);
+            this.toolCallsIndex[index] = toolCall;
+        }
+        const toolCall = this.toolCallsIndex[index];
+        if (toolCallDelta.id) {
+            toolCall.id = toolCallDelta.id;
+        }
+        if (toolCallDelta.type) {
+            toolCall.type = toolCallDelta.type;
+        }
+        if (toolCallDelta.function?.name) {
+            toolCall.function.name += toolCallDelta.function.name;
+        }
+        if (toolCallDelta.function?.arguments) {
+            toolCall.function.arguments += toolCallDelta.function.arguments;
+        }
+    }
+    setToolCallBlockIndex(toolCallIndex, blockIndex) {
+        const toolCall = this.toolCallsIndex[toolCallIndex];
+        if (toolCall) {
+            toolCall.blockIndex = blockIndex;
+        }
+    }
+    getToolCallBlockIndex(toolCallIndex) {
+        const toolCall = this.toolCallsIndex[toolCallIndex];
+        if (!toolCall || toolCall.blockIndex < 0) {
+            throw new Error(`Tool call ${toolCallIndex} does not have an assigned content block`);
+        }
+        return toolCall.blockIndex;
+    }
+    getUnstoppedBlocks() {
+        return this.contentBlocks.filter((b) => !b.stopped);
+    }
+    /**
+     * Get all tool calls
+     * @returns Tool calls array
+     */
+    getToolCalls() {
+        return this.toolCalls;
+    }
+    /**
+     * Check for planning loop pattern
+     * Loop = N consecutive thinking blocks with no tool calls
+     * @returns True if loop detected
+     */
+    checkForLoop() {
+        // Already detected loop
+        if (this.loopDetected) {
+            return true;
+        }
+        // Need minimum blocks to detect pattern
+        if (this.contentBlocks.length < this.loopDetectionThreshold) {
+            return false;
+        }
+        // Get last N blocks
+        const recentBlocks = this.contentBlocks.slice(-this.loopDetectionThreshold);
+        // Check if all recent blocks are thinking blocks
+        const allThinking = recentBlocks.every((b) => b.type === 'thinking');
+        // Check if no tool calls have been made at all
+        const noToolCalls = this.toolCalls.length === 0;
+        // Loop detected if: all recent blocks are thinking AND no tool calls yet
+        if (allThinking && noToolCalls) {
+            this.loopDetected = true;
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Reset loop detection state (for testing)
+     */
+    resetLoopDetection() {
+        this.loopDetected = false;
+    }
+    /**
+     * Get summary of accumulated state
+     * @returns Summary
+     */
+    getSummary() {
+        return {
+            messageId: this.messageId,
+            model: this.model,
+            role: this.role,
+            blockCount: this.contentBlocks.length,
+            currentIndex: this.currentBlockIndex,
+            toolCallCount: this.toolCalls.length,
+            messageStarted: this.messageStarted,
+            finalized: this.finalized,
+            loopDetected: this.loopDetected,
+            usage: {
+                input_tokens: this.inputTokens,
+                output_tokens: this.outputTokens,
+            },
+        };
+    }
+    // ========== State Getters ==========
+    /**
+     * Check if message has been finalized
+     */
+    isFinalized() {
+        return this.finalized;
+    }
+    /**
+     * Check if message has started
+     */
+    isMessageStarted() {
+        return this.messageStarted;
+    }
+    /**
+     * Get message ID
+     */
+    getMessageId() {
+        return this.messageId;
+    }
+    /**
+     * Get model name
+     */
+    getModel() {
+        return this.model;
+    }
+    /**
+     * Get role
+     */
+    getRole() {
+        return this.role;
+    }
+    /**
+     * Get input tokens
+     */
+    getInputTokens() {
+        return this.inputTokens;
+    }
+    /**
+     * Get output tokens
+     */
+    getOutputTokens() {
+        return this.outputTokens;
+    }
+    // ========== State Setters ==========
+    /**
+     * Set model name
+     */
+    setModel(model) {
+        this.model = model;
+    }
+    /**
+     * Set message started flag
+     */
+    setMessageStarted(started) {
+        this.messageStarted = started;
+    }
+    /**
+     * Set role
+     */
+    setRole(role) {
+        this.role = role;
+    }
+    /**
+     * Set finalized flag
+     */
+    setFinalized(finalized) {
+        this.finalized = finalized;
+    }
+    /**
+     * Set finish reason
+     */
+    setFinishReason(reason) {
+        this.finishReason = reason;
+    }
+    /**
+     * Get finish reason
+     */
+    getFinishReason() {
+        return this.finishReason;
+    }
+    /**
+     * Check if usage stats have been received
+     */
+    hasUsageReceived() {
+        return this.usageReceived;
+    }
+    /**
+     * Mark usage as received
+     */
+    setUsageReceived(received) {
+        this.usageReceived = received;
+    }
+    // ========== Tool Call Helpers ==========
+    /**
+     * Check if there are any tool calls, or check if a specific index exists
+     */
+    hasToolCall(index) {
+        if (index === undefined) {
+            return this.toolCalls.length > 0;
+        }
+        return this.toolCallsIndex[index] !== undefined;
+    }
+    /**
+     * Get tool call by index
+     */
+    getToolCall(index) {
+        return this.toolCallsIndex[index];
+    }
+}
+exports.DeltaAccumulator = DeltaAccumulator;
+//# sourceMappingURL=delta-accumulator.js.map

package/lib/proxy/glmt/glmt-transformer.js

@@ -0,0 +1,204 @@
+"use strict";
+/**
+ * GlmtTransformer - Orchestrator for Anthropic ↔ OpenAI format transformation
+ *
+ * Pipeline Architecture:
+ * - RequestTransformer: Anthropic → OpenAI request conversion
+ * - StreamParser: Delta processing for streaming responses
+ * - ResponseBuilder: SSE event generation
+ * - ToolCallHandler: Tool call processing
+ */
+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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GlmtTransformer = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const logging_1 = require("../services/logging");
+const pipeline_1 = require("./pipeline");
+const config_loader_facade_1 = require("../config/config-loader-facade");
+class GlmtTransformer {
+    constructor(config = {}) {
+        this.logger = (0, logging_1.createLogger)('glmt:transformer');
+        this.verbose = config.verbose || false;
+        const debugEnabled = process.env.CCS_DEBUG === '1';
+        this.debugLog = config.debugLog ?? debugEnabled;
+        this.debugLogDir = config.debugLogDir || path.join((0, config_loader_facade_1.getCcsDir)(), 'logs');
+        // Initialize pipeline components
+        this.requestTransformer = new pipeline_1.RequestTransformer({
+            defaultThinking: config.defaultThinking ?? true,
+            verbose: this.verbose,
+            explicitReasoning: config.explicitReasoning ?? true,
+            log: (msg) => this.log(msg),
+        });
+        this.responseBuilder = new pipeline_1.ResponseBuilder(this.verbose);
+        this.toolCallHandler = new pipeline_1.ToolCallHandler();
+        this.contentTransformer = new pipeline_1.ContentTransformer(config.defaultThinking ?? true);
+        this.streamParser = new pipeline_1.StreamParser({
+            verbose: this.verbose,
+            debugMode: config.debugMode ?? debugEnabled,
+            debugLog: this.debugLog,
+            writeDebugLog: (type, data) => this.writeDebugLog(type, data),
+        });
+    }
+    /** Transform Anthropic request to OpenAI format */
+    transformRequest(anthropicRequest) {
+        this.writeDebugLog('request-anthropic', anthropicRequest);
+        const result = this.requestTransformer.transform(anthropicRequest);
+        this.writeDebugLog('request-openai', result.openaiRequest);
+        return result;
+    }
+    /** Transform OpenAI response to Anthropic format */
+    transformResponse(openaiResponse, _thinkingConfig = { thinking: false, effort: 'medium' }) {
+        this.writeDebugLog('response-openai', openaiResponse);
+        try {
+            const choice = openaiResponse.choices?.[0];
+            if (!choice)
+                throw new Error('No choices in OpenAI response');
+            const message = choice.message;
+            const content = [];
+            if (message.reasoning_content) {
+                this.log(`Detected reasoning_content: ${message.reasoning_content.length} chars`);
+                content.push({
+                    type: 'thinking',
+                    thinking: message.reasoning_content,
+                    signature: this.responseBuilder.generateThinkingSignature(message.reasoning_content),
+                });
+            }
+            if (message.content) {
+                content.push({ type: 'text', text: message.content });
+            }
+            if (message.tool_calls?.length) {
+                content.push(...this.toolCallHandler.processToolCalls(message.tool_calls));
+            }
+            const anthropicResponse = {
+                id: openaiResponse.id || 'msg_' + Date.now(),
+                type: 'message',
+                role: 'assistant',
+                content,
+                model: openaiResponse.model || 'glm-5',
+                stop_reason: this.responseBuilder.mapStopReason(choice.finish_reason || 'stop'),
+                usage: {
+                    input_tokens: openaiResponse.usage?.prompt_tokens || 0,
+                    output_tokens: openaiResponse.usage?.completion_tokens || 0,
+                },
+            };
+            this.writeDebugLog('response-anthropic', anthropicResponse);
+            return anthropicResponse;
+        }
+        catch (error) {
+            const err = error;
+            this.logger.stage('cleanup', 'response.transform_failed', 'GLMT response transformation failed', undefined, { level: 'error', error: { name: err.name, message: err.message } });
+            console.error('[glmt-transformer] Response transformation error:', err);
+            return {
+                id: 'msg_error_' + Date.now(),
+                type: 'message',
+                role: 'assistant',
+                content: [{ type: 'text', text: '[Transformation Error] ' + err.message }],
+                model: 'glm-5',
+                stop_reason: 'end_turn',
+                usage: { input_tokens: 0, output_tokens: 0 },
+            };
+        }
+    }
+    /** Transform streaming delta (delegates to StreamParser) */
+    transformDelta(openaiEvent, accumulator) {
+        return this.streamParser.transformDelta(openaiEvent, accumulator);
+    }
+    /** Finalize streaming (delegates to StreamParser) */
+    finalizeDelta(accumulator) {
+        return this.streamParser.finalizeDelta(accumulator);
+    }
+    redactSensitiveData(data) {
+        if (data === null || data === undefined)
+            return data;
+        if (typeof data !== 'object')
+            return data;
+        if (Array.isArray(data))
+            return data.map((item) => this.redactSensitiveData(item));
+        const SENSITIVE_KEYS = /^(authorization|auth[_-]?token|api[_-]?key|apikey|token|secret|password|credential|x-api-key|anthropic-api-key|cookie)$/i;
+        const result = {};
+        for (const [key, value] of Object.entries(data)) {
+            if (SENSITIVE_KEYS.test(key)) {
+                result[key] = '[REDACTED]';
+            }
+            else {
+                result[key] = this.redactSensitiveData(value);
+            }
+        }
+        return result;
+    }
+    writeDebugLog(type, data) {
+        if (!this.debugLog)
+            return;
+        try {
+            const timestamp = new Date().toISOString().replace(/[:.]/g, '-').split('.')[0];
+            const filepath = path.join(this.debugLogDir, `${timestamp}-${type}.json`);
+            fs.mkdirSync(this.debugLogDir, { recursive: true });
+            const redacted = this.redactSensitiveData(data);
+            fs.writeFileSync(filepath, JSON.stringify(redacted, null, 2) + '\n', 'utf8');
+        }
+        catch (error) {
+            this.logger.warn('debug-log.write_failed', 'GLMT debug log write failed', {
+                message: error.message,
+            });
+            console.error(`[glmt-transformer] Debug log error: ${error.message}`);
+        }
+    }
+    log(message) {
+        if (this.verbose) {
+            this.logger.debug('transformer.verbose', message);
+            console.error(`[glmt-transformer] [${new Date().toTimeString().split(' ')[0]}] ${message}`);
+        }
+    }
+    // ========== Backwards-compatible public methods ==========
+    /** Generate thinking signature (delegates to ResponseBuilder) */
+    generateThinkingSignature(thinking) {
+        return this.responseBuilder.generateThinkingSignature(thinking);
+    }
+    /** Map stop reason (delegates to ResponseBuilder) */
+    mapStopReason(openaiReason) {
+        return this.responseBuilder.mapStopReason(openaiReason);
+    }
+    /** Detect think keywords (delegates to ContentTransformer) */
+    detectThinkKeywords(messages) {
+        return this.contentTransformer.detectThinkKeywords(messages);
+    }
+    /** Validate transformation result */
+    validateTransformation(anthropicResponse) {
+        const checks = {
+            hasContent: Boolean(anthropicResponse.content && anthropicResponse.content.length > 0),
+            hasThinking: anthropicResponse.content?.some((block) => block.type === 'thinking') || false,
+            hasText: anthropicResponse.content?.some((block) => block.type === 'text') || false,
+            validStructure: anthropicResponse.type === 'message' && anthropicResponse.role === 'assistant',
+            hasUsage: Boolean(anthropicResponse.usage),
+        };
+        const passed = Object.values(checks).filter(Boolean).length;
+        const total = Object.keys(checks).length;
+        return { checks, passed, total, valid: passed === total };
+    }
+}
+exports.GlmtTransformer = GlmtTransformer;
+exports.default = GlmtTransformer;
+//# sourceMappingURL=glmt-transformer.js.map

package/lib/proxy/glmt/index.js

@@ -0,0 +1,41 @@
+"use strict";
+/**
+ * GLMT (GLM Thinking) Module Barrel Export
+ *
+ * Provides OpenAI-to-Anthropic protocol translation for GLM models with
+ * extended thinking support.
+ */
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReasoningEnforcer = exports.LocaleEnforcer = exports.DeltaAccumulator = exports.SSEParser = exports.GlmtTransformer = exports.GlmtProxy = void 0;
+// Core proxy and transformer
+var glmt_proxy_1 = require("./glmt-proxy");
+Object.defineProperty(exports, "GlmtProxy", { enumerable: true, get: function () { return glmt_proxy_1.GlmtProxy; } });
+var glmt_transformer_1 = require("./glmt-transformer");
+Object.defineProperty(exports, "GlmtTransformer", { enumerable: true, get: function () { return glmt_transformer_1.GlmtTransformer; } });
+// Streaming utilities
+var sse_parser_1 = require("./sse-parser");
+Object.defineProperty(exports, "SSEParser", { enumerable: true, get: function () { return sse_parser_1.SSEParser; } });
+var delta_accumulator_1 = require("./delta-accumulator");
+Object.defineProperty(exports, "DeltaAccumulator", { enumerable: true, get: function () { return delta_accumulator_1.DeltaAccumulator; } });
+// Content enforcers
+var locale_enforcer_1 = require("./locale-enforcer");
+Object.defineProperty(exports, "LocaleEnforcer", { enumerable: true, get: function () { return locale_enforcer_1.LocaleEnforcer; } });
+var reasoning_enforcer_1 = require("./reasoning-enforcer");
+Object.defineProperty(exports, "ReasoningEnforcer", { enumerable: true, get: function () { return reasoning_enforcer_1.ReasoningEnforcer; } });
+// Pipeline components and types
+__exportStar(require("./pipeline"), exports);
+//# sourceMappingURL=index.js.map