@kaitranntt/ccs 3.2.0 → 3.4.0

package/README.md

@@ -30,7 +30,7 @@ Stop hitting rate limits. Keep working continuously.
 claude /login
 ```
 
-### Primary Installation Methods
+### Installation
 
 #### Option 1: npm Package (Recommended)
 
@@ -75,6 +75,7 @@ irm ccs.kaitran.ca/install | iex
 {
   "profiles": {
     "glm": "~/.ccs/glm.settings.json",
+    "glmt": "~/.ccs/glmt.settings.json",
     "kimi": "~/.ccs/kimi.settings.json",
     "default": "~/.claude/settings.json"
   }
@@ -106,19 +107,23 @@ $env:CCS_CLAUDE_PATH = "D:\Tools\Claude\claude.exe"   # Windows
 
 ### Your First Switch
 
-> **⚠️ Important**: Before using GLM or Kimi profiles, you need to update your API keys in their respective settings files:
+> **⚠️ Important**: Before using GLM/GLMT or Kimi profiles, update API keys in settings files:
 > - **GLM**: Edit `~/.ccs/glm.settings.json` and add your GLM API key
+> - **GLMT**: Edit `~/.ccs/glmt.settings.json` and add your Z.AI API key (requires coding plan)
 > - **Kimi**: Edit `~/.ccs/kimi.settings.json` and add your Kimi API key
 
 ```bash
-# Use Claude subscription (default) for high-level planning
-ccs "Plan the implementation of a microservices architecture"
+# Default Claude subscription
+ccs "Plan microservices architecture"
 
-# Switch to GLM for cost-optimized tasks
-ccs glm "Create a simple REST API"
+# Switch to GLM (cost-optimized)
+ccs glm "Create REST API"
 
-# Switch to Kimi for its thinking capabilities
-ccs kimi "Write integration tests with proper error handling"
+# GLM with thinking mode
+ccs glmt "Solve algorithmic problem"
+
+# Kimi for coding
+ccs kimi "Write integration tests"
 ```
 
 ---
@@ -149,186 +154,208 @@ Manual context switching breaks your workflow. **CCS manages it seamlessly**.
 
 </div>
 
-**The Solution**:
-```bash
-ccs work          # Use company Claude account
-ccs personal      # Switch to personal Claude account
-ccs glm           # Switch to GLM for cost-effective tasks
-ccs kimi          # Switch to Kimi for alternative option
-# Hit rate limit? Switch instantly:
-ccs glm           # Continue working with GLM
-# Need different company account?
-ccs work-2        # Switch to second company account
-```
-
 ---
 
-## 📁 Shared Data Architecture
+## Architecture
+
+### Profile Types
+
+**Settings-based**: GLM, GLMT, Kimi, default
+- Uses `--settings` flag pointing to config files
+- GLMT: Embedded proxy for thinking mode support
+
+**Account-based**: work, personal, team
+- Uses `CLAUDE_CONFIG_DIR` for isolated instances
+- Create with `ccs auth create <profile>`
+
+### Shared Data (v3.1)
 
-**v3.1 Shared Global Data**: Commands and skills are symlinked across all profiles via `~/.ccs/shared/`, eliminating duplication.
+Commands and skills symlinked from `~/.ccs/shared/` - no duplication across profiles.
 
-**Directory Structure**:
 ```
 ~/.ccs/
 ├── shared/                  # Shared across all profiles
-│   ├── commands/            # Custom slash commands
-│   └── skills/              # Claude Code skills
+│   ├── agents/
+│   ├── commands/
+│   └── skills/
 ├── instances/               # Profile-specific data
-│   ├── work/
-│   │   ├── commands@ → ~/.ccs/shared/commands/  # Symlink
-│   │   ├── skills@ → ~/.ccs/shared/skills/      # Symlink
-│   │   ├── settings.json    # Profile-specific config
-│   │   └── sessions/        # Profile-specific sessions
-│   └── personal/
+│   └── work/
+│       ├── agents@ → shared/agents/
+│       ├── commands@ → shared/commands/
+│       ├── skills@ → shared/skills/
+│       ├── settings.json    # API keys, credentials
+│       └── sessions/        # Conversation history
 │       └── ...
 ```
 
-**Benefits**:
-- No duplication of commands/skills across profiles
-- Single source of truth for shared resources
-- Automatic migration from v3.0 (runs on first use)
-- Windows fallback: copies if symlinks unavailable (enable Developer Mode for true symlinks)
+**Shared**: commands/, skills/, agents/
+**Profile-specific**: settings.json, sessions/, todolists/, logs/
 
-**What's Shared**:
-- `.claude/commands/` - Custom slash commands
-- `.claude/skills/` - Claude Code skills
-
-**What's Profile-Specific**:
-- `settings.json` - API keys, credentials
-- `sessions/` - Conversation history
-- `todolists/` - Task tracking
-- `logs/` - Profile-specific logs
+**[i] Windows**: Copies dirs if symlinks unavailable (enable Developer Mode for true symlinks)
 
 ---
 
-## 🏗️ Architecture Overview
+## GLM with Thinking (GLMT)
+
+> **[!] Important**: GLMT requires npm installation (`npm install -g @kaitranntt/ccs`). Not available in native shell versions (requires Node.js HTTP server).
 
-**v3.0 Login-Per-Profile Model**: Each profile is an isolated Claude instance where users login directly. No credential copying or vault encryption.
+### GLM vs GLMT
 
-```mermaid
-flowchart TD
-    subgraph "User Input"
-        USER["User runs: ccs &lt;profile&gt; [args...]"]
-    end
+| Feature | GLM (`ccs glm`) | GLMT (`ccs glmt`) |
+|---------|-----------------|-------------------|
+| **Endpoint** | Anthropic-compatible | OpenAI-compatible |
+| **Thinking** | No | Yes (reasoning_content) |
+| **Streaming** | Yes | **Yes (v3.4+)** |
+| **TTFB** | <500ms | <500ms (streaming), 2-10s (buffered) |
+| **Use Case** | Fast responses | Complex reasoning |
 
-    subgraph "Profile Detection Engine"
-        DETECT[ProfileDetector]
-        PROFILE_CHECK{Profile exists?}
+### Streaming Support (v3.4)
 
-        subgraph "Profile Types"
-            SETTINGS["Settings-based<br/>glm, kimi, default"]
-            ACCOUNT["Account-based<br/>work, personal, team"]
-        end
-    end
+**GLMT now supports real-time streaming** with incremental reasoning content delivery.
 
-    subgraph "CCS Core Processing"
-        CONFIG["Read config.json<br/>and profiles.json"]
+- **Default**: Streaming enabled (TTFB <500ms)
+- **Disable**: Set `CCS_GLMT_STREAMING=disabled` for buffered mode
+- **Force**: Set `CCS_GLMT_STREAMING=force` to override client preferences
 
-        subgraph "Profile Handlers"
-            SETTINGS_MGR["SettingsManager<br/>→ --settings flag"]
-            INSTANCE_MGR["InstanceManager<br/>→ CLAUDE_CONFIG_DIR"]
-        end
-    end
+**Confirmed working**: Z.AI (1498 reasoning chunks tested)
 
-    subgraph "Claude CLI Execution"
-        CLAUDE_DETECT["Claude CLI Detection<br/>CCS_CLAUDE_PATH support"]
+### How It Works
 
-        subgraph "Execution Methods"
-            SETTINGS_EXEC["claude --settings &lt;path&gt;"]
-            INSTANCE_EXEC["CLAUDE_CONFIG_DIR=&lt;instance&gt; claude"]
-        end
-    end
+1. CCS spawns embedded HTTP proxy on localhost
+2. Proxy converts Anthropic format → OpenAI format (streaming or buffered)
+3. Forwards to Z.AI with reasoning parameters
+4. Converts `reasoning_content` → thinking blocks (incremental or complete)
+5. Thinking appears in Claude Code UI in real-time
 
-    subgraph "API Layer"
-        API["API Response<br/>Claude Sonnet 4.5<br/>GLM 4.6<br/>Kimi K2 Thinking"]
-    end
+### Control Tags
 
-    %% Flow connections
-    USER --> DETECT
-    DETECT --> PROFILE_CHECK
-    PROFILE_CHECK -->|Yes| SETTINGS
-    PROFILE_CHECK -->|Yes| ACCOUNT
+- `<Thinking:On|Off>` - Enable/disable reasoning blocks (default: On)
+- `<Effort:Low|Medium|High>` - Control reasoning depth (default: Medium)
 
-    SETTINGS --> CONFIG
-    ACCOUNT --> CONFIG
+### API Key Setup
 
-    CONFIG --> SETTINGS_MGR
-    CONFIG --> INSTANCE_MGR
+```bash
+# Edit GLMT settings
+nano ~/.ccs/glmt.settings.json
 
-    SETTINGS_MGR --> SETTINGS_EXEC
-    INSTANCE_MGR --> INSTANCE_EXEC
+# Set Z.AI API key (requires coding plan)
+{
+  "env": {
+    "ANTHROPIC_AUTH_TOKEN": "your-z-ai-api-key"
+  }
+}
+```
 
-    SETTINGS_EXEC --> CLAUDE_DETECT
-    INSTANCE_EXEC --> CLAUDE_DETECT
+### Security Limits
 
-    CLAUDE_DETECT --> API
+**DoS protection** (v3.4):
+- SSE buffer: 1MB max per event
+- Content buffer: 10MB max per block (thinking/text)
+- Content blocks: 100 max per message
+- Request timeout: 120s (both streaming and buffered)
+
+### Debugging
+
+**Enable verbose logging**:
+```bash
+ccs glmt --verbose "your prompt"
 ```
 
----
+**Enable debug file logging**:
+```bash
+export CCS_DEBUG_LOG=1
+ccs glmt --verbose "your prompt"
+# Logs: ~/.ccs/logs/
+```
 
-## ⚡ Features
+**Check streaming mode**:
+```bash
+# Disable streaming for debugging
+CCS_GLMT_STREAMING=disabled ccs glmt "test"
+```
 
-- **Instant Switching** - `ccs glm` switches to GLM, no config editing
-- **Concurrent Sessions** - Run multiple profiles simultaneously in different terminals
-- **Isolated Instances** - Each profile gets own config (`~/.ccs/instances/<profile>/`)
-- **Cross-Platform** - macOS, Linux, Windows - identical behavior
-- **Zero Downtime** - Switch instantly, no workflow interruption
+**Check reasoning content**:
+```bash
+cat ~/.ccs/logs/*response-openai.json | jq '.choices[0].message.reasoning_content'
+```
 
+**If absent**: Z.AI API issue (verify key, account status)
+**If present**: Transformation issue (check response-anthropic.json)
 
 ---
 
-## 💻 Usage Examples
+## Usage Examples
 
-### Basic Profile Switching
+### Basic Switching
 ```bash
-ccs              # Use Claude subscription (default)
-ccs glm          # Use GLM fallback
-ccs kimi         # Use Kimi for Coding
-ccs --version    # Show CCS version and install location
+ccs              # Claude subscription (default)
+ccs glm          # GLM (no thinking)
+ccs glmt         # GLM with thinking
+ccs kimi         # Kimi for Coding
+ccs --version    # Show version
 ```
 
-### Concurrent Sessions (Multi-Account)
+### Multi-Account Setup
 ```bash
-# Create multiple Claude accounts
-ccs auth create work       # Company account
-ccs auth create personal   # Personal account
-ccs auth create team       # Team account
+# Create accounts
+ccs auth create work
+ccs auth create personal
 
-# Terminal 1 - Work account
+# Terminal 1
 ccs work "implement feature"
 
-# Terminal 2 - Personal account (runs concurrently)
+# Terminal 2 (concurrent)
 ccs personal "review code"
 ```
 
+### Custom Claude CLI Path
+
+Non-standard installation location:
+```bash
+export CCS_CLAUDE_PATH="/path/to/claude"              # Unix
+$env:CCS_CLAUDE_PATH = "D:\Tools\Claude\claude.exe"   # Windows
+```
+
+See [Troubleshooting Guide](./docs/en/troubleshooting.md#claude-cli-in-non-standard-location)
+
 ---
 
-### 🗑️ Uninstall
+## Configuration
+
+Auto-created during installation via npm postinstall script.
+
+**~/.ccs/config.json**:
+```json
+{
+  "profiles": {
+    "glm": "~/.ccs/glm.settings.json",
+    "glmt": "~/.ccs/glmt.settings.json",
+    "kimi": "~/.ccs/kimi.settings.json",
+    "default": "~/.claude/settings.json"
+  }
+}
+```
+
+Complete guide: [docs/en/configuration.md](./docs/en/configuration.md)
+
+---
+
+## Uninstall
 
 **Package Managers**
 ```bash
-# npm
 npm uninstall -g @kaitranntt/ccs
-
-# yarn
 yarn global remove @kaitranntt/ccs
-
-# pnpm
 pnpm remove -g @kaitranntt/ccs
-
-# bun
 bun remove -g @kaitranntt/ccs
 ```
 
 **Official Uninstaller**
-
-**macOS / Linux**
 ```bash
+# macOS / Linux
 curl -fsSL ccs.kaitran.ca/uninstall | bash
-```
 
-**Windows PowerShell**
-```powershell
+# Windows
 irm ccs.kaitran.ca/uninstall | iex
 ```
 
@@ -348,6 +375,7 @@ irm ccs.kaitran.ca/uninstall | iex
 - [Installation Guide](./docs/en/installation.md)
 - [Configuration](./docs/en/configuration.md)
 - [Usage Examples](./docs/en/usage.md)
+- [System Architecture](./docs/system-architecture.md)
 - [Troubleshooting](./docs/en/troubleshooting.md)
 - [Contributing](./CONTRIBUTING.md)
 

package/VERSION

@@ -1 +1 @@
-3.2.0
+3.4.0

package/bin/ccs.js

@@ -108,6 +108,8 @@ function handleHelpCommand() {
   console.log(colored('Model Switching:', 'cyan'));
   console.log(`  ${colored('ccs', 'yellow')}                         Use default Claude account`);
   console.log(`  ${colored('ccs glm', 'yellow')}                     Switch to GLM 4.6 model`);
+  console.log(`  ${colored('ccs glmt', 'yellow')}                    Switch to GLM with thinking mode`);
+  console.log(`  ${colored('ccs glmt --verbose', 'yellow')}          Enable debug logging`);
   console.log(`  ${colored('ccs kimi', 'yellow')}                    Switch to Kimi for Coding`);
   console.log(`  ${colored('ccs glm', 'yellow')} "debug this code"   Use GLM and run command`);
   console.log('');
@@ -212,6 +214,114 @@ function detectProfile(args) {
   }
 }
 
+// Execute Claude CLI with embedded proxy (for GLMT profile)
+async function execClaudeWithProxy(claudeCli, profileName, args) {
+  const { getSettingsPath } = require('./config-manager');
+
+  // 1. Read settings to get API key
+  const settingsPath = getSettingsPath(profileName);
+  const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+  const apiKey = settings.env.ANTHROPIC_AUTH_TOKEN;
+
+  if (!apiKey || apiKey === 'YOUR_GLM_API_KEY_HERE') {
+    console.error('[X] GLMT profile requires Z.AI API key');
+    console.error('    Edit ~/.ccs/glmt.settings.json and set ANTHROPIC_AUTH_TOKEN');
+    process.exit(1);
+  }
+
+  // Detect verbose flag
+  const verbose = args.includes('--verbose') || args.includes('-v');
+
+  // 2. Spawn embedded proxy with verbose flag
+  const proxyPath = path.join(__dirname, 'glmt-proxy.js');
+  const proxyArgs = verbose ? ['--verbose'] : [];
+  const proxy = spawn('node', [proxyPath, ...proxyArgs], {
+    stdio: ['ignore', 'pipe', verbose ? 'pipe' : 'inherit']
+  });
+
+  // 3. Wait for proxy ready signal (with timeout)
+  let port;
+  try {
+    port = await new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new Error('Proxy startup timeout (5s)'));
+      }, 5000);
+
+      proxy.stdout.on('data', (data) => {
+        const match = data.toString().match(/PROXY_READY:(\d+)/);
+        if (match) {
+          clearTimeout(timeout);
+          resolve(parseInt(match[1]));
+        }
+      });
+
+      proxy.on('error', (error) => {
+        clearTimeout(timeout);
+        reject(error);
+      });
+
+      proxy.on('exit', (code) => {
+        if (code !== 0 && code !== null) {
+          clearTimeout(timeout);
+          reject(new Error(`Proxy exited with code ${code}`));
+        }
+      });
+    });
+  } catch (error) {
+    console.error('[X] Failed to start GLMT proxy:', error.message);
+    console.error('');
+    console.error('Possible causes:');
+    console.error('  1. Port conflict (unlikely with random port)');
+    console.error('  2. Node.js permission issue');
+    console.error('  3. Firewall blocking localhost');
+    console.error('');
+    console.error('Workarounds:');
+    console.error('  - Use non-thinking mode: ccs glm "prompt"');
+    console.error('  - Enable verbose logging: ccs glmt --verbose "prompt"');
+    console.error('  - Check proxy logs in ~/.ccs/logs/ (if debug enabled)');
+    console.error('');
+    proxy.kill();
+    process.exit(1);
+  }
+
+  // 4. Spawn Claude CLI with proxy URL
+  const envVars = {
+    ...process.env,
+    ANTHROPIC_BASE_URL: `http://127.0.0.1:${port}`,
+    ANTHROPIC_AUTH_TOKEN: apiKey,
+    ANTHROPIC_MODEL: 'glm-4.6'
+  };
+
+  const claude = spawn(claudeCli, args, {
+    stdio: 'inherit',
+    env: envVars
+  });
+
+  // 5. Cleanup: kill proxy when Claude exits
+  claude.on('exit', (code, signal) => {
+    proxy.kill('SIGTERM');
+    if (signal) process.kill(process.pid, signal);
+    else process.exit(code || 0);
+  });
+
+  claude.on('error', (error) => {
+    console.error('[X] Claude CLI error:', error);
+    proxy.kill('SIGTERM');
+    process.exit(1);
+  });
+
+  // Also handle parent process termination (use .once to avoid duplicates)
+  process.once('SIGTERM', () => {
+    proxy.kill('SIGTERM');
+    claude.kill('SIGTERM');
+  });
+
+  process.once('SIGINT', () => {
+    proxy.kill('SIGTERM');
+    claude.kill('SIGTERM');
+  });
+}
+
 // Main execution
 async function main() {
   const args = process.argv.slice(2);
@@ -284,10 +394,16 @@ async function main() {
     const profileInfo = detector.detectProfileType(profile);
 
     if (profileInfo.type === 'settings') {
-      // EXISTING FLOW: Settings-based profile (glm, kimi)
-      // Use --settings flag (backward compatible)
-      const expandedSettingsPath = getSettingsPath(profileInfo.name);
-      execClaude(claudeCli, ['--settings', expandedSettingsPath, ...remainingArgs]);
+      // Check if this is GLMT profile (requires proxy)
+      if (profileInfo.name === 'glmt') {
+        // GLMT FLOW: Settings-based with embedded proxy for thinking support
+        await execClaudeWithProxy(claudeCli, profileInfo.name, remainingArgs);
+      } else {
+        // EXISTING FLOW: Settings-based profile (glm, kimi)
+        // Use --settings flag (backward compatible)
+        const expandedSettingsPath = getSettingsPath(profileInfo.name);
+        execClaude(claudeCli, ['--settings', expandedSettingsPath, ...remainingArgs]);
+      }
     } else if (profileInfo.type === 'account') {
       // NEW FLOW: Account-based profile (work, personal)
       // All platforms: Use instance isolation with CLAUDE_CONFIG_DIR

package/bin/delta-accumulator.js

@@ -0,0 +1,155 @@
+#!/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);
+ */
+class DeltaAccumulator {
+  constructor(thinkingConfig = {}, options = {}) {
+    this.thinkingConfig = thinkingConfig;
+    this.messageId = 'msg_' + Date.now() + '_' + Math.random().toString(36).substring(7);
+    this.model = null;
+    this.role = 'assistant';
+
+    // Content blocks
+    this.contentBlocks = [];
+    this.currentBlockIndex = -1;
+
+    // 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
+
+    // State flags
+    this.messageStarted = false;
+    this.finalized = false;
+
+    // Statistics
+    this.inputTokens = 0;
+    this.outputTokens = 0;
+    this.finishReason = null;
+  }
+
+  /**
+   * Get current content block
+   * @returns {Object|null} 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 {string} type - Block type ('thinking' or 'text')
+   * @returns {Object} 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
+    if (type === 'thinking') {
+      this.thinkingBuffer = '';
+    } else if (type === 'text') {
+      this.textBuffer = '';
+    }
+
+    return block;
+  }
+
+  /**
+   * Add delta to current block
+   * @param {string} delta - Content delta
+   */
+  addDelta(delta) {
+    const block = this.getCurrentBlock();
+    if (block) {
+      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;
+      } 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;
+    }
+  }
+
+  /**
+   * Update usage statistics
+   * @param {Object} 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;
+    }
+  }
+
+  /**
+   * Get summary of accumulated state
+   * @returns {Object} Summary
+   */
+  getSummary() {
+    return {
+      messageId: this.messageId,
+      model: this.model,
+      role: this.role,
+      blockCount: this.contentBlocks.length,
+      currentIndex: this.currentBlockIndex,
+      messageStarted: this.messageStarted,
+      finalized: this.finalized,
+      usage: {
+        input_tokens: this.inputTokens,
+        output_tokens: this.outputTokens
+      }
+    };
+  }
+}
+
+module.exports = DeltaAccumulator;