tiennm99/ccs
1
0 Fork 0
mirror of https://github.com/tiennm99/ccs.git synced 2026-10-13 08:15:17 +00:00
Code Issues Packages Projects Releases Wiki Activity

fix(tsconfig): remove duplicate compiler options

Browse Source 
- Remove duplicate allowSyntheticDefaultImports (lines 16 & 42)
- Remove duplicate skipLibCheck (lines 18 & 46)
- Add TypeScript source files for npm package migration
- Verify build pipeline works (42/42 tests pass)
This commit is contained in:
kaitranntt committed 2025-11-26 19:24:40 -05:00
1 parent fd8fec20d7
commit 77d026869e
37 files changed
+6813 -200
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

.gitignore
+4
View File
@@ -23,6 +23,10 @@ npm-debug.log*
yarn-debug.log*
yarn-error.log*
# TypeScript build output
dist/
*.tsbuildinfo
# Package lock files (keep package-lock.json but ignore others)
yarn.lock
pnpm-lock.yaml
docs/project-roadmap.md
+354 -191
View File
@@ -1,238 +1,401 @@
# CCS Project Roadmap
## Completed Features
## Project Overview
### v4.3.2 (Current - 2025-11-17)
- ✅ **AI-Powered Delegation**: Headless execution with stream-JSON output
- ✅ **Selective Symlinking**: Share .claude/ directories (commands, skills, agents)
- ✅ **Enhanced Shell Completion**: 4 shells, color-coded categories
- ✅ **Diagnostics Suite**: Doctor, sync, update commands
- ✅ **Session Continuation**: `:continue` support for follow-up tasks
- ✅ **Stream-JSON Parser**: Real-time tool tracking (13+ Claude Code tools)
CCS (Claude Code Switch) is a CLI wrapper for instant switching between multiple Claude accounts and alternative models (GLM, GLMT, Kimi). The project enables developers to maintain continuous productivity by running parallel workflows with different AI models, avoiding rate limits and context switching.
### v4.2.x (2025-11-16)
- ✅ **Doctor Command**: Comprehensive health validation
- ✅ **Sync Command**: Repair broken symlinks and directory structure
- ✅ **Update Checker**: Smart notifications for newer versions
- ✅ **Color-Coded Status**: [OK], [!], [X] indicators
- ✅ **Actionable Diagnostics**: Specific recommendations for issues
### Core Value Proposition
- **Zero Downtime**: Instant profile switching without breaking flow state
- **Cost Optimization**: 81% cost savings through intelligent delegation to GLM/Kimi
- **Parallel Workflows**: Strategic planning with Claude + cost-effective execution with GLM
- **Cross-Platform**: Unified experience on macOS, Linux, and Windows
### v4.1.x (2025-11-15)
- ✅ **.claude/ Directory Symlinking**: Selective sharing with isolation
- ✅ **Stream-JSON Output**: Real-time delegation tool tracking
- ✅ **Shell Completion v2**: Enhanced with color-coded categories
- ✅ **Windows Fallback**: Directory copying when symlinks unavailable
- ✅ **Kimi API Fixes**: 401 error handling improvements
## Current Status
### v4.0.x (2025-11-14)
- ✅ **Delegation System**: Initial AI-powered task delegation
- ✅ **Headless Execution**: `-p` flag for prompt-based execution
- ✅ **Cost Tracking**: USD cost display per delegation
- ✅ **Session Management**: Save session IDs for continuation
- ✅ **Result Formatting**: Cost, duration, exit code display
### Version Information
- **Current Version**: 4.4.0
- **Release Status**: TypeScript conversion complete
- **Build Status**: ✅ Working (npm run build → dist/ccs.js)
- **Test Status**: ✅ All tests passing
- **Cross-Platform**: ✅ Windows/macOS/Linux
### v3.x (Historical)
- ✅ **Vault Removal** (v3.0): Login-per-profile model
- ✅ **GLMT Thinking Mode** (v3.2-v3.6): Experimental GLM reasoning support
- ✅ **Platform Parity** (v3.0): Unified macOS/Linux/Windows behavior
- ✅ **Shared Data Architecture** (v3.1): Early .claude/ sharing
- ✅ **Concurrent Sessions** (v3.2): CLAUDE_CONFIG_DIR support
### TypeScript Conversion Summary
### v2.x (Historical)
- ✅ **Vault-Based Encryption**: AES-256-GCM credential storage
- ✅ **Multi-Account Management**: Multiple Claude accounts
- ✅ **Profile Switching**: Instant model changes
- ✅ **Initial Architecture**: Foundation for CCS
**✅ Conversion Completed: 100% (31/31 files)**
## Active Development (v4.4-v4.5)
The CCS project has been fully converted from JavaScript to TypeScript, delivering enhanced type safety, improved developer experience, and better maintainability.
### High Priority
1. **Delegation Improvements**
- MCP tool integration for delegation workflow
- SQLite session storage for better query capabilities
- Pluggable result formatters (JSON, CSV, table)
- Enhanced error handling and retry logic
- Cost estimation before execution
**Migration Statistics**:
- **Source Files**: 31 TypeScript files converted
- **Lines of Code**: 6,279 lines of TypeScript code
- **Type Coverage**: 100% with zero `any` types
- **Build System**: Full TypeScript compilation pipeline
- **Type Definitions**: Comprehensive type definitions in `src/types/`
2. **Performance Optimization**
- Model selection based on task complexity analysis
- Cost-aware delegation routing (glm vs kimi vs claude)
- Caching for frequently used delegation tasks
- Parallel delegation support (multiple tasks)
**Converted Components**:
- ✅ **Core System** (`src/ccs.ts`) - Main entry point
- ✅ **Authentication** (`src/auth/`) - Profile management and commands
- ✅ **Delegation** (`src/delegation/`) - AI-powered task delegation system
- ✅ **GLMT** (`src/glmt/`) - GLM with Thinking support
- ✅ **Management** (`src/management/`) - System diagnostics and instance management
- ✅ **Utils** (`src/utils/`) - Cross-platform utilities and helpers
- ✅ **Types** (`src/types/`) - Complete type definitions
3. **Documentation**
- Video tutorials for delegation workflows
- Interactive setup wizard for API keys
- Migration guides (v3.x → v4.x tips)
- Troubleshooting expansion (common errors)
## Recent Achievements
### Medium Priority
1. **Enhanced Diagnostics**
- Automated troubleshooting recommendations
- Performance profiling integration
- Log analysis tools
- Health score dashboard
### TypeScript Conversion Benefits (v4.4.0)
2. **Testing Expansion**
- End-to-end delegation tests
- Cross-platform CI/CD (macOS, Linux, Windows)
- Integration tests for symlinking
- Performance regression tests
#### Type Safety & Reliability
- **Zero `any` types**: Complete type coverage across the entire codebase
- **Compile-time error detection**: Catches bugs before runtime
- **Interface contracts**: Clear API boundaries and data structures
- **Exhaustive type checking**: Eliminates entire classes of common errors
3. **Developer Experience**
- Better error messages for delegation failures
- Progress bars for long-running delegations
- Delegation history browsing (`ccs history`)
- Session replay capability
#### Enhanced Developer Experience
- **IDE support**: Full IntelliSense autocomplete and navigation
- **Refactoring safety**: Type-safe code modifications and renames
- **Self-documenting code**: Type definitions serve as living documentation
- **Better debugging**: Clear type information in debuggers and stack traces
### Low Priority
1. **UI Improvements**
- Optional TUI for profile management
- Web dashboard for session history
- Visual delegation flow diagrams
#### Maintainability Improvements
- **Code navigation**: Easy "go to definition" across the entire codebase
- **Impact analysis**: Clear understanding of where types are used
- **API documentation**: Types define precise interfaces for all components
- **Future-proofing**: Easier to add new features without breaking existing code
2. **Configuration Enhancements**
- Profile templates (copy settings from existing)
- Bulk profile operations
- Export/import profiles
#### Architecture Enhancements
- **Modular type system**: Comprehensive type definitions in `src/types/`
- **Strict configuration**: TypeScript strict mode enabled for maximum safety
- **Build pipeline**: Automated compilation with source maps and declarations
- **Cross-platform consistency**: Types ensure consistent behavior across platforms
### Configuration Architecture Improvements
- **Shared Settings**: v4.4 introduces unified `settings.json` sharing across profiles
- **Plugin Support**: Enhanced shared directory structure with plugin support
- **Error Handling**: Improved error management with typed error codes
- **Shell Completion**: PowerShell compatibility improvements
## Current Architecture
### Updated Architecture Diagram
```mermaid
%%{init: {'theme': 'base', 'themeVariables': { 'primaryColor': '#1f2937', 'edgeLabelBackground':'#374151', 'clusterBkg':'#374151'}}}%%
graph TB
subgraph "TypeScript Source Layer"
MAIN[src/ccs.ts - Main Entry]
AUTH[src/auth/ - Authentication]
DELEGATE[src/delegation/ - AI Delegation]
GLMT[src/glmt/ - GLM Thinking]
MGMT[src/management/ - System Mgmt]
UTILS[src/utils/ - Cross-Platform Utils]
TYPES[src/types/ - Type Definitions]
end
subgraph "Build Output Layer"
DIST[dist/ccs.js - Compiled Output]
DECL[dist/ccs.d.ts - Type Declarations]
MAP[dist/ccs.js.map - Source Maps]
end
subgraph "Native Integration Layer"
BASH[lib/ccs - Bash Implementation]
PS[lib/ccs.ps1 - PowerShell Implementation]
SHELLS[Shell Completion Scripts]
end
subgraph "Runtime Environment"
CLAUDE[Claude CLI]
CONFIG[Configuration Files]
SHARED[~/.ccs/shared/]
INSTANCES[Isolated Instances]
end
MAIN --> DIST
AUTH --> DIST
DELEGATE --> DIST
GLMT --> DIST
MGMT --> DIST
UTILS --> DIST
TYPES --> DECL
DIST --> CLAUDE
BASH --> CLAUDE
PS --> CLAUDE
SHELLS --> CLAUDE
CONFIG --> CLAUDE
SHARED --> CLAUDE
INSTANCES --> CLAUDE
```
### TypeScript Architecture Benefits
#### Type System Organization
```
src/types/
├── cli.ts # CLI interface definitions
├── config.ts # Configuration type schemas
├── delegation.ts # Delegation system types
├── glmt.ts # GLMT-specific types
├── utils.ts # Utility function types
└── index.ts # Central type exports
```
#### Component Type Safety
- **Authentication**: Type-safe profile management and command execution
- **Delegation**: Structured delegation workflows with typed result handling
- **GLMT**: Type-safe transformation pipelines and proxy management
- **Management**: Typed diagnostics and instance management
- **Utils**: Cross-platform utilities with consistent interfaces
#### Build Pipeline
- **TypeScript Compiler**: `tsc` with strict configuration and comprehensive checks
- **Declaration Generation**: Automatic `.d.ts` file generation for API documentation
- **Source Maps**: Debug-friendly mapping back to TypeScript source files
- **Incremental Builds**: Fast rebuilds with TypeScript incremental compilation
## Development Roadmap
### Next Development Phases
#### Phase 1: TypeScript Foundation Stabilization (v4.4.1 - v4.4.5)
**Timeline**: Immediate - 4 weeks
**Priorities**:
1. **Type System Refinement**
- Migrate remaining `any` types (target: zero any types)
- Add generic constraints for better type inference
- Implement branded types for enhanced type safety
- Create utility types for common patterns
2. **Build System Enhancement**
- Add TypeScript ESLint with strict rules
- Implement pre-commit type checking
- Add automated type coverage reporting
- Enhance development build performance
3. **Testing Infrastructure**
- Migrate tests to TypeScript
- Add type-safe test utilities
- Implement mock type definitions
- Create type-safe test data fixtures
#### Phase 2: Advanced Delegation System (v4.5.0)
**Timeline**: 1-2 months
**TypeScript-Driven Features**:
1. **Smart Delegation Routing**
- Type-based task classification system
- Intelligent profile selection algorithms
- Cost estimation with typed calculation models
- Performance optimization through type-aware caching
2. **Enhanced Session Management**
- Type-safe session persistence with serialization
- Advanced session resumption with state restoration
- Multi-turn conversation context management
- Session analytics with typed metrics
3. **Plugin System Foundation**
- Type-safe plugin API definitions
- Plugin discovery and registration system
- Sandboxed plugin execution environment
- Community plugin marketplace infrastructure
#### Phase 3: Enterprise Features (v4.6.0)
**Timeline**: 2-3 months
**Enterprise-Grade TypeScript Features**:
1. **Team Profile Management**
- Type-safe role-based access control (RBAC)
- Centralized configuration management
- Audit logging with typed event structures
- Compliance reporting with structured data formats
2. **Advanced Analytics Dashboard**
- Real-time usage metrics with typed data streams
- Cost tracking and budgeting with financial types
- Team productivity analytics with KPI types
- Performance monitoring with alert types
3. **CI/CD Integration**
- Type-safe GitHub Actions workflows
- Automated testing with type validation
- Deployment pipelines with type checks
- Infrastructure as Code with TypeScript
### Technical Debt Resolution
#### Immediate Priorities (v4.4.1)
1. **GLMT System Refactoring**
- Transform GLMT proxy with typed request/response handling
- Implement type-safe SSE parsing with error recovery
- Add typed transformation pipelines for API compatibility
- Create comprehensive GLMT test suites with type safety
2. **Error Handling Enhancement**
- Implement typed error hierarchies with inheritance
- Create structured error reporting with localization
- Add automatic error recovery with typed retry logic
- Develop error analytics with classification systems
3. **Performance Optimization**
- Profile and optimize hot paths with typed benchmarks
- Implement memory-efficient data structures with generics
- Add lazy loading patterns with type-safe initialization
- Create performance monitoring with typed metrics
#### Medium-term Improvements (v4.5.0)
1. **Cross-Platform Consistency**
- Unify behavior across platforms with typed abstractions
- Implement platform-specific optimizations with type guards
- Create comprehensive cross-platform test suites
- Add platform-specific feature detection
2. **API Evolution**
- Design backward-compatible API evolution strategies
- Implement API versioning with type migration paths
- Create deprecation warnings with upgrade guidance
- Add automated API compatibility testing
## Future Vision (v5.0+)
### Long-term Goals
### Next-Generation Architecture
#### AI-Powered Features
1. **Automatic Task Classification**
- Analyze prompt to suggest best model (glm, kimi, claude)
- Estimate cost and duration before execution
- Smart profile recommendations
#### AI-Powered TypeScript Development
1. **Intelligent Code Generation**
- TypeScript-aware AI code completion
- Automatic type inference from usage patterns
- Smart refactoring suggestions with type analysis
- Code quality recommendations based on type metrics
2. **Intelligent Model Selection**
- Context-aware routing (task complexity → model)
- Cost optimization strategies
- Performance-based model selection
2. **Adaptive Type System**
- Dynamic type generation based on runtime behavior
- Machine learning-assisted type predictions
- Automatic interface extraction from APIs
- Smart type narrowing with statistical analysis
3. **Context-Aware Delegation**
- Understand project context from git history
- Suggest relevant delegation tasks
- Learn from past delegation patterns
#### Enterprise TypeScript Platform
1. **Advanced Team Collaboration**
- Real-time collaborative TypeScript editing
- Shared type libraries across projects
- Automated type governance policies
- Team-wide type consistency enforcement
#### Enterprise Features
1. **Team Profile Sharing**
- Centralized profile repository
- Team-wide API key management
- Access control and permissions
2. **Comprehensive Analytics**
- Type usage analytics and optimization recommendations
- Code quality metrics with type safety scores
- Developer productivity tracking with type metrics
- Technical debt measurement with type analysis
2. **Usage Analytics Dashboard**
- Delegation statistics and trends
- Cost tracking and budgeting
- Team productivity metrics
#### Ecosystem Integration
1. **Package Management**
- Type-safe dependency management
- Automated vulnerability scanning with type analysis
- Smart version resolution with compatibility checking
- Package quality assessment with type metrics
3. **Centralized Configuration Management**
- Cloud-based config synchronization
- Multi-machine profile sync
- Backup and restore
2. **Tool Integration**
- TypeScript-native IDE extensions
- Enhanced debugging with type information
- Performance profiling with type insights
- Automated testing with type-driven test generation
#### Ecosystem Expansion
1. **Plugin System for Custom Models**
- Plugin API for third-party model integration
- Community plugin marketplace
- Custom transformation pipelines
## Release Notes
2. **CI/CD Pipeline Integration**
- GitHub Actions integration
- GitLab CI integration
- Automated delegation in workflows
### Version 4.4.0 - TypeScript Conversion Complete
**Release Date**: 2025-11-25
3. **Cloud-Based Session Synchronization**
- Session history across machines
- Collaborative delegation sessions
- Team delegation sharing
#### Major Features
- ✅ **Complete TypeScript Conversion**: All 31 source files migrated to TypeScript
- ✅ **Zero `any` Types**: 100% type coverage with comprehensive type definitions
- ✅ **Enhanced Build Pipeline**: Automated compilation with source maps and declarations
- ✅ **Shared Settings Architecture**: Unified `settings.json` across all profiles
- ✅ **Plugin Support**: Enhanced shared directory structure
## Deprecated Features
#### Technical Improvements
- **Type Safety**: Compile-time error detection eliminates entire bug categories
- **Developer Experience**: Full IDE support with IntelliSense and navigation
- **Maintainability**: Self-documenting code with comprehensive type definitions
- **Cross-Platform**: Typed abstractions ensure consistent behavior
### Removed in v3.0
- ❌ **Vault-Based Credential Encryption**: Replaced with login-per-profile
- ❌ **`ccs auth save` command**: Replaced with `ccs auth create`
- ❌ **macOS-Specific Credential Switcher**: Unified across platforms
#### Breaking Changes
- **None**: Fully backward compatible with existing configurations
- **Migration**: Seamless upgrade path with zero user impact
### Removed in v2.x
- ❌ **Early profile management**: Replaced with more robust system
#### Dependencies
- **TypeScript 5.3**: Updated to latest stable version
- **Enhanced Build Process**: Automated compilation and type checking
- **Development Tools**: Improved development tooling and debugging
## Experimental Features
### Recent Patch Updates
- **v4.3.10**: Package manager cache clearing during updates
- **v4.3.9**: Fixed missing `commands/ccs.md` symlink in npm install
- **v4.3.8**: Resolved missing `~/.ccs/.claude/` directory creation
- **v4.3.7**: Enhanced directory creation during npm install
- **v4.3.6**: Added plugin support to shared directories
- **v4.4.0**: TypeScript conversion complete, shared settings architecture
### GLMT (Stable Experimental)
- **Status**: Maintained but not actively developed
- **Version**: v3.2-v3.6 (frozen)
- **Limitations**:
- Unstable tool support
- Streaming issues
- Language forcing required (locale-enforcer)
- **Alternative**: Use ZaiTransformer for production GLMT
- **Future**: May be deprecated in v5.0 if Z.AI improves native support
## Testing Strategy
### Stream-JSON Parsing (Active)
- **Status**: Actively developed in v4.x
- **Version**: v4.0-v4.3.2
- **Current State**: Stable for 13+ Claude Code tools
- **Future**: Expand tool support, improve parsing reliability
### TypeScript Testing Infrastructure
1. **Unit Testing with Type Safety**
- Mocha tests with TypeScript compilation
- Type-safe test utilities and fixtures
- Mock implementations with interface compliance
- Coverage reporting with type metrics
## Version History
2. **Integration Testing**
- Cross-platform compatibility validation
- End-to-end workflow testing with typed data
- API contract testing with type validation
- Performance testing with type-aware profiling
| Version | Date | Key Features |
|---------|------|--------------|
| **v4.3.2** | 2025-11-17 | Session continuation, stream-JSON enhancements |
| **v4.2.0** | 2025-11-16 | Diagnostics suite (doctor, sync, update) |
| **v4.1.4** | 2025-11-15 | Shell completion v2 with color-coding |
| **v4.1.0** | 2025-11-15 | Selective .claude/ symlinking |
| **v4.0.0** | 2025-11-14 | AI delegation system, headless execution |
| **v3.6.x** | 2025-XX-XX | GLMT loop detection, locale enforcer |
| **v3.3.0** | 2025-XX-XX | GLMT thinking mode, debug logging |
| **v3.2.0** | 2025-XX-XX | GLMT proxy, concurrent sessions |
| **v3.1.0** | 2025-XX-XX | Shared data architecture |
| **v3.0.0** | 2025-XX-XX | Vault removal, login-per-profile |
| **v2.x** | 2024-XX-XX | Multi-account management, vault encryption |
3. **Type-Level Testing**
- TypeScript compiler error verification
- Type coverage measurement and reporting
- API surface validation with type checking
- Dependency graph analysis with type relationships
## Breaking Changes
## Quality Assurance
### v4.x → v5.0 (Planned)
- **Potential**: GLMT removal if Z.AI improves
- **Potential**: Configuration schema changes for enterprise features
- **Migration**: Migration tools will be provided
### TypeScript Quality Metrics
- **Type Coverage**: 100% (target: maintain zero any types)
- **Compiler Strictness**: Maximum strict mode configuration
- **Interface Compliance**: All exports properly typed
- **Documentation Coverage**: Type definitions serve as documentation
### v3.x → v4.x
- **Zero Breaking Changes**: Fully backward compatible
- **New Features**: Delegation, symlinking, diagnostics (opt-in)
- **Migration**: No migration required
### v2.x → v3.0
- **Breaking**: `ccs auth save` → `ccs auth create`
- **Breaking**: Profile schema change (vault removed)
- **Breaking**: Removed `auth current`, `auth cleanup` commands
- **Migration**: Manual profile recreation required
## Roadmap Decision Process
### Feature Prioritization
1. **User Impact**: Features most requested by users
2. **Technical Debt**: Addressing long-standing issues
3. **Strategic Alignment**: Moving toward v5.0 vision
4. **Resource Availability**: Development capacity
### Version Planning
- **Patch (x.x.X)**: Bug fixes, small improvements
- **Minor (x.X.0)**: New features, backward compatible
- **Major (X.0.0)**: Breaking changes, major overhaul
### Code Quality Standards
- **ESLint Integration**: TypeScript-specific linting rules
- **Pre-commit Hooks**: Automated type checking before commits
- **CI/CD Pipeline**: Type validation in continuous integration
- **Code Review**: Type safety as review requirement
## Contributing to Roadmap
Community input is welcome. To suggest features:
1. Open GitHub issue with `[Feature Request]` tag
2. Describe use case and expected behavior
3. Provide examples or mockups if applicable
4. Discuss trade-offs and alternatives
### TypeScript Development Guidelines
1. **Type-First Development**: Define types before implementation
2. **Zero Any Policy**: Maintain 100% type coverage
3. **Interface Documentation**: Comprehensive JSDoc with type examples
4. **Backward Compatibility**: Evolve APIs without breaking changes
**Current Focus**: v4.4-v4.5 delegation improvements and performance optimization
### Feature Contribution Process
1. **Type Design**: Submit type definitions for review
2. **Implementation**: Type-safe implementation with comprehensive tests
3. **Documentation**: Update type documentation and examples
4. **Review**: Peer review focused on type safety and API design
## Community and Ecosystem
### TypeScript Community Engagement
- **TypeScript Best Practices**: Share learnings with TypeScript community
- **Open Source Contribution**: Contribute to TypeScript tooling ecosystem
- **Knowledge Sharing**: Document TypeScript migration experience
- **Community Support**: Help other projects with TypeScript adoption
---
**Last Updated**: 2025-11-21 (v4.3.2)
**Document Status**: Living document, updated with each major release
**Last Updated**: 2025-11-25 (v4.4.0 - TypeScript Conversion Complete)
**Next Update**: v4.5.0 roadmap specification
**Maintainer**: CCS Development Team
package-lock.json
Generated
+36 -3
View File
@@ -1,12 +1,12 @@
{
"name": "@kaitranntt/ccs",
"version": "4.3.7",
"version": "4.4.0",
"lockfileVersion": 3,
"requires": true,
"packages": {
"": {
"name": "@kaitranntt/ccs",
"version": "4.3.7",
"version": "4.4.0",
"hasInstallScript": true,
"license": "MIT",
"os": [
@@ -22,7 +22,9 @@
"ccs": "bin/ccs.js"
},
"devDependencies": {
"mocha": "^11.7.5"
"@types/node": "^20.19.25",
"mocha": "^11.7.5",
"typescript": "5.3"
},
"engines": {
"node": ">=14.0.0"
@@ -67,6 +69,16 @@
"node": ">=14"
}
},
"node_modules/@types/node": {
"version": "20.19.25",
"resolved": "https://registry.npmjs.org/@types/node/-/node-20.19.25.tgz",
"integrity": "sha512-ZsJzA5thDQMSQO788d7IocwwQbI8B5OPzmqNvpf3NY/+MHDAS759Wo0gd2WQeXYt5AAAQjzcrTVC6SKCuYgoCQ==",
"dev": true,
"license": "MIT",
"dependencies": {
"undici-types": "~6.21.0"
}
},
"node_modules/ansi-regex": {
"version": "6.2.2",
"resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.2.2.tgz",
@@ -1215,6 +1227,27 @@
"url": "https://github.com/chalk/supports-color?sponsor=1"
}
},
"node_modules/typescript": {
"version": "5.3.3",
"resolved": "https://registry.npmjs.org/typescript/-/typescript-5.3.3.tgz",
"integrity": "sha512-pXWcraxM0uxAS+tN0AG/BF2TyqmHO014Z070UsJ+pFvYuRSq8KH8DmWpnbXe0pEPDHXZV3FcAbJkijJ5oNEnWw==",
"dev": true,
"license": "Apache-2.0",
"bin": {
"tsc": "bin/tsc",
"tsserver": "bin/tsserver"
},
"engines": {
"node": ">=14.17"
}
},
"node_modules/undici-types": {
"version": "6.21.0",
"resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz",
"integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",
"dev": true,
"license": "MIT"
},
"node_modules/which": {
"version": "2.0.2",
"resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
package.json
+13 -6
View File
@@ -23,11 +23,13 @@
"name": "Tam Nhu Tran (Kai)",
"email": "kaitranntt@users.noreply.github.com"
},
"main": "dist/ccs.js",
"types": "dist/ccs.d.ts",
"bin": {
"ccs": "bin/ccs.js"
"ccs": "dist/ccs.js"
},
"files": [
"bin/",
"dist/",
"lib/",
"scripts/",
"config/",
@@ -46,14 +48,17 @@
],
"preferGlobal": true,
"scripts": {
"test": "npm run test:all",
"build": "tsc && node scripts/add-shebang.js",
"build:watch": "tsc --watch",
"prebuild": "rm -rf dist",
"test": "npm run build && npm run test:all",
"test:all": "npm run test:unit && npm run test:npm",
"test:unit": "npx mocha tests/shared/unit/**/*.test.js --timeout 5000",
"test:npm": "npx mocha tests/npm/**/*.test.js --timeout 10000",
"test:native": "bash tests/native/unix/edge-cases.sh",
"test:edge-cases": "bash tests/edge-cases.sh",
"prepublishOnly": "node scripts/sync-version.js",
"prepack": "node scripts/sync-version.js",
"prepublishOnly": "npm run build && node scripts/sync-version.js",
"prepack": "npm run build && node scripts/sync-version.js",
"prepare": "node scripts/check-executables.js",
"postinstall": "node scripts/postinstall.js"
},
@@ -62,6 +67,8 @@
"ora": "^9.0.0"
},
"devDependencies": {
"mocha": "^11.7.5"
"@types/node": "^20.19.25",
"mocha": "^11.7.5",
"typescript": "5.3"
}
}
scripts/add-shebang.js
Executable
+39
View File
@@ -0,0 +1,39 @@
#!/usr/bin/env node
'use strict';
const fs = require('fs');
const path = require('path');
/**
* Add shebang to dist/ccs.js and make executable
* Run after: tsc
*/
function addShebang() {
const ccsPath = path.join(__dirname, '../dist/ccs.js');
if (!fs.existsSync(ccsPath)) {
console.error('[X] dist/ccs.js not found. Run tsc first.');
process.exit(1);
}
let content = fs.readFileSync(ccsPath, 'utf8');
// Add shebang if missing
if (!content.startsWith('#!/usr/bin/env node')) {
content = '#!/usr/bin/env node\n' + content;
fs.writeFileSync(ccsPath, content);
console.log('[OK] Shebang added to dist/ccs.js');
}
// Make executable (Unix-like systems)
if (process.platform !== 'win32') {
try {
fs.chmodSync(ccsPath, 0o755);
console.log('[OK] dist/ccs.js is now executable');
} catch (err) {
console.warn('[!] Could not chmod dist/ccs.js:', err.message);
}
}
}
addShebang();
src/auth/auth-commands.ts
+533
View File
@@ -0,0 +1,533 @@
/**
* Auth Commands (Simplified)
*
* CLI interface for CCS multi-account management.
* Commands: create, list, show, remove, default
*
* Login-per-profile model: Each profile is an isolated Claude instance.
* Users login directly in each instance (no credential copying).
*/
import { spawn, ChildProcess } from 'child_process';
import * as fs from 'fs';
import * as path from 'path';
import ProfileRegistry from './profile-registry';
import { InstanceManager } from '../management/instance-manager';
import { colored } from '../utils/helpers';
import { detectClaudeCli } from '../utils/claude-detector';
import { InteractivePrompt } from '../utils/prompt';
import packageJson from '../../package.json';
interface AuthCommandArgs {
profileName?: string;
force?: boolean;
verbose?: boolean;
json?: boolean;
yes?: boolean;
}
interface ProfileOutput {
name: string;
type: string;
is_default: boolean;
created: string;
last_used: string | null;
instance_path?: string;
session_count?: number;
}
interface ListOutput {
version: string;
profiles: ProfileOutput[];
}
/**
* Auth Commands Class
*/
class AuthCommands {
private registry: ProfileRegistry;
private instanceMgr: InstanceManager;
private readonly version: string = packageJson.version;
constructor() {
this.registry = new ProfileRegistry();
this.instanceMgr = new InstanceManager();
}
/**
* Show help for auth commands
*/
showHelp(): void {
console.log(colored('CCS Concurrent Account Management', 'bold'));
console.log('');
console.log(colored('Usage:', 'cyan'));
console.log(` ${colored('ccs auth', 'yellow')} <command> [options]`);
console.log('');
console.log(colored('Commands:', 'cyan'));
console.log(` ${colored('create <profile>', 'yellow')} Create new profile and login`);
console.log(` ${colored('list', 'yellow')} List all saved profiles`);
console.log(` ${colored('show <profile>', 'yellow')} Show profile details`);
console.log(` ${colored('remove <profile>', 'yellow')} Remove saved profile`);
console.log(` ${colored('default <profile>', 'yellow')} Set default profile`);
console.log('');
console.log(colored('Examples:', 'cyan'));
console.log(` ${colored('ccs auth create work', 'yellow')} # Create & login to work profile`);
console.log(` ${colored('ccs auth default work', 'yellow')} # Set work as default`);
console.log(` ${colored('ccs auth list', 'yellow')} # List all profiles`);
console.log(` ${colored('ccs work "review code"', 'yellow')} # Use work profile`);
console.log(` ${colored('ccs "review code"', 'yellow')} # Use default profile`);
console.log('');
console.log(colored('Options:', 'cyan'));
console.log(` ${colored('--force', 'yellow')} Allow overwriting existing profile (create)`);
console.log(` ${colored('--yes, -y', 'yellow')} Skip confirmation prompts (remove)`);
console.log(` ${colored('--json', 'yellow')} Output in JSON format (list, show)`);
console.log(` ${colored('--verbose', 'yellow')} Show additional details (list)`);
console.log('');
console.log(colored('Note:', 'cyan'));
console.log(` By default, ${colored('ccs', 'yellow')} uses Claude CLI defaults from ~/.claude/`);
console.log(` Use ${colored('ccs auth default <profile>', 'yellow')} to change the default profile.`);
console.log('');
}
/**
* Parse command arguments
*/
private parseArgs(args: string[]): AuthCommandArgs {
const profileName = args.find(arg => !arg.startsWith('--'));
return {
profileName,
force: args.includes('--force'),
verbose: args.includes('--verbose'),
json: args.includes('--json'),
yes: args.includes('--yes') || args.includes('-y')
};
}
/**
* Create new profile and prompt for login
*/
async handleCreate(args: string[]): Promise<void> {
const { profileName, force } = this.parseArgs(args);
if (!profileName) {
console.error('[X] Profile name is required');
console.log('');
console.log(`Usage: ${colored('ccs auth create <profile> [--force]', 'yellow')}`);
console.log('');
console.log('Example:');
console.log(` ${colored('ccs auth create work', 'yellow')}`);
process.exit(1);
}
// Check if profile already exists
if (!force && this.registry.hasProfile(profileName)) {
console.error(`[X] Profile already exists: ${profileName}`);
console.log(` Use ${colored('--force', 'yellow')} to overwrite`);
process.exit(1);
}
try {
// Create instance directory
console.log(`[i] Creating profile: ${profileName}`);
const instancePath = this.instanceMgr.ensureInstance(profileName);
// Create/update profile entry
if (this.registry.hasProfile(profileName)) {
this.registry.updateProfile(profileName, {
type: 'account'
});
} else {
this.registry.createProfile(profileName, {
type: 'account'
});
}
console.log(`[i] Instance directory: ${instancePath}`);
console.log('');
console.log(colored('[i] Starting Claude in isolated instance...', 'yellow'));
console.log(colored('[i] You will be prompted to login with your account.', 'yellow'));
console.log('');
// Detect Claude CLI
const claudeCli = detectClaudeCli();
if (!claudeCli) {
console.error('[X] Claude CLI not found');
console.log('');
console.log('Please install Claude CLI first:');
console.log(' https://claude.ai/download');
process.exit(1);
}
// Execute Claude in isolated instance (will auto-prompt for login if no credentials)
const child: ChildProcess = spawn(claudeCli, [], {
stdio: 'inherit',
env: { ...process.env, CLAUDE_CONFIG_DIR: instancePath }
});
child.on('exit', (code: number | null) => {
if (code === 0) {
console.log('');
console.log(colored('[OK] Profile created successfully', 'green'));
console.log('');
console.log(` Profile: ${profileName}`);
console.log(` Instance: ${instancePath}`);
console.log('');
console.log('Usage:');
console.log(` ${colored(`ccs ${profileName} "your prompt here"`, 'yellow')} # Use this specific profile`);
console.log('');
console.log('To set as default (so you can use just "ccs"):');
console.log(` ${colored(`ccs auth default ${profileName}`, 'yellow')}`);
console.log('');
process.exit(0);
} else {
console.log('');
console.error('[X] Login failed or cancelled');
console.log('');
console.log('To retry:');
console.log(` ${colored(`ccs auth create ${profileName} --force`, 'yellow')}`);
console.log('');
process.exit(1);
}
});
child.on('error', (err: Error) => {
console.error(`[X] Failed to execute Claude CLI: ${err.message}`);
process.exit(1);
});
} catch (error) {
console.error(`[X] Failed to create profile: ${(error as Error).message}`);
process.exit(1);
}
}
/**
* List all saved profiles
*/
async handleList(args: string[]): Promise<void> {
const { verbose, json } = this.parseArgs(args);
try {
const profiles = this.registry.getAllProfiles();
const defaultProfile = this.registry.getDefaultProfile();
const profileNames = Object.keys(profiles);
// JSON output mode
if (json) {
const output: ListOutput = {
version: this.version,
profiles: profileNames.map(name => {
const profile = profiles[name];
const isDefault = name === defaultProfile;
const instancePath = this.instanceMgr.getInstancePath(name);
return {
name: name,
type: profile.type || 'account',
is_default: isDefault,
created: profile.created,
last_used: profile.last_used || null,
instance_path: instancePath
};
})
};
console.log(JSON.stringify(output, null, 2));
return;
}
// Human-readable output
if (profileNames.length === 0) {
console.log(colored('No account profiles found', 'yellow'));
console.log('');
console.log('To create your first profile:');
console.log(` ${colored('ccs auth create <profile>', 'yellow')} # Create and login to profile`);
console.log('');
console.log('Example:');
console.log(` ${colored('ccs auth create work', 'yellow')}`);
console.log('');
return;
}
console.log(colored('Saved Account Profiles:', 'bold'));
console.log('');
// Sort by last_used (descending), then alphabetically
const sorted = profileNames.sort((a, b) => {
const aProfile = profiles[a];
const bProfile = profiles[b];
// Default first
if (a === defaultProfile) return -1;
if (b === defaultProfile) return 1;
// Then by last_used
if (aProfile.last_used && bProfile.last_used) {
return new Date(bProfile.last_used).getTime() - new Date(aProfile.last_used).getTime();
}
if (aProfile.last_used) return -1;
if (bProfile.last_used) return 1;
// Then alphabetically
return a.localeCompare(b);
});
sorted.forEach(name => {
const profile = profiles[name];
const isDefault = name === defaultProfile;
const indicator = isDefault ? colored('[*]', 'green') : '[ ]';
console.log(`${indicator} ${colored(name, 'cyan')}${isDefault ? colored(' (default)', 'green') : ''}`);
console.log(` Type: ${profile.type || 'account'}`);
if (verbose) {
console.log(` Created: ${new Date(profile.created).toLocaleString()}`);
if (profile.last_used) {
console.log(` Last used: ${new Date(profile.last_used).toLocaleString()}`);
}
}
console.log('');
});
console.log(`Total profiles: ${profileNames.length}`);
console.log('');
} catch (error) {
console.error(`[X] Failed to list profiles: ${(error as Error).message}`);
process.exit(1);
}
}
/**
* Show details for a specific profile
*/
async handleShow(args: string[]): Promise<void> {
const { profileName, json } = this.parseArgs(args);
if (!profileName) {
console.error('[X] Profile name is required');
console.log('');
console.log(`Usage: ${colored('ccs auth show <profile> [--json]', 'yellow')}`);
process.exit(1);
}
try {
const profile = this.registry.getProfile(profileName);
const defaultProfile = this.registry.getDefaultProfile();
const isDefault = profileName === defaultProfile;
const instancePath = this.instanceMgr.getInstancePath(profileName);
// Count sessions
let sessionCount = 0;
try {
const sessionsDir = path.join(instancePath, 'session-env');
if (fs.existsSync(sessionsDir)) {
const files = fs.readdirSync(sessionsDir);
sessionCount = files.filter(f => f.endsWith('.json')).length;
}
} catch (e) {
// Ignore errors counting sessions
}
// JSON output mode
if (json) {
const output: ProfileOutput = {
name: profileName,
type: profile.type || 'account',
is_default: isDefault,
created: profile.created,
last_used: profile.last_used || null,
instance_path: instancePath,
session_count: sessionCount
};
console.log(JSON.stringify(output, null, 2));
return;
}
// Human-readable output
console.log(colored(`Profile: ${profileName}`, 'bold'));
console.log('');
console.log(` Type: ${profile.type || 'account'}`);
console.log(` Default: ${isDefault ? 'Yes' : 'No'}`);
console.log(` Instance: ${instancePath}`);
console.log(` Created: ${new Date(profile.created).toLocaleString()}`);
if (profile.last_used) {
console.log(` Last used: ${new Date(profile.last_used).toLocaleString()}`);
} else {
console.log(` Last used: Never`);
}
console.log('');
} catch (error) {
console.error(`[X] ${(error as Error).message}`);
process.exit(1);
}
}
/**
* Remove a saved profile
*/
async handleRemove(args: string[]): Promise<void> {
const { profileName, yes } = this.parseArgs(args);
if (!profileName) {
console.error('[X] Profile name is required');
console.log('');
console.log(`Usage: ${colored('ccs auth remove <profile> [--yes]', 'yellow')}`);
process.exit(1);
}
if (!this.registry.hasProfile(profileName)) {
console.error(`[X] Profile not found: ${profileName}`);
process.exit(1);
}
try {
// Get instance path and session count for impact display
const instancePath = this.instanceMgr.getInstancePath(profileName);
let sessionCount = 0;
try {
const sessionsDir = path.join(instancePath, 'session-env');
if (fs.existsSync(sessionsDir)) {
const files = fs.readdirSync(sessionsDir);
sessionCount = files.filter(f => f.endsWith('.json')).length;
}
} catch (e) {
// Ignore errors counting sessions
}
// Display impact
console.log('');
console.log(`Profile '${colored(profileName, 'cyan')}' will be permanently deleted.`);
console.log(` Instance path: ${instancePath}`);
console.log(` Sessions: ${sessionCount} conversation${sessionCount !== 1 ? 's' : ''}`);
console.log('');
// Interactive confirmation (or --yes flag)
const confirmed = yes || await InteractivePrompt.confirm(
'Delete this profile?',
{ default: false } // Default to NO (safe)
);
if (!confirmed) {
console.log('[i] Cancelled');
process.exit(0);
}
// Delete instance
this.instanceMgr.deleteInstance(profileName);
// Delete profile
this.registry.deleteProfile(profileName);
console.log(colored('[OK] Profile removed successfully', 'green'));
console.log(` Profile: ${profileName}`);
console.log('');
} catch (error) {
console.error(`[X] Failed to remove profile: ${(error as Error).message}`);
process.exit(1);
}
}
/**
* Set default profile
*/
async handleDefault(args: string[]): Promise<void> {
const { profileName } = this.parseArgs(args);
if (!profileName) {
console.error('[X] Profile name is required');
console.log('');
console.log(`Usage: ${colored('ccs auth default <profile>', 'yellow')}`);
process.exit(1);
}
try {
this.registry.setDefaultProfile(profileName);
console.log(colored('[OK] Default profile set', 'green'));
console.log(` Profile: ${profileName}`);
console.log('');
console.log('Now you can use:');
console.log(` ${colored('ccs "your prompt"', 'yellow')} # Uses ${profileName} profile`);
console.log('');
} catch (error) {
console.error(`[X] ${(error as Error).message}`);
process.exit(1);
}
}
/**
* Route auth command to appropriate handler
*/
async route(args: string[]): Promise<void> {
if (args.length === 0 || args[0] === '--help' || args[0] === '-h' || args[0] === 'help') {
this.showHelp();
return;
}
const command = args[0];
const commandArgs = args.slice(1);
switch (command) {
case 'create':
await this.handleCreate(commandArgs);
break;
case 'save':
// Deprecated - redirect to create
console.log(colored('[!] Command "save" is deprecated', 'yellow'));
console.log(` Use: ${colored('ccs auth create <profile>', 'yellow')} instead`);
console.log('');
await this.handleCreate(commandArgs);
break;
case 'list':
await this.handleList(commandArgs);
break;
case 'show':
await this.handleShow(commandArgs);
break;
case 'remove':
await this.handleRemove(commandArgs);
break;
case 'default':
await this.handleDefault(commandArgs);
break;
case 'current':
console.log(colored('[!] Command "current" has been removed', 'yellow'));
console.log('');
console.log('Each profile has its own login in an isolated instance.');
console.log('Use "ccs auth list" to see all profiles.');
console.log('');
break;
case 'cleanup':
console.log(colored('[!] Command "cleanup" has been removed', 'yellow'));
console.log('');
console.log('No cleanup needed - no separate vault files.');
console.log('Use "ccs auth list" to see all profiles.');
console.log('');
break;
default:
console.error(`[X] Unknown command: ${command}`);
console.log('');
console.log('Run for help:');
console.log(` ${colored('ccs auth --help', 'yellow')}`);
process.exit(1);
}
}
}
export default AuthCommands;
src/auth/profile-detector.ts
+223
View File
@@ -0,0 +1,223 @@
/**
* Profile Detector
*
* Determines profile type (settings-based vs account-based) for routing.
* Priority: settings-based profiles (glm/kimi) checked FIRST for backward compatibility.
*/
import * as fs from 'fs';
import * as path from 'path';
import * as os from 'os';
import { findSimilarStrings } from '../utils/helpers';
import { Config } from '../types';
export type ProfileType = 'settings' | 'account' | 'default';
export interface ProfileDetectionResult {
type: ProfileType;
name: string;
settingsPath?: string;
profile?: any;
message?: string;
}
export interface AllProfiles {
settings: string[];
accounts: string[];
default?: string;
}
export interface ProfileNotFoundError extends Error {
profileName: string;
suggestions: string[];
availableProfiles: string;
}
/**
* Profile Detector Class
*/
class ProfileDetector {
private readonly configPath: string;
private readonly profilesPath: string;
constructor() {
this.configPath = path.join(os.homedir(), '.ccs', 'config.json');
this.profilesPath = path.join(os.homedir(), '.ccs', 'profiles.json');
}
/**
* Read settings-based config (config.json)
*/
private readConfig(): Config {
if (!fs.existsSync(this.configPath)) {
return { profiles: {} };
}
try {
const data = fs.readFileSync(this.configPath, 'utf8');
return JSON.parse(data) as Config;
} catch (error) {
console.warn(`[!] Warning: Could not read config.json: ${(error as Error).message}`);
return { profiles: {} };
}
}
/**
* Read account-based profiles (profiles.json)
*/
private readProfiles(): { profiles: Record<string, any>; default?: string } {
if (!fs.existsSync(this.profilesPath)) {
return { profiles: {}, default: undefined };
}
try {
const data = fs.readFileSync(this.profilesPath, 'utf8');
return JSON.parse(data);
} catch (error) {
console.warn(`[!] Warning: Could not read profiles.json: ${(error as Error).message}`);
return { profiles: {}, default: undefined };
}
}
/**
* Detect profile type and return routing information
*/
detectProfileType(profileName: string | null | undefined): ProfileDetectionResult {
// Special case: 'default' means use default profile
if (profileName === 'default' || profileName === null || profileName === undefined) {
return this.resolveDefaultProfile();
}
// Priority 1: Check settings-based profiles (glm, kimi) - BACKWARD COMPATIBILITY
const config = this.readConfig();
if (config.profiles && config.profiles[profileName]) {
return {
type: 'settings',
name: profileName,
settingsPath: config.profiles[profileName]
};
}
// Priority 2: Check account-based profiles (work, personal)
const profiles = this.readProfiles();
if (profiles.profiles && profiles.profiles[profileName]) {
return {
type: 'account',
name: profileName,
profile: profiles.profiles[profileName]
};
}
// Not found - generate suggestions
const allProfiles = this.getAllProfiles();
const allProfileNames = [...allProfiles.settings, ...allProfiles.accounts];
const suggestions = findSimilarStrings(profileName, allProfileNames);
const error = new Error(`Profile not found: ${profileName}`) as ProfileNotFoundError;
error.profileName = profileName;
error.suggestions = suggestions;
error.availableProfiles = this.listAvailableProfiles();
throw error;
}
/**
* Resolve default profile
*/
private resolveDefaultProfile(): ProfileDetectionResult {
// Check if account-based default exists
const profiles = this.readProfiles();
if (profiles.default && profiles.profiles[profiles.default]) {
return {
type: 'account',
name: profiles.default,
profile: profiles.profiles[profiles.default]
};
}
// Check if settings-based default exists
const config = this.readConfig();
if (config.profiles && config.profiles['default']) {
return {
type: 'settings',
name: 'default',
settingsPath: config.profiles['default']
};
}
// No default profile configured, use Claude's own defaults
return {
type: 'default',
name: 'default',
message: 'No profile configured. Using Claude CLI defaults from ~/.claude/'
};
}
/**
* List available profiles (for error messages)
*/
private listAvailableProfiles(): string {
const lines: string[] = [];
// Settings-based profiles
const config = this.readConfig();
const settingsProfiles = Object.keys(config.profiles || {});
if (settingsProfiles.length > 0) {
lines.push('Settings-based profiles (GLM, Kimi, etc.):');
settingsProfiles.forEach(name => {
lines.push(` - ${name}`);
});
}
// Account-based profiles
const profiles = this.readProfiles();
const accountProfiles = Object.keys(profiles.profiles || {});
if (accountProfiles.length > 0) {
lines.push('Account-based profiles:');
accountProfiles.forEach(name => {
const isDefault = name === profiles.default;
lines.push(` - ${name}${isDefault ? ' [DEFAULT]' : ''}`);
});
}
if (lines.length === 0) {
return ' (no profiles configured)\n' +
' Run "ccs auth save <profile>" to create your first account profile.';
}
return lines.join('\n');
}
/**
* Check if profile exists (any type)
*/
hasProfile(profileName: string): boolean {
try {
this.detectProfileType(profileName);
return true;
} catch {
return false;
}
}
/**
* Get all available profile names
*/
getAllProfiles(): AllProfiles {
const config = this.readConfig();
const profiles = this.readProfiles();
return {
settings: Object.keys(config.profiles || {}),
accounts: Object.keys(profiles.profiles || {}),
default: profiles.default
};
}
}
export default ProfileDetector;
src/auth/profile-registry.ts
+225
View File
@@ -0,0 +1,225 @@
import * as fs from 'fs';
import * as path from 'path';
import * as os from 'os';
import { ProfileMetadata } from '../types';
/**
* Profile Registry (Simplified)
*
* Manages account profile metadata in ~/.ccs/profiles.json
* Each profile represents an isolated Claude instance with login credentials.
*
* Profile Schema (v3.0 - Minimal):
* {
* type: 'account', // Profile type
* created: <ISO timestamp>, // Creation time
* last_used: <ISO timestamp or null> // Last usage time
* }
*
* Removed fields from v2.x:
* - vault: No encrypted vault (credentials in instance)
* - subscription: No credential reading
* - email: No credential reading
*/
interface ProfileData {
version: string;
profiles: Record<string, ProfileMetadata>;
default: string | null;
}
interface CreateMetadata {
type?: string;
created?: string;
last_used?: string | null;
}
export class ProfileRegistry {
private profilesPath: string;
constructor() {
this.profilesPath = path.join(os.homedir(), '.ccs', 'profiles.json');
}
/**
* Read profiles from disk
*/
private _read(): ProfileData {
if (!fs.existsSync(this.profilesPath)) {
return {
version: '2.0.0',
profiles: {},
default: null
};
}
try {
const data = fs.readFileSync(this.profilesPath, 'utf8');
return JSON.parse(data) as ProfileData;
} catch (error) {
const message = error instanceof Error ? error.message : 'Unknown error';
throw new Error(`Failed to read profiles: ${message}`);
}
}
/**
* Write profiles to disk atomically
*/
private _write(data: ProfileData): void {
const dir = path.dirname(this.profilesPath);
// Ensure directory exists
if (!fs.existsSync(dir)) {
fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
}
// Atomic write: temp file + rename
const tempPath = `${this.profilesPath}.tmp`;
try {
fs.writeFileSync(tempPath, JSON.stringify(data, null, 2), { mode: 0o600 });
fs.renameSync(tempPath, this.profilesPath);
} catch (error) {
// Cleanup temp file on error
if (fs.existsSync(tempPath)) {
fs.unlinkSync(tempPath);
}
const message = error instanceof Error ? error.message : 'Unknown error';
throw new Error(`Failed to write profiles: ${message}`);
}
}
/**
* Create a new profile
*/
createProfile(name: string, metadata: CreateMetadata = {}): void {
const data = this._read();
if (data.profiles[name]) {
throw new Error(`Profile already exists: ${name}`);
}
// v3.0 minimal schema: only essential fields
data.profiles[name] = {
type: metadata.type || 'account',
created: metadata.created || new Date().toISOString(),
last_used: metadata.last_used || null
};
// Note: No longer auto-set as default
// Users must explicitly run: ccs auth default <profile>
// Default always stays on implicit 'default' profile (uses ~/.claude/)
this._write(data);
}
/**
* Get profile metadata
*/
getProfile(name: string): ProfileMetadata {
const data = this._read();
if (!data.profiles[name]) {
throw new Error(`Profile not found: ${name}`);
}
return data.profiles[name];
}
/**
* Update profile metadata
*/
updateProfile(name: string, updates: Partial<ProfileMetadata>): void {
const data = this._read();
if (!data.profiles[name]) {
throw new Error(`Profile not found: ${name}`);
}
data.profiles[name] = {
...data.profiles[name],
...updates
};
this._write(data);
}
/**
* Delete a profile
*/
deleteProfile(name: string): void {
const data = this._read();
if (!data.profiles[name]) {
throw new Error(`Profile not found: ${name}`);
}
delete data.profiles[name];
// Clear default if it was the deleted profile
if (data.default === name) {
// Set to first remaining profile or null
const remaining = Object.keys(data.profiles);
data.default = remaining.length > 0 ? remaining[0] : null;
}
this._write(data);
}
/**
* List all profiles
*/
listProfiles(): string[] {
const data = this._read();
return Object.keys(data.profiles);
}
/**
* Get all profiles with metadata
*/
getAllProfiles(): Record<string, ProfileMetadata> {
const data = this._read();
return data.profiles;
}
/**
* Get default profile name
*/
getDefaultProfile(): string | null {
const data = this._read();
return data.default;
}
/**
* Set default profile
*/
setDefaultProfile(name: string): void {
const data = this._read();
if (!data.profiles[name]) {
throw new Error(`Profile not found: ${name}`);
}
data.default = name;
this._write(data);
}
/**
* Check if profile exists
*/
hasProfile(name: string): boolean {
const data = this._read();
return !!data.profiles[name];
}
/**
* Update last used timestamp
*/
touchProfile(name: string): void {
this.updateProfile(name, {
last_used: new Date().toISOString()
});
}
}
export default ProfileRegistry;
src/ccs.ts
+90
View File
@@ -0,0 +1,90 @@
#!/usr/bin/env node
import { colored } from './utils/helpers';
import { readFileSync } from 'fs';
import { join } from 'path';
const CCS_VERSION = JSON.parse(readFileSync(join(__dirname, '../package.json'), 'utf8')).version;
/**
* Handle version command
*/
function handleVersionCommand(): void {
console.log(colored(`CCS (Claude Code Switch) v${CCS_VERSION}`, 'bold'));
console.log('');
console.log(colored('Installation:', 'cyan'));
console.log(` ${colored('Location:'.padEnd(17), 'cyan')} ${process.argv[1] || '(not found)'}`);
console.log('');
console.log(`${colored('Documentation:', 'cyan')} https://github.com/kaitranntt/ccs`);
console.log(`${colored('License:', 'cyan')} MIT`);
console.log('');
console.log(colored('Run \'ccs --help\' for usage information', 'yellow'));
process.exit(0);
}
/**
* Handle help command
*/
function handleHelpCommand(): void {
console.log(colored('CCS (Claude Code Switch) - Instant profile switching for Claude CLI', 'bold'));
console.log('');
console.log(colored('Usage:', 'cyan'));
console.log(` ${colored('ccs', 'yellow')} [profile] [claude-args...]`);
console.log(` ${colored('ccs', 'yellow')} [flags]`);
console.log('');
console.log(colored('Description:', 'cyan'));
console.log(' Switch between multiple Claude accounts and alternative models');
console.log(' (GLM, Kimi) instantly. Run different Claude CLI sessions concurrently');
console.log('');
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 kimi', 'yellow')} Switch to Kimi for Coding`);
console.log('');
console.log(colored('Flags:', 'cyan'));
console.log(` ${colored('-h, --help', 'yellow')} Show this help message`);
console.log(` ${colored('-v, --version', 'yellow')} Show version and installation info`);
console.log('');
process.exit(0);
}
/**
* Main entry point
*/
function main(): void {
const args = process.argv.slice(2);
// Handle special commands
if (args[0] === '--version' || args[0] === '-v') {
handleVersionCommand();
}
if (args[0] === '--help' || args[0] === '-h') {
handleHelpCommand();
}
// For now, just show a message that conversion is in progress
console.log(colored('[i] CCS TypeScript conversion in progress', 'yellow'));
console.log(colored('[i] Basic structure is working', 'green'));
console.log('');
console.log('Build verification:');
console.log(` ✓ TypeScript compilation successful`);
console.log(` ✓ Shebang injection working`);
console.log(` ✓ Type definitions loaded`);
console.log('');
console.log('Next steps:');
console.log(' - Convert remaining utility files');
console.log(' - Convert auth/management modules');
console.log(' - Convert delegation system');
console.log(' - Convert GLMT proxy');
console.log('');
console.log(colored('TypeScript conversion foundation is complete!', 'green'));
}
main();
src/delegation/delegation-handler.ts
+222
View File
@@ -0,0 +1,222 @@
#!/usr/bin/env node
import { HeadlessExecutor } from './headless-executor';
import { SessionManager } from './session-manager';
import { ResultFormatter } from './result-formatter';
import { DelegationValidator } from '../utils/delegation-validator';
import { SettingsParser } from './settings-parser';
interface ParsedArgs {
profile: string;
prompt: string;
options: {
cwd: string;
outputFormat: string;
permissionMode: string;
timeout?: number;
resumeSession?: boolean;
sessionId?: string;
};
}
/**
* Delegation command handler
* Routes -p flag commands to HeadlessExecutor with enhanced features
*/
export class DelegationHandler {
/**
* Route delegation command
* @param args - Full args array from ccs.js
*/
async route(args: string[]): Promise<void> {
try {
// 1. Parse args into { profile, prompt, options }
const parsed = this._parseArgs(args);
// 2. Detect special profiles (glm:continue, kimi:continue)
if (parsed.profile.includes(':continue')) {
return await this._handleContinue(parsed);
}
// 3. Validate profile
this._validateProfile(parsed.profile);
// 4. Execute via HeadlessExecutor
const result = await HeadlessExecutor.execute(
parsed.profile,
parsed.prompt,
parsed.options
);
// 5. Format and display results
const formatted = ResultFormatter.format(result);
console.log(formatted);
// 6. Exit with proper code
process.exit(result.exitCode || 0);
} catch (error) {
console.error(`[X] Delegation error: ${(error as Error).message}`);
if (process.env.CCS_DEBUG) {
console.error((error as Error).stack);
}
process.exit(1);
}
}
/**
* Handle continue command (resume last session)
* @param parsed - Parsed args
*/
async _handleContinue(parsed: ParsedArgs): Promise<void> {
const baseProfile = parsed.profile.replace(':continue', '');
// Get last session from SessionManager
const sessionMgr = new SessionManager();
const lastSession = sessionMgr.getLastSession(baseProfile);
if (!lastSession) {
console.error(`[X] No previous session found for ${baseProfile}`);
console.error(` Start a new session first with: ccs ${baseProfile} -p "task"`);
process.exit(1);
}
// Execute with resume flag
const result = await HeadlessExecutor.execute(
baseProfile,
parsed.prompt,
{
...parsed.options,
resumeSession: true,
sessionId: lastSession.sessionId
}
);
const formatted = ResultFormatter.format(result);
console.log(formatted);
process.exit(result.exitCode || 0);
}
/**
* Parse args into structured format
* @param args - Raw args
* @returns { profile, prompt, options }
*/
_parseArgs(args: string[]): ParsedArgs {
// Extract profile (first non-flag arg or 'default')
const profile = this._extractProfile(args);
// Extract prompt from -p or --prompt
const prompt = this._extractPrompt(args);
// Extract options (--timeout, --permission-mode, etc.)
const options = this._extractOptions(args);
return { profile, prompt, options };
}
/**
* Extract profile from args (first non-flag arg)
* @param args - Args array
* @returns profile name
*/
_extractProfile(args: string[]): string {
// Find first arg that doesn't start with '-' and isn't -p value
let skipNext = false;
for (let i = 0; i < args.length; i++) {
if (skipNext) {
skipNext = false;
continue;
}
if (args[i] === '-p' || args[i] === '--prompt') {
skipNext = true;
continue;
}
if (!args[i].startsWith('-')) {
return args[i];
}
}
// No profile specified, return empty string (will error in validation)
return '';
}
/**
* Extract prompt from -p flag
* @param args - Args array
* @returns prompt text
*/
_extractPrompt(args: string[]): string {
const pIndex = args.indexOf('-p');
const promptIndex = args.indexOf('--prompt');
const index = pIndex !== -1 ? pIndex : promptIndex;
if (index === -1 || index === args.length - 1) {
console.error('[X] Missing prompt after -p flag');
console.error(' Usage: ccs glm -p "task description"');
process.exit(1);
}
return args[index + 1];
}
/**
* Extract options from remaining args
* @param args - Args array
* @returns options for HeadlessExecutor
*/
_extractOptions(args: string[]): ParsedArgs['options'] {
const cwd = process.cwd();
// Read default permission mode from .claude/settings.local.json
// Falls back to 'acceptEdits' if file doesn't exist
const defaultPermissionMode = SettingsParser.parseDefaultPermissionMode(cwd);
const options: ParsedArgs['options'] = {
cwd,
outputFormat: 'stream-json',
permissionMode: defaultPermissionMode
};
// Parse permission-mode (CLI flag overrides settings file)
const permModeIndex = args.indexOf('--permission-mode');
if (permModeIndex !== -1 && permModeIndex < args.length - 1) {
options.permissionMode = args[permModeIndex + 1];
}
// Parse timeout
const timeoutIndex = args.indexOf('--timeout');
if (timeoutIndex !== -1 && timeoutIndex < args.length - 1) {
options.timeout = parseInt(args[timeoutIndex + 1], 10);
}
return options;
}
/**
* Validate profile exists and is configured
* @param profile - Profile name
*/
_validateProfile(profile: string): void {
if (!profile) {
console.error('[X] No profile specified');
console.error(' Usage: ccs <profile> -p "task"');
console.error(' Examples: ccs glm -p "task", ccs kimi -p "task"');
process.exit(1);
}
// Use DelegationValidator to check profile
const validation = DelegationValidator.validate(profile);
if (!validation.valid) {
console.error(`[X] Profile '${profile}' is not configured for delegation`);
console.error(` ${validation.error}`);
console.error('');
console.error(' Run: ccs doctor');
console.error(` Or configure: ~/.ccs/${profile}.settings.json`);
process.exit(1);
}
}
}
src/delegation/headless-executor.ts
+669
View File
@@ -0,0 +1,669 @@
#!/usr/bin/env node
import { spawn } from 'child_process';
import * as path from 'path';
import * as os from 'os';
import * as fs from 'fs';
import { SessionManager } from './session-manager';
import { SettingsParser } from './settings-parser';
interface ExecutionOptions {
cwd?: string;
timeout?: number;
outputFormat?: string;
permissionMode?: string;
resumeSession?: boolean;
sessionId?: string;
maxRetries?: number;
}
interface ExecutionResult {
exitCode: number;
stdout: string;
stderr: string;
cwd: string;
profile: string;
duration: number;
timedOut: boolean;
success: boolean;
messages: any[];
sessionId?: string;
totalCost?: number;
numTurns?: number;
isError?: boolean;
type?: string | null;
subtype?: string;
durationApi?: number;
permissionDenials?: any[];
errors?: any[];
content?: string;
}
interface StreamMessage {
type: string;
message?: {
content?: Array<{
type: string;
name?: string;
input?: any;
}>;
};
session_id?: string;
total_cost_usd?: number;
num_turns?: number;
is_error?: boolean;
result?: string;
duration_api_ms?: number;
permission_denials?: any[];
errors?: any[];
subtype?: string;
}
/**
* Headless executor for Claude CLI delegation
* Spawns claude with -p flag for single-turn execution
*/
export class HeadlessExecutor {
/**
* Execute task via headless Claude CLI
* @param profile - Profile name (glm, kimi, custom)
* @param enhancedPrompt - Enhanced prompt with context
* @param options - Execution options
* @returns execution result
*/
static async execute(
profile: string,
enhancedPrompt: string,
options: ExecutionOptions = {}
): Promise<ExecutionResult> {
const {
cwd = process.cwd(),
timeout = 600000, // 10 minutes default
permissionMode = 'acceptEdits',
resumeSession = false,
sessionId = null
} = options;
// Validate permission mode
this._validatePermissionMode(permissionMode);
// Initialize session manager
const sessionMgr = new SessionManager();
// Detect Claude CLI path
const claudeCli = this._detectClaudeCli();
if (!claudeCli) {
throw new Error('Claude CLI not found in PATH. Install from: https://docs.claude.com/en/docs/claude-code/installation');
}
// Get settings path for profile
const settingsPath = path.join(os.homedir(), '.ccs', `${profile}.settings.json`);
// Validate settings file exists
if (!fs.existsSync(settingsPath)) {
throw new Error(`Settings file not found: ${settingsPath}\nProfile "${profile}" may not be configured.`);
}
// Smart slash command detection and preservation
// Detects if prompt contains slash command and restructures for proper execution
const processedPrompt = this._processSlashCommand(enhancedPrompt);
// Prepare arguments
const args: string[] = ['-p', processedPrompt, '--settings', settingsPath];
// Always use stream-json for real-time progress visibility
// Note: --verbose is required when using --print with stream-json
args.push('--output-format', 'stream-json', '--verbose');
// Add permission mode
if (permissionMode && permissionMode !== 'default') {
if (permissionMode === 'bypassPermissions') {
args.push('--dangerously-skip-permissions');
// Warn about dangerous mode
if (process.env.CCS_DEBUG) {
console.warn('[!] WARNING: Using --dangerously-skip-permissions mode');
console.warn('[!] This bypasses ALL permission checks. Use only in trusted environments.');
}
} else {
args.push('--permission-mode', permissionMode);
}
}
// Add resume flag for multi-turn sessions
if (resumeSession) {
const lastSession = sessionMgr.getLastSession(profile);
if (lastSession) {
args.push('--resume', lastSession.sessionId);
if (process.env.CCS_DEBUG) {
const cost = lastSession.totalCost !== undefined && lastSession.totalCost !== null ? lastSession.totalCost.toFixed(4) : '0.0000';
console.error(`[i] Resuming session: ${lastSession.sessionId} (${lastSession.turns} turns, $${cost})`);
}
} else if (sessionId) {
args.push('--resume', sessionId);
if (process.env.CCS_DEBUG) {
console.error(`[i] Resuming specific session: ${sessionId}`);
}
} else {
console.warn('[!] No previous session found, starting new session');
}
} else if (sessionId) {
args.push('--resume', sessionId);
if (process.env.CCS_DEBUG) {
console.error(`[i] Resuming specific session: ${sessionId}`);
}
}
// Add tool restrictions from settings
const toolRestrictions = SettingsParser.parseToolRestrictions(cwd);
if (toolRestrictions.allowedTools.length > 0) {
args.push('--allowedTools');
toolRestrictions.allowedTools.forEach(tool => args.push(tool));
}
if (toolRestrictions.disallowedTools.length > 0) {
args.push('--disallowedTools');
toolRestrictions.disallowedTools.forEach(tool => args.push(tool));
}
// Note: No max-turns limit - using time-based limits instead (default 10min timeout)
// Debug log args
if (process.env.CCS_DEBUG) {
console.error(`[i] Claude CLI args: ${args.join(' ')}`);
}
// Execute with spawn
return new Promise((resolve, reject) => {
const startTime = Date.now();
// Show progress unless explicitly disabled with CCS_QUIET
const showProgress = !process.env.CCS_QUIET;
// Show initial progress message
if (showProgress) {
const modelName = profile === 'glm' ? 'GLM-4.6' : profile === 'kimi' ? 'Kimi' : profile.toUpperCase();
console.error(`[i] Delegating to ${modelName}...`);
}
const proc = spawn(claudeCli, args, {
cwd,
stdio: ['ignore', 'pipe', 'pipe'],
timeout
});
let stdout = '';
let stderr = '';
let progressInterval: NodeJS.Timeout | undefined;
const messages: StreamMessage[] = []; // Accumulate stream-json messages
let partialLine = ''; // Buffer for incomplete JSON lines
// Handle parent process termination (Ctrl+C or Esc in Claude)
// When main Claude session is killed, cleanup spawned child process
const cleanupHandler = () => {
if (!proc.killed) {
if (process.env.CCS_DEBUG) {
console.error('[!] Parent process terminating, killing delegated session...');
}
proc.kill('SIGTERM');
// Force kill if not dead after 2s
setTimeout(() => {
if (!proc.killed) {
proc.kill('SIGKILL');
}
}, 2000);
}
};
// Register signal handlers for parent process termination
process.once('SIGINT', cleanupHandler);
process.once('SIGTERM', cleanupHandler);
// Cleanup signal handlers when child process exits
const removeSignalHandlers = () => {
process.removeListener('SIGINT', cleanupHandler);
process.removeListener('SIGTERM', cleanupHandler);
};
proc.on('close', removeSignalHandlers);
proc.on('error', removeSignalHandlers);
// Progress indicator (show elapsed time every 5 seconds)
if (showProgress) {
progressInterval = setInterval(() => {
const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
process.stderr.write(`[i] Still running... ${elapsed}s elapsed\r`);
}, 5000);
}
// Capture stdout (stream-json format - jsonl)
proc.stdout?.on('data', (data: Buffer) => {
const dataStr = data.toString();
stdout += dataStr;
// Parse stream-json messages (jsonl format - one JSON per line)
const chunk = partialLine + dataStr;
const lines = chunk.split('\n');
partialLine = lines.pop() || ''; // Save incomplete line for next chunk
for (const line of lines) {
if (!line.trim()) continue;
try {
const msg: StreamMessage = JSON.parse(line);
messages.push(msg);
// Show real-time tool use with verbose details
if (showProgress && msg.type === 'assistant') {
const toolUses = msg.message?.content?.filter(c => c.type === 'tool_use') || [];
for (const tool of toolUses) {
process.stderr.write('\r\x1b[K'); // Clear line
// Show verbose tool use with description/input if available
const toolInput = tool.input || {};
let verboseMsg = `[Tool] ${tool.name}`;
// Add context based on tool type (all Claude Code tools)
switch (tool.name) {
case 'Bash':
if (toolInput.command) {
// Truncate long commands
const cmd = toolInput.command.length > 80
? toolInput.command.substring(0, 77) + '...'
: toolInput.command;
verboseMsg += `: ${cmd}`;
}
break;
case 'Edit':
case 'Write':
case 'Read':
if (toolInput.file_path) {
verboseMsg += `: ${toolInput.file_path}`;
}
break;
case 'NotebookEdit':
case 'NotebookRead':
if (toolInput.notebook_path) {
verboseMsg += `: ${toolInput.notebook_path}`;
}
break;
case 'Grep':
if (toolInput.pattern) {
verboseMsg += `: searching for "${toolInput.pattern}"`;
if (toolInput.path) {
verboseMsg += ` in ${toolInput.path}`;
}
}
break;
case 'Glob':
if (toolInput.pattern) {
verboseMsg += `: ${toolInput.pattern}`;
}
break;
case 'SlashCommand':
if (toolInput.command) {
verboseMsg += `: ${toolInput.command}`;
}
break;
case 'Task':
if (toolInput.description) {
verboseMsg += `: ${toolInput.description}`;
} else if (toolInput.prompt) {
const prompt = toolInput.prompt.length > 60
? toolInput.prompt.substring(0, 57) + '...'
: toolInput.prompt;
verboseMsg += `: ${prompt}`;
}
break;
case 'TodoWrite':
if (toolInput.todos && Array.isArray(toolInput.todos)) {
// Show in_progress task instead of just count
const inProgressTask = toolInput.todos.find((t: any) => t.status === 'in_progress');
if (inProgressTask && inProgressTask.activeForm) {
verboseMsg += `: ${inProgressTask.activeForm}`;
} else {
// Fallback to count if no in_progress task
verboseMsg += `: ${toolInput.todos.length} task(s)`;
}
}
break;
case 'WebFetch':
if (toolInput.url) {
verboseMsg += `: ${toolInput.url}`;
}
break;
case 'WebSearch':
if (toolInput.query) {
verboseMsg += `: "${toolInput.query}"`;
}
break;
default:
// For unknown tools, show first meaningful parameter
if (Object.keys(toolInput).length > 0) {
const firstKey = Object.keys(toolInput)[0];
const firstValue = toolInput[firstKey];
if (typeof firstValue === 'string' && firstValue.length < 60) {
verboseMsg += `: ${firstValue}`;
}
}
}
process.stderr.write(`${verboseMsg}\n`);
}
}
} catch (parseError) {
// Skip malformed JSON lines (shouldn't happen with stream-json)
if (process.env.CCS_DEBUG) {
console.error(`[!] Failed to parse stream-json line: ${(parseError as Error).message}`);
}
}
}
});
// Stream stderr in real-time (progress messages from Claude CLI)
proc.stderr?.on('data', (data: Buffer) => {
const stderrText = data.toString();
stderr += stderrText;
// Show stderr in real-time if in TTY
if (showProgress) {
// Clear progress line before showing stderr
if (progressInterval) {
process.stderr.write('\r\x1b[K'); // Clear line
}
process.stderr.write(stderrText);
}
});
// Handle completion
proc.on('close', (exitCode: number | null) => {
const duration = Date.now() - startTime;
// Clear progress indicator
if (progressInterval) {
clearInterval(progressInterval);
process.stderr.write('\r\x1b[K'); // Clear line
}
// Show completion message
if (showProgress) {
const durationSec = (duration / 1000).toFixed(1);
if (timedOut) {
console.error(`[i] Execution timed out after ${durationSec}s`);
} else {
console.error(`[i] Execution completed in ${durationSec}s`);
}
console.error(''); // Blank line before formatted output
}
const result: ExecutionResult = {
exitCode: exitCode || 0,
stdout,
stderr,
cwd,
profile,
duration,
timedOut: false,
success: (exitCode === 0) && !timedOut,
messages // Include all stream-json messages
};
// Extract metadata from final 'result' message in stream-json
const resultMessage = messages.find(m => m.type === 'result');
if (resultMessage) {
// Add parsed fields from result message
result.sessionId = resultMessage.session_id || undefined;
result.totalCost = resultMessage.total_cost_usd || 0;
result.numTurns = resultMessage.num_turns || 0;
result.isError = resultMessage.is_error || false;
result.type = resultMessage.type || null;
result.subtype = resultMessage.subtype || undefined;
result.durationApi = resultMessage.duration_api_ms || 0;
result.permissionDenials = resultMessage.permission_denials || [];
result.errors = resultMessage.errors || [];
// Extract content from result message
result.content = resultMessage.result || '';
} else {
// Fallback: no result message found (shouldn't happen)
result.content = stdout;
if (process.env.CCS_DEBUG) {
console.error(`[!] No result message found in stream-json output`);
}
}
// Store or update session if we have session ID (even on timeout, for :continue support)
if (result.sessionId) {
if (resumeSession || sessionId) {
// Update existing session
sessionMgr.updateSession(profile, result.sessionId, {
totalCost: result.totalCost
});
} else {
// Store new session
sessionMgr.storeSession(profile, {
sessionId: result.sessionId,
totalCost: result.totalCost,
cwd: result.cwd
});
}
// Cleanup expired sessions periodically
if (Math.random() < 0.1) { // 10% chance
sessionMgr.cleanupExpired();
}
}
resolve(result);
});
// Handle errors
proc.on('error', (error: Error) => {
if (progressInterval) {
clearInterval(progressInterval);
}
reject(new Error(`Failed to execute Claude CLI: ${error.message}`));
});
// Handle timeout with graceful SIGTERM then forceful SIGKILL
let timedOut = false;
if (timeout > 0) {
const timeoutHandle = setTimeout(() => {
if (!proc.killed) {
timedOut = true;
if (progressInterval) {
clearInterval(progressInterval);
process.stderr.write('\r\x1b[K'); // Clear line
}
if (process.env.CCS_DEBUG) {
console.error(`[!] Timeout reached after ${timeout}ms, sending SIGTERM for graceful shutdown...`);
}
// Send SIGTERM for graceful shutdown
proc.kill('SIGTERM');
// If process doesn't terminate within 10s, force kill
setTimeout(() => {
if (!proc.killed) {
if (process.env.CCS_DEBUG) {
console.error(`[!] Process did not terminate gracefully, sending SIGKILL...`);
}
proc.kill('SIGKILL');
}
}, 10000); // Give 10s for graceful shutdown instead of 5s
}
}, timeout);
// Clear timeout on successful completion
proc.on('close', () => clearTimeout(timeoutHandle));
}
});
}
/**
* Validate permission mode
* @param mode - Permission mode
* @throws {Error} If mode is invalid
* @private
*/
private static _validatePermissionMode(mode: string): void {
const VALID_MODES = ['default', 'plan', 'acceptEdits', 'bypassPermissions'];
if (!VALID_MODES.includes(mode)) {
throw new Error(
`Invalid permission mode: "${mode}". Valid modes: ${VALID_MODES.join(', ')}`
);
}
}
/**
* Detect Claude CLI executable
* @returns Path to claude CLI or null if not found
* @private
*/
private static _detectClaudeCli(): string | null {
// Check environment variable override
if (process.env.CCS_CLAUDE_PATH) {
return process.env.CCS_CLAUDE_PATH;
}
// Try to find in PATH
const { execSync } = require('child_process');
try {
const result = execSync('command -v claude', { encoding: 'utf8' });
return result.trim();
} catch (error) {
return null;
}
}
/**
* Execute with retry logic
* @param profile - Profile name
* @param enhancedPrompt - Enhanced prompt
* @param options - Execution options
* @returns execution result
*/
static async executeWithRetry(
profile: string,
enhancedPrompt: string,
options: ExecutionOptions = {}
): Promise<ExecutionResult> {
const { maxRetries = 2, ...execOptions } = options;
let lastError: Error | undefined;
for (let attempt = 0; attempt <= maxRetries; attempt++) {
try {
const result = await this.execute(profile, enhancedPrompt, execOptions);
// If successful, return immediately
if (result.success) {
return result;
}
// If not last attempt, retry
if (attempt < maxRetries) {
console.error(`[!] Attempt ${attempt + 1} failed, retrying...`);
await this._sleep(1000 * (attempt + 1)); // Exponential backoff
continue;
}
// Last attempt failed, return result anyway
return result;
} catch (error) {
lastError = error as Error;
if (attempt < maxRetries) {
console.error(`[!] Attempt ${attempt + 1} errored: ${(error as Error).message}, retrying...`);
await this._sleep(1000 * (attempt + 1));
}
}
}
// All retries exhausted
throw lastError || new Error('Execution failed after all retry attempts');
}
/**
* Sleep utility for retry backoff
* @param ms - Milliseconds to sleep
* @returns Promise<void>
* @private
*/
private static _sleep(ms: number): Promise<void> {
return new Promise(resolve => setTimeout(resolve, ms));
}
/**
* Process prompt to detect and preserve slash commands
* Implements smart enhancement: preserves slash command at start, allows context in rest
* @param prompt - Original prompt (may contain slash command)
* @returns Processed prompt with slash command preserved
* @private
*/
private static _processSlashCommand(prompt: string): string {
const trimmed = prompt.trim();
// Case 1: Already starts with slash command - keep as-is
if (trimmed.match(/^\/[\w:-]+(\s|$)/)) {
return prompt;
}
// Case 2: Find slash command embedded in text
// Look for /command that's NOT part of a file path
// File paths: /home/user, /path/to/file (have / before or after)
// Commands: /cook, /plan (standalone, preceded by space/colon/start)
// Strategy: Find LAST occurrence that looks like a command, not a path
const embeddedSlash = trimmed.match(/(?:^|[^\w/])(\/[\w:-]+)(\s+[\s\S]*)?$/);
if (embeddedSlash) {
const command = embeddedSlash[1]; // e.g., "/cook"
const args = (embeddedSlash[2] || '').trim(); // Everything after command
// Calculate where the command starts (excluding preceding char if any)
const matchIndex = embeddedSlash.index || 0;
const matchStart = matchIndex + (embeddedSlash[0][0] === '/' ? 0 : 1);
const beforeCommand = trimmed.substring(0, matchStart).trim();
// Restructure: command first, context after
if (beforeCommand && args) {
return `${command} ${args}\n\nContext: ${beforeCommand}`;
} else if (beforeCommand) {
return `${command}\n\nContext: ${beforeCommand}`;
}
return args ? `${command} ${args}` : command;
}
// No slash command detected, return as-is
return prompt;
}
/**
* Test if profile is executable (quick health check)
* @param profile - Profile name
* @returns True if profile can execute
*/
static async testProfile(profile: string): Promise<boolean> {
try {
const result = await this.execute(profile, 'Say "test successful"', {
timeout: 10000
});
return result.success;
} catch (error) {
return false;
}
}
}
src/delegation/result-formatter.ts
+465
View File
@@ -0,0 +1,465 @@
#!/usr/bin/env node
/**
* Formats delegation execution results for display
* Creates ASCII box output with file change tracking
*/
import * as path from 'path';
import { execSync } from 'child_process';
import * as fs from 'fs';
interface ExecutionResult {
profile: string;
cwd: string;
exitCode: number;
stdout: string;
stderr: string;
duration: number;
success: boolean;
content?: string;
sessionId?: string;
totalCost?: number;
numTurns?: number;
subtype?: string;
permissionDenials?: PermissionDenial[];
errors?: ErrorInfo[];
// json?: any; // Removed: unused parameter
timedOut?: boolean;
}
interface PermissionDenial {
tool_name?: string;
tool_input?: {
command?: string;
description?: string;
[key: string]: any;
};
}
interface ErrorInfo {
message?: string;
error?: string;
[key: string]: any;
}
interface FileChanges {
created: string[];
modified: string[];
}
/**
* Result Formatter Class
*/
class ResultFormatter {
/**
* Format execution result with complete source-of-truth
*/
static format(result: ExecutionResult): string {
const { profile, cwd, exitCode, stdout, stderr, duration, success, content, sessionId, totalCost, numTurns, subtype, permissionDenials, errors, timedOut } = result;
// Handle timeout (graceful termination)
if (timedOut) {
return this.formatTimeoutError(result);
}
// Handle legacy max_turns error (Claude CLI might still return this)
if (subtype === 'error_max_turns') {
return this.formatTimeoutError(result);
}
// Use content field for output (JSON result or fallback stdout)
const displayOutput = content || stdout;
// Build formatted output
let output = '';
// Header
output += this.formatHeader(profile, success);
// Info box (file detection handled by delegated session itself)
output += this.formatInfoBox(cwd, profile, duration, exitCode, sessionId, totalCost, numTurns);
// Task output
output += '\n';
output += this.formatOutput(displayOutput);
// Permission denials if present
if (permissionDenials && permissionDenials.length > 0) {
output += '\n';
output += this.formatPermissionDenials(permissionDenials);
}
// Errors if present
if (errors && errors.length > 0) {
output += '\n';
output += this.formatErrors(errors);
}
// Stderr if present
if (stderr && stderr.trim()) {
output += '\n';
output += this.formatStderr(stderr);
}
// Footer
output += '\n';
output += this.formatFooter(success, duration);
return output;
}
/**
* Extract file changes from output
*/
static extractFileChanges(output: string, cwd: string): FileChanges {
const created: string[] = [];
const modified: string[] = [];
// Patterns to match file operations (case-insensitive)
const createdPatterns = [
/created:\s*([^\n\r]+)/gi,
/create:\s*([^\n\r]+)/gi,
/wrote:\s*([^\n\r]+)/gi,
/write:\s*([^\n\r]+)/gi,
/new file:\s*([^\n\r]+)/gi,
/generated:\s*([^\n\r]+)/gi,
/added:\s*([^\n\r]+)/gi
];
const modifiedPatterns = [
/modified:\s*([^\n\r]+)/gi,
/update:\s*([^\n\r]+)/gi,
/updated:\s*([^\n\r]+)/gi,
/edit:\s*([^\n\r]+)/gi,
/edited:\s*([^\n\r]+)/gi,
/changed:\s*([^\n\r]+)/gi
];
// Helper to check if file is infrastructure (should be ignored)
const isInfrastructure = (filePath: string): boolean => {
return filePath.includes('/.claude/') || filePath.startsWith('.claude/');
};
// Extract created files
for (const pattern of createdPatterns) {
let match;
while ((match = pattern.exec(output)) !== null) {
const filePath = match[1].trim();
if (filePath && !created.includes(filePath) && !isInfrastructure(filePath)) {
created.push(filePath);
}
}
}
// Extract modified files
for (const pattern of modifiedPatterns) {
let match;
while ((match = pattern.exec(output)) !== null) {
const filePath = match[1].trim();
// Don't include if already in created list or is infrastructure
if (filePath && !modified.includes(filePath) && !created.includes(filePath) && !isInfrastructure(filePath)) {
modified.push(filePath);
}
}
}
// Fallback: Scan filesystem for recently modified files (last 5 minutes)
if (created.length === 0 && modified.length === 0 && cwd) {
try {
// Use find command to get recently modified files (excluding infrastructure)
const findCmd = `find . -type f -mmin -5 -not -path "./.git/*" -not -path "./node_modules/*" -not -path "./.claude/*" 2>/dev/null | head -20`;
const result = execSync(findCmd, { cwd, encoding: 'utf8', timeout: 5000 });
const files = result.split('\n').filter(f => f.trim());
files.forEach(file => {
const fullPath = path.join(cwd, file);
// Double-check not infrastructure
if (isInfrastructure(fullPath)) {
return;
}
try {
const stats = fs.statSync(fullPath);
const now = Date.now();
const mtime = stats.mtimeMs;
const ctime = stats.ctimeMs;
// If both mtime and ctime are very recent (within 10 minutes), likely created
// ctime = inode change time, for new files this is close to creation time
const isVeryRecent = (now - mtime) < 600000 && (now - ctime) < 600000;
const timeDiff = Math.abs(mtime - ctime);
// If mtime and ctime are very close (< 1 second apart) and both recent, it's created
if (isVeryRecent && timeDiff < 1000) {
if (!created.includes(fullPath)) {
created.push(fullPath);
}
} else {
// Otherwise, it's modified
if (!modified.includes(fullPath)) {
modified.push(fullPath);
}
}
} catch (statError) {
// If stat fails, default to created (since we're in fallback mode)
if (!created.includes(fullPath) && !modified.includes(fullPath)) {
created.push(fullPath);
}
}
});
} catch (scanError) {
// Silently fail if filesystem scan doesn't work
if (process.env.CCS_DEBUG) {
console.error(`[!] Filesystem scan failed: ${(scanError as Error).message}`);
}
}
}
return { created, modified };
}
/**
* Format header with delegation indicator
*/
private static formatHeader(profile: string, success: boolean): string {
const modelName = this.getModelDisplayName(profile);
const icon = success ? '[i]' : '[X]';
return `${icon} Delegated to ${modelName} (ccs:${profile})\n`;
}
/**
* Format info box with delegation details
*/
private static formatInfoBox(cwd: string, profile: string, duration: number, exitCode: number, sessionId?: string, totalCost?: number, numTurns?: number): string {
const modelName = this.getModelDisplayName(profile);
const durationSec = (duration / 1000).toFixed(1);
// Calculate box width (fit longest line + padding)
const maxWidth = 70;
const cwdLine = `Working Directory: ${cwd}`;
const boxWidth = Math.min(Math.max(cwdLine.length + 4, 50), maxWidth);
const lines: string[] = [
`Working Directory: ${this.truncate(cwd, boxWidth - 22)}`,
`Model: ${modelName}`,
`Duration: ${durationSec}s`,
`Exit Code: ${exitCode}`
];
// Add JSON-specific fields if available
if (sessionId) {
// Abbreviate session ID (Git-style first 8 chars) to prevent wrapping
const shortId = sessionId.length > 8 ? sessionId.substring(0, 8) : sessionId;
lines.push(`Session ID: ${shortId}`);
}
if (totalCost !== undefined && totalCost !== null) {
lines.push(`Cost: $${totalCost.toFixed(4)}`);
}
if (numTurns) {
lines.push(`Turns: ${numTurns}`);
}
let box = '';
box += '╔' + '═'.repeat(boxWidth - 2) + '╗\n';
for (const line of lines) {
const padding = boxWidth - line.length - 4;
box += '║ ' + line + ' '.repeat(Math.max(0, padding)) + ' ║\n';
}
box += '╚' + '═'.repeat(boxWidth - 2) + '╝';
return box;
}
/**
* Format task output
*/
private static formatOutput(output: string): string {
if (!output || !output.trim()) {
return '[i] No output from delegated task\n';
}
return output.trim() + '\n';
}
/**
* Format stderr output
*/
private static formatStderr(stderr: string): string {
return `[!] Stderr:\n${stderr.trim()}\n\n`;
}
/**
* Format file list (created or modified) - Currently unused
*/
/*
private static formatFileList(label: string, files: string[]): string {
let output = `[i] ${label} Files:\n`;
for (const file of files) {
output += ` - ${file}\n`;
}
return output;
}
*/
/**
* Format footer with completion status
*/
private static formatFooter(success: boolean, _duration: number): string {
const icon = success ? '[OK]' : '[X]';
const status = success ? 'Delegation completed' : 'Delegation failed';
return `${icon} ${status}\n`;
}
/**
* Get display name for model profile
*/
private static getModelDisplayName(profile: string): string {
const displayNames: Record<string, string> = {
'glm': 'GLM-4.6',
'glmt': 'GLM-4.6 (Thinking)',
'kimi': 'Kimi',
'default': 'Claude'
};
return displayNames[profile] || profile.toUpperCase();
}
/**
* Truncate string to max length
*/
private static truncate(str: string, maxLength: number): string {
if (str.length <= maxLength) {
return str;
}
return str.substring(0, maxLength - 3) + '...';
}
/**
* Format minimal result (for quick tasks)
*/
static formatMinimal(result: ExecutionResult): string {
const { profile, success, duration } = result;
const modelName = this.getModelDisplayName(profile);
const icon = success ? '[OK]' : '[X]';
const durationSec = (duration / 1000).toFixed(1);
return `${icon} ${modelName} delegation ${success ? 'completed' : 'failed'} (${durationSec}s)\n`;
}
/**
* Format verbose result (with full details)
*/
static formatVerbose(result: ExecutionResult): string {
const basic = this.format(result);
// Add additional debug info
let verbose = basic;
verbose += '\n=== Debug Information ===\n';
verbose += `CWD: ${result.cwd}\n`;
verbose += `Profile: ${result.profile}\n`;
verbose += `Exit Code: ${result.exitCode}\n`;
verbose += `Duration: ${result.duration}ms\n`;
verbose += `Success: ${result.success}\n`;
verbose += `Stdout Length: ${result.stdout.length} chars\n`;
verbose += `Stderr Length: ${result.stderr.length} chars\n`;
return verbose;
}
/**
* Check if NO_COLOR environment variable is set - Currently unused
*/
/*
private static shouldDisableColors(): boolean {
return process.env.NO_COLOR !== undefined;
}
*/
/**
* Format timeout error (session exceeded time limit)
*/
private static formatTimeoutError(result: ExecutionResult): string {
const { profile, cwd, duration, sessionId, totalCost, numTurns, permissionDenials } = result;
let output = '';
// Header
output += this.formatHeader(profile, false);
// Info box
output += this.formatInfoBox(cwd, profile, duration, 0, sessionId, totalCost, numTurns);
// Timeout message
output += '\n';
const timeoutMin = (duration / 60000).toFixed(1);
output += `[!] Execution timed out after ${timeoutMin} minutes\n\n`;
output += 'The delegated session exceeded its time limit before completing the task.\n';
output += 'Session was gracefully terminated and saved for continuation.\n';
// Permission denials if present
if (permissionDenials && permissionDenials.length > 0) {
output += '\n';
output += this.formatPermissionDenials(permissionDenials);
output += '\n';
output += 'The task may require permissions that were denied.\n';
output += 'Consider running with --permission-mode bypassPermissions or execute manually.\n';
}
// Suggestions
output += '\n';
output += 'Suggestions:\n';
output += ` - Continue session: ccs ${profile}:continue -p "finish the task"\n`;
output += ` - Increase timeout: ccs ${profile} -p "task" --timeout ${duration * 2}\n`;
output += ' - Break task into smaller steps\n';
output += ' - Run task manually in main Claude session\n';
output += '\n';
// Abbreviate session ID (Git-style first 8 chars)
const shortId = sessionId && sessionId.length > 8 ? sessionId.substring(0, 8) : sessionId;
output += `[i] Session persisted with ID: ${shortId}\n`;
if (totalCost !== undefined && totalCost !== null) {
output += `[i] Cost: $${totalCost.toFixed(4)}\n`;
}
return output;
}
/**
* Format permission denials
*/
private static formatPermissionDenials(denials: PermissionDenial[]): string {
let output = '[!] Permission Denials:\n';
for (const denial of denials) {
const tool = denial.tool_name || 'Unknown';
const input = denial.tool_input || {};
const command = input.command || input.description || JSON.stringify(input);
output += ` - ${tool}: ${command}\n`;
}
return output;
}
/**
* Format errors array
*/
private static formatErrors(errors: ErrorInfo[]): string {
let output = '[X] Errors:\n';
for (const error of errors) {
const message = error.message || error.error || JSON.stringify(error);
output += ` - ${message}\n`;
}
return output;
}
}
export { ResultFormatter };
src/delegation/session-manager.ts
+170
View File
@@ -0,0 +1,170 @@
#!/usr/bin/env node
/**
* Manages delegation session persistence for multi-turn conversations
*/
import * as fs from 'fs';
import * as path from 'path';
import * as os from 'os';
interface SessionData {
sessionId: string;
totalCost?: number;
cwd?: string;
}
interface TurnData {
totalCost?: number;
}
interface SessionMetadata {
sessionId: string;
profile: string;
startTime: number;
lastTurnTime: number;
totalCost: number;
turns: number;
cwd: string;
}
interface SessionsRegistry {
[key: string]: SessionMetadata;
}
/**
* Session Manager Class
*/
class SessionManager {
private readonly sessionsPath: string;
constructor() {
this.sessionsPath = path.join(os.homedir(), '.ccs', 'delegation-sessions.json');
}
/**
* Store new session metadata
*/
storeSession(profile: string, sessionData: SessionData): void {
const sessions = this.loadSessions();
const key = `${profile}:latest`;
sessions[key] = {
sessionId: sessionData.sessionId,
profile,
startTime: Date.now(),
lastTurnTime: Date.now(),
totalCost: sessionData.totalCost || 0,
turns: 1,
cwd: sessionData.cwd || process.cwd()
};
this.saveSessions(sessions);
if (process.env.CCS_DEBUG) {
console.error(`[i] Stored session: ${sessionData.sessionId} for ${profile}`);
}
}
/**
* Update session after additional turn
*/
updateSession(profile: string, sessionId: string, turnData: TurnData): void {
const sessions = this.loadSessions();
const key = `${profile}:latest`;
if (sessions[key]?.sessionId === sessionId) {
sessions[key].lastTurnTime = Date.now();
sessions[key].totalCost += turnData.totalCost || 0;
sessions[key].turns += 1;
this.saveSessions(sessions);
if (process.env.CCS_DEBUG) {
const cost = sessions[key].totalCost !== undefined && sessions[key].totalCost !== null ? sessions[key].totalCost.toFixed(4) : '0.0000';
console.error(`[i] Updated session: ${sessionId}, total: $${cost}, turns: ${sessions[key].turns}`);
}
}
}
/**
* Get last session for profile
*/
getLastSession(profile: string): SessionMetadata | null {
const sessions = this.loadSessions();
const key = `${profile}:latest`;
return sessions[key] || null;
}
/**
* Clear all sessions for profile
*/
clearProfile(profile: string): void {
const sessions = this.loadSessions();
const key = `${profile}:latest`;
delete sessions[key];
this.saveSessions(sessions);
}
/**
* Clean up expired sessions (>30 days)
*/
cleanupExpired(): void {
const sessions = this.loadSessions();
const now = Date.now();
const maxAge = 30 * 24 * 60 * 60 * 1000; // 30 days
let cleaned = 0;
Object.keys(sessions).forEach(key => {
if (now - sessions[key].lastTurnTime > maxAge) {
delete sessions[key];
cleaned++;
}
});
if (cleaned > 0) {
this.saveSessions(sessions);
if (process.env.CCS_DEBUG) {
console.error(`[i] Cleaned ${cleaned} expired sessions`);
}
}
}
/**
* Load sessions from disk
*/
private loadSessions(): SessionsRegistry {
try {
if (!fs.existsSync(this.sessionsPath)) {
return {};
}
const content = fs.readFileSync(this.sessionsPath, 'utf8');
return JSON.parse(content) as SessionsRegistry;
} catch (error) {
if (process.env.CCS_DEBUG) {
console.warn(`[!] Failed to load sessions: ${(error as Error).message}`);
}
return {};
}
}
/**
* Save sessions to disk
*/
private saveSessions(sessions: SessionsRegistry): void {
try {
const dir = path.dirname(this.sessionsPath);
if (!fs.existsSync(dir)) {
fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
}
fs.writeFileSync(
this.sessionsPath,
JSON.stringify(sessions, null, 2),
{ mode: 0o600 }
);
} catch (error) {
console.error(`[!] Failed to save sessions: ${(error as Error).message}`);
}
}
}
export { SessionManager };
src/delegation/settings-parser.ts
+115
View File
@@ -0,0 +1,115 @@
#!/usr/bin/env node
/**
* Parses Claude Code settings for tool restrictions
*/
import * as fs from 'fs';
import * as path from 'path';
interface ToolRestrictions {
allowedTools: string[];
disallowedTools: string[];
}
interface Settings {
permissions?: {
allow?: string[];
deny?: string[];
defaultMode?: string;
};
}
/**
* Settings Parser Class
*/
class SettingsParser {
/**
* Parse default permission mode from project settings
*/
static parseDefaultPermissionMode(projectDir: string): string {
const settings = this.loadSettings(projectDir);
const permissions = settings.permissions || {};
// Priority: local > shared > fallback to 'acceptEdits'
const defaultMode = permissions.defaultMode || 'acceptEdits';
if (process.env.CCS_DEBUG) {
console.error(`[i] Permission mode from settings: ${defaultMode}`);
}
return defaultMode;
}
/**
* Parse project settings for tool restrictions
*/
static parseToolRestrictions(projectDir: string): ToolRestrictions {
const settings = this.loadSettings(projectDir);
const permissions = settings.permissions || {};
const allowed = permissions.allow || [];
const denied = permissions.deny || [];
if (process.env.CCS_DEBUG) {
console.error(`[i] Tool restrictions: ${allowed.length} allowed, ${denied.length} denied`);
}
return {
allowedTools: allowed,
disallowedTools: denied
};
}
/**
* Load and merge settings files (local overrides shared)
*/
private static loadSettings(projectDir: string): Settings {
const claudeDir = path.join(projectDir, '.claude');
const sharedPath = path.join(claudeDir, 'settings.json');
const localPath = path.join(claudeDir, 'settings.local.json');
// Load shared settings
const shared = this.readJsonSafe(sharedPath) || {};
// Load local settings (overrides shared)
const local = this.readJsonSafe(localPath) || {};
// Merge permissions (local overrides shared)
return {
permissions: {
allow: [
...(shared.permissions?.allow || []),
...(local.permissions?.allow || [])
],
deny: [
...(shared.permissions?.deny || []),
...(local.permissions?.deny || [])
],
// Local defaultMode takes priority over shared
defaultMode: local.permissions?.defaultMode || shared.permissions?.defaultMode || undefined
}
};
}
/**
* Read JSON file safely (no throw)
*/
private static readJsonSafe(filePath: string): Settings | null {
try {
if (!fs.existsSync(filePath)) {
return null;
}
const content = fs.readFileSync(filePath, 'utf8');
return JSON.parse(content) as Settings;
} catch (error) {
if (process.env.CCS_DEBUG) {
console.warn(`[!] Failed to read settings: ${filePath}: ${(error as Error).message}`);
}
return null;
}
}
}
export { SettingsParser };
src/glmt/delta-accumulator.ts
+349
View File
@@ -0,0 +1,349 @@
#!/usr/bin/env node
/**
* 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);
*/
interface ThinkingConfig {
[key: string]: any;
}
interface DeltaAccumulatorOptions {
maxBlocks?: number;
maxBufferSize?: number;
loopDetectionThreshold?: number;
}
interface ContentBlock {
index: number;
type: string;
content: string;
started: boolean;
stopped: boolean;
}
interface ToolCall {
index: number;
id: string;
type: string;
function: {
name: string;
arguments: string;
};
}
interface ToolCallDelta {
index: number;
id?: string;
type?: string;
function?: {
name?: string;
arguments?: string;
};
}
interface UsageStats {
prompt_tokens?: number;
input_tokens?: number;
completion_tokens?: number;
output_tokens?: number;
}
interface AccumulatorSummary {
messageId: string;
model: string | null;
role: string;
blockCount: number;
currentIndex: number;
toolCallCount: number;
messageStarted: boolean;
finalized: boolean;
loopDetected: boolean;
usage: {
input_tokens: number;
output_tokens: number;
};
}
export class DeltaAccumulator {
private messageId: string;
private model: string | null;
private role: string;
private contentBlocks: ContentBlock[];
private currentBlockIndex: number;
private toolCalls: ToolCall[];
private toolCallsIndex: Record<number, ToolCall>;
private thinkingBuffer: string;
private textBuffer: string;
private maxBlocks: number;
private maxBufferSize: number;
private loopDetectionThreshold: number;
private loopDetected: boolean;
private messageStarted: boolean;
private finalized: boolean;
private inputTokens: number;
private outputTokens: number;
constructor(_thinkingConfig: ThinkingConfig = {}, options: DeltaAccumulatorOptions = {}) {
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(): ContentBlock | null {
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: string): ContentBlock {
// 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: ContentBlock = {
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: string): void {
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(): void {
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: UsageStats): void {
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: ToolCallDelta): void {
const index = toolCallDelta.index;
// Initialize tool call if not exists
if (!this.toolCallsIndex[index]) {
const toolCall: ToolCall = {
index: index,
id: '',
type: 'function',
function: {
name: '',
arguments: ''
}
};
this.toolCalls.push(toolCall);
this.toolCallsIndex[index] = toolCall;
}
const toolCall = this.toolCallsIndex[index];
// Update id if present
if (toolCallDelta.id) {
toolCall.id = toolCallDelta.id;
}
// Update type if present
if (toolCallDelta.type) {
toolCall.type = toolCallDelta.type;
}
// Update function name if present
if (toolCallDelta.function?.name) {
toolCall.function.name += toolCallDelta.function.name;
}
// Update function arguments if present
if (toolCallDelta.function?.arguments) {
toolCall.function.arguments += toolCallDelta.function.arguments;
}
}
/**
* Get all tool calls
* @returns Tool calls array
*/
getToolCalls(): ToolCall[] {
return this.toolCalls;
}
/**
* Check for planning loop pattern
* Loop = N consecutive thinking blocks with no tool calls
* @returns True if loop detected
*/
checkForLoop(): boolean {
// 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(): void {
this.loopDetected = false;
}
/**
* Get summary of accumulated state
* @returns Summary
*/
getSummary(): AccumulatorSummary {
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
}
};
}
}
src/glmt/locale-enforcer.ts
+81
View File
@@ -0,0 +1,81 @@
#!/usr/bin/env node
/**
* LocaleEnforcer - Force English output from GLM models
*
* Purpose: GLM models default to Chinese when prompts are ambiguous or contain Chinese context.
* This module always injects "MUST respond in English" instruction into system prompt or first user message.
*
* Usage:
* const enforcer = new LocaleEnforcer();
* const modifiedMessages = enforcer.injectInstruction(messages);
*
* Strategy:
* 1. If system prompt exists: Prepend instruction
* 2. If no system prompt: Prepend to first user message
* 3. Preserve message structure (string vs array content)
*/
interface Message {
role: string;
content: string | Array<{ type: string; text: string }>;
}
interface LocaleEnforcerOptions {
instruction?: string;
}
export class LocaleEnforcer {
private instruction: string;
constructor(options: LocaleEnforcerOptions = {}) {
this.instruction = options.instruction || "CRITICAL: You MUST respond in English only, regardless of the input language or context. This is a strict requirement.";
}
/**
* Inject English instruction into messages
* @param messages - Messages array to modify
* @returns Modified messages array
*/
injectInstruction(messages: Message[]): Message[] {
// Clone messages to avoid mutation
const modifiedMessages = JSON.parse(JSON.stringify(messages)) as Message[];
// Strategy 1: Inject into system prompt (preferred)
const systemIndex = modifiedMessages.findIndex(m => m.role === 'system');
if (systemIndex >= 0) {
const systemMsg = modifiedMessages[systemIndex];
if (typeof systemMsg.content === 'string') {
systemMsg.content = `${this.instruction}\n\n${systemMsg.content}`;
} else if (Array.isArray(systemMsg.content)) {
systemMsg.content.unshift({
type: 'text',
text: this.instruction
});
}
return modifiedMessages;
}
// Strategy 2: Prepend to first user message
const userIndex = modifiedMessages.findIndex(m => m.role === 'user');
if (userIndex >= 0) {
const userMsg = modifiedMessages[userIndex];
if (typeof userMsg.content === 'string') {
userMsg.content = `${this.instruction}\n\n${userMsg.content}`;
} else if (Array.isArray(userMsg.content)) {
userMsg.content.unshift({
type: 'text',
text: this.instruction
});
}
return modifiedMessages;
}
// No system or user messages found (edge case)
return modifiedMessages;
}
}
src/glmt/sse-parser.ts
+110
View File
@@ -0,0 +1,110 @@
#!/usr/bin/env node
/**
* SSEParser - Parse Server-Sent Events (SSE) stream
*
* Handles:
* - Incomplete events across chunks
* - Multiple events in single chunk
* - Malformed data (skip gracefully)
* - [DONE] marker
*
* Usage:
* const parser = new SSEParser();
* stream.on('data', chunk => {
* const events = parser.parse(chunk);
* events.forEach(event => { ... });
* });
*/
interface SSEParserOptions {
maxBufferSize?: number;
}
interface SSEEvent {
event: string;
data: any;
index?: number;
id?: string;
retry?: number;
}
export class SSEParser {
private buffer: string;
private eventCount: number;
private maxBufferSize: number;
constructor(options: SSEParserOptions = {}) {
this.buffer = '';
this.eventCount = 0;
this.maxBufferSize = options.maxBufferSize || 1024 * 1024; // 1MB default
}
/**
* Parse chunk and extract SSE events
* @param chunk - Data chunk from stream
* @returns Array of parsed events
*/
parse(chunk: Buffer | string): SSEEvent[] {
this.buffer += chunk.toString();
// C-01 Fix: Prevent unbounded buffer growth (DoS protection)
if (this.buffer.length > this.maxBufferSize) {
throw new Error(`SSE buffer exceeded ${this.maxBufferSize} bytes (DoS protection)`);
}
const lines = this.buffer.split('\n');
// Keep incomplete line in buffer
this.buffer = lines.pop() || '';
const events: SSEEvent[] = [];
let currentEvent: SSEEvent = { event: 'message', data: '' };
for (const line of lines) {
if (line.startsWith('event: ')) {
currentEvent.event = line.substring(7).trim();
} else if (line.startsWith('data: ')) {
const data = line.substring(6);
if (data === '[DONE]') {
this.eventCount++;
events.push({
event: 'done',
data: null,
index: this.eventCount
});
currentEvent = { event: 'message', data: '' };
} else {
try {
currentEvent.data = JSON.parse(data);
this.eventCount++;
currentEvent.index = this.eventCount;
events.push({ ...currentEvent });
currentEvent = { event: 'message', data: '' };
} catch (e) {
// H-01 Fix: Log parse errors for debugging
if (typeof console !== 'undefined' && console.error) {
console.error('[SSEParser] Malformed JSON event:', (e as Error).message, 'Data:', data.substring(0, 100));
}
}
}
} else if (line.startsWith('id: ')) {
currentEvent.id = line.substring(4).trim();
} else if (line.startsWith('retry: ')) {
currentEvent.retry = parseInt(line.substring(7), 10);
}
// Empty lines separate events (already handled by JSON parsing)
}
return events;
}
/**
* Reset parser state (for reuse)
*/
reset(): void {
this.buffer = '';
this.eventCount = 0;
}
}
src/management/doctor.ts
+763
View File
@@ -0,0 +1,763 @@
/**
* CCS Health Check and Diagnostics
*/
import * as fs from 'fs';
import * as path from 'path';
import * as os from 'os';
import { spawn } from 'child_process';
import { colored } from '../utils/helpers';
import { detectClaudeCli } from '../utils/claude-detector';
import packageJson from '../../package.json';
// Make ora optional (might not be available during npm install postinstall)
// ora v9+ is an ES module, need to use .default for CommonJS
interface Spinner {
start(): {
succeed(msg?: string): void;
fail(msg?: string): void;
warn(msg?: string): void;
info(msg?: string): void;
text: string;
};
}
let ora: (text: string) => Spinner;
try {
const oraModule = require('ora');
ora = oraModule.default || oraModule;
} catch (e) {
// ora not available, create fallback spinner that uses console.log
ora = function(text: string): Spinner {
return {
start: () => ({
succeed: (msg?: string) => console.log(msg || `[OK] ${text}`),
fail: (msg?: string) => console.log(msg || `[X] ${text}`),
warn: (msg?: string) => console.log(msg || `[!] ${text}`),
info: (msg?: string) => console.log(msg || `[i] ${text}`),
text: ''
})
};
};
}
// Import cli-table3
const Table = require('cli-table3');
interface HealthCheckDetails {
status: 'OK' | 'ERROR' | 'WARN';
info: string;
}
interface HealthCheckItem {
name: string;
status: 'success' | 'error' | 'warning';
message?: string;
fix?: string;
}
interface HealthIssue {
name: string;
message: string;
fix?: string;
}
/**
* Health check results
*/
class HealthCheck {
public checks: HealthCheckItem[] = [];
public warnings: HealthIssue[] = [];
public errors: HealthIssue[] = [];
public details: Record<string, HealthCheckDetails> = {};
addCheck(name: string, status: 'success' | 'error' | 'warning', message = '', fix: string | undefined = undefined, details: HealthCheckDetails | undefined = undefined): void {
this.checks.push({ name, status, message, fix });
if (status === 'error') this.errors.push({ name, message, fix });
if (status === 'warning') this.warnings.push({ name, message, fix });
// Store details for summary table
if (details) {
this.details[name] = details;
}
}
hasErrors(): boolean {
return this.errors.length > 0;
}
hasWarnings(): boolean {
return this.warnings.length > 0;
}
isHealthy(): boolean {
return !this.hasErrors();
}
}
/**
* Doctor Class
*/
class Doctor {
private readonly homedir: string;
private readonly ccsDir: string;
private readonly claudeDir: string;
private readonly results: HealthCheck;
private readonly ccsVersion: string;
constructor() {
this.homedir = os.homedir();
this.ccsDir = path.join(this.homedir, '.ccs');
this.claudeDir = path.join(this.homedir, '.claude');
this.results = new HealthCheck();
this.ccsVersion = packageJson.version;
}
/**
* Run all health checks
*/
async runAllChecks(): Promise<HealthCheck> {
console.log(colored('Running CCS Health Check...', 'cyan'));
console.log('');
// Store CCS version in details
this.results.details['CCS Version'] = { status: 'OK', info: `v${this.ccsVersion}` };
// Group 1: System
console.log(colored('System:', 'bold'));
await this.checkClaudeCli();
this.checkCcsDirectory();
console.log('');
// Group 2: Configuration
console.log(colored('Configuration:', 'bold'));
this.checkConfigFiles();
this.checkClaudeSettings();
console.log('');
// Group 3: Profiles & Delegation
console.log(colored('Profiles & Delegation:', 'bold'));
this.checkProfiles();
this.checkInstances();
this.checkDelegation();
console.log('');
// Group 4: System Health
console.log(colored('System Health:', 'bold'));
this.checkPermissions();
this.checkCcsSymlinks();
this.checkSettingsSymlinks();
console.log('');
this.showReport();
return this.results;
}
/**
* Check 1: Claude CLI availability
*/
private async checkClaudeCli(): Promise<void> {
const spinner = ora('Checking Claude CLI').start();
const claudeCli = detectClaudeCli();
if (!claudeCli) {
spinner.fail(` ${'Claude CLI'.padEnd(26)}${colored('[X]', 'red')} Not found in PATH`);
this.results.addCheck(
'Claude CLI',
'error',
'Claude CLI not found in PATH',
'Install from: https://docs.claude.com/en/docs/claude-code/installation',
{ status: 'ERROR', info: 'Not installed' }
);
return;
}
// Try to execute claude --version
try {
const result = await new Promise<string>((resolve, reject) => {
const child = spawn(claudeCli, ['--version'], {
stdio: 'pipe',
timeout: 5000
});
let output = '';
child.stdout?.on('data', (data: Buffer) => output += data);
child.stderr?.on('data', (data: Buffer) => output += data);
child.on('close', (code: number | null) => {
if (code === 0) resolve(output);
else reject(new Error('Exit code ' + code));
});
child.on('error', reject);
});
// Extract version from output
const versionMatch = result.match(/(\d+\.\d+\.\d+)/);
const version = versionMatch ? versionMatch[1] : 'unknown';
spinner.succeed(` ${'Claude CLI'.padEnd(26)}${colored('[OK]', 'green')} ${claudeCli} (v${version})`);
this.results.addCheck('Claude CLI', 'success', `Found: ${claudeCli}`, undefined, {
status: 'OK',
info: `v${version} (${claudeCli})`
});
} catch (err) {
spinner.fail(` ${'Claude CLI'.padEnd(26)}${colored('[X]', 'red')} Not found or not working`);
this.results.addCheck(
'Claude CLI',
'error',
'Claude CLI not found or not working',
'Install from: https://docs.claude.com/en/docs/claude-code/installation',
{ status: 'ERROR', info: 'Not installed' }
);
}
}
/**
* Check 2: ~/.ccs/ directory
*/
private checkCcsDirectory(): void {
const spinner = ora('Checking ~/.ccs/ directory').start();
if (fs.existsSync(this.ccsDir)) {
spinner.succeed(` ${'CCS Directory'.padEnd(26)}${colored('[OK]', 'green')} ~/.ccs/`);
this.results.addCheck('CCS Directory', 'success', undefined, undefined, {
status: 'OK',
info: '~/.ccs/'
});
} else {
spinner.fail(` ${'CCS Directory'.padEnd(26)}${colored('[X]', 'red')} Not found`);
this.results.addCheck(
'CCS Directory',
'error',
'~/.ccs/ directory not found',
'Run: npm install -g @kaitranntt/ccs --force',
{ status: 'ERROR', info: 'Not found' }
);
}
}
/**
* Check 3: Config files
*/
private checkConfigFiles(): void {
const files = [
{ path: path.join(this.ccsDir, 'config.json'), name: 'config.json', key: 'config.json' },
{ path: path.join(this.ccsDir, 'glm.settings.json'), name: 'glm.settings.json', key: 'GLM Settings', profile: 'glm' },
{ path: path.join(this.ccsDir, 'kimi.settings.json'), name: 'kimi.settings.json', key: 'Kimi Settings', profile: 'kimi' }
];
const { DelegationValidator } = require('../utils/delegation-validator');
for (const file of files) {
const spinner = ora(`Checking ${file.name}`).start();
if (!fs.existsSync(file.path)) {
spinner.fail(` ${file.name.padEnd(26)}${colored('[X]', 'red')} Not found`);
this.results.addCheck(
file.name,
'error',
`${file.name} not found`,
'Run: npm install -g @kaitranntt/ccs --force',
{ status: 'ERROR', info: 'Not found' }
);
continue;
}
// Validate JSON
try {
const content = fs.readFileSync(file.path, 'utf8');
JSON.parse(content);
// Extract useful info based on file type
let info = 'Valid';
let status: 'OK' | 'WARN' = 'OK';
if (file.profile) {
// For settings files, check if API key is configured
const validation = DelegationValidator.validate(file.profile);
if (validation.valid) {
info = 'Key configured';
status = 'OK';
} else if (validation.error && validation.error.includes('placeholder')) {
info = 'Placeholder key (not configured)';
status = 'WARN';
} else {
info = 'Valid JSON';
status = 'OK';
}
}
const statusIcon = status === 'OK' ? colored('[OK]', 'green') : colored('[!]', 'yellow');
if (status === 'WARN') {
spinner.warn(` ${file.name.padEnd(26)}${statusIcon} ${info}`);
} else {
spinner.succeed(` ${file.name.padEnd(26)}${statusIcon} ${info}`);
}
this.results.addCheck(file.name, status === 'OK' ? 'success' : 'warning', undefined, undefined, {
status: status,
info: info
});
} catch (e) {
spinner.fail(` ${file.name.padEnd(26)}${colored('[X]', 'red')} Invalid JSON`);
this.results.addCheck(
file.name,
'error',
`Invalid JSON: ${(e as Error).message}`,
`Backup and recreate: mv ${file.path} ${file.path}.backup && npm install -g @kaitranntt/ccs --force`,
{ status: 'ERROR', info: 'Invalid JSON' }
);
}
}
}
/**
* Check 4: Claude settings
*/
private checkClaudeSettings(): void {
const spinner = ora('Checking ~/.claude/settings.json').start();
const settingsPath = path.join(this.claudeDir, 'settings.json');
if (!fs.existsSync(settingsPath)) {
spinner.warn(` ${'~/.claude/settings.json'.padEnd(26)}${colored('[!]', 'yellow')} Not found`);
this.results.addCheck(
'Claude Settings',
'warning',
'~/.claude/settings.json not found',
'Run: claude /login'
);
return;
}
// Validate JSON
try {
const content = fs.readFileSync(settingsPath, 'utf8');
JSON.parse(content);
spinner.succeed(` ${'~/.claude/settings.json'.padEnd(26)}${colored('[OK]', 'green')}`);
this.results.addCheck('Claude Settings', 'success');
} catch (e) {
spinner.warn(` ${'~/.claude/settings.json'.padEnd(26)}${colored('[!]', 'yellow')} Invalid JSON`);
this.results.addCheck(
'Claude Settings',
'warning',
`Invalid JSON: ${(e as Error).message}`,
'Run: claude /login'
);
}
}
/**
* Check 5: Profile configurations
*/
private checkProfiles(): void {
const spinner = ora('Checking profiles').start();
const configPath = path.join(this.ccsDir, 'config.json');
if (!fs.existsSync(configPath)) {
spinner.info(` ${'Profiles'.padEnd(26)}${colored('[SKIP]', 'cyan')} config.json not found`);
return;
}
try {
const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
if (!config.profiles || typeof config.profiles !== 'object') {
spinner.fail(` ${'Profiles'.padEnd(26)}${colored('[X]', 'red')} Missing profiles object`);
this.results.addCheck(
'Profiles',
'error',
'config.json missing profiles object',
'Run: npm install -g @kaitranntt/ccs --force',
{ status: 'ERROR', info: 'Missing profiles object' }
);
return;
}
const profileCount = Object.keys(config.profiles).length;
const profileNames = Object.keys(config.profiles).join(', ');
spinner.succeed(` ${'Profiles'.padEnd(26)}${colored('[OK]', 'green')} ${profileCount} configured (${profileNames})`);
this.results.addCheck('Profiles', 'success', `${profileCount} profiles configured`, undefined, {
status: 'OK',
info: `${profileCount} configured (${profileNames.length > 30 ? profileNames.substring(0, 27) + '...' : profileNames})`
});
} catch (e) {
spinner.fail(` ${'Profiles'.padEnd(26)}${colored('[X]', 'red')} ${(e as Error).message}`);
this.results.addCheck('Profiles', 'error', (e as Error).message, undefined, {
status: 'ERROR',
info: (e as Error).message
});
}
}
/**
* Check 6: Instance directories (account-based profiles)
*/
private checkInstances(): void {
const spinner = ora('Checking instances').start();
const instancesDir = path.join(this.ccsDir, 'instances');
if (!fs.existsSync(instancesDir)) {
spinner.info(` ${'Instances'.padEnd(26)}${colored('[i]', 'cyan')} No account profiles`);
this.results.addCheck('Instances', 'success', 'No account profiles configured');
return;
}
const instances = fs.readdirSync(instancesDir).filter(name => {
return fs.statSync(path.join(instancesDir, name)).isDirectory();
});
if (instances.length === 0) {
spinner.info(` ${'Instances'.padEnd(26)}${colored('[i]', 'cyan')} No account profiles`);
this.results.addCheck('Instances', 'success', 'No account profiles');
return;
}
spinner.succeed(` ${'Instances'.padEnd(26)}${colored('[OK]', 'green')} ${instances.length} account profiles`);
this.results.addCheck('Instances', 'success', `${instances.length} account profiles`);
}
/**
* Check 7: Delegation system
*/
private checkDelegation(): void {
const spinner = ora('Checking delegation').start();
// Check if delegation commands exist in ~/.ccs/.claude/commands/
const ccsClaudeCommandsDir = path.join(this.ccsDir, '.claude', 'commands');
const hasCcsCommand = fs.existsSync(path.join(ccsClaudeCommandsDir, 'ccs.md'));
const hasContinueCommand = fs.existsSync(path.join(ccsClaudeCommandsDir, 'ccs', 'continue.md'));
if (!hasCcsCommand || !hasContinueCommand) {
spinner.warn(` ${'Delegation'.padEnd(26)}${colored('[!]', 'yellow')} Not installed`);
this.results.addCheck(
'Delegation',
'warning',
'Delegation commands not found',
'Install with: npm install -g @kaitranntt/ccs --force',
{ status: 'WARN', info: 'Not installed' }
);
return;
}
// Check profile validity using DelegationValidator
const { DelegationValidator } = require('../utils/delegation-validator');
const readyProfiles: string[] = [];
for (const profile of ['glm', 'kimi']) {
const validation = DelegationValidator.validate(profile);
if (validation.valid) {
readyProfiles.push(profile);
}
}
if (readyProfiles.length === 0) {
spinner.warn(` ${'Delegation'.padEnd(26)}${colored('[!]', 'yellow')} No profiles ready`);
this.results.addCheck(
'Delegation',
'warning',
'Delegation installed but no profiles configured',
'Configure profiles with valid API keys (not placeholders)',
{ status: 'WARN', info: 'No profiles ready' }
);
return;
}
spinner.succeed(` ${'Delegation'.padEnd(26)}${colored('[OK]', 'green')} ${readyProfiles.length} profiles ready (${readyProfiles.join(', ')})`);
this.results.addCheck(
'Delegation',
'success',
`${readyProfiles.length} profile(s) ready: ${readyProfiles.join(', ')}`,
undefined,
{ status: 'OK', info: `${readyProfiles.length} profiles ready` }
);
}
/**
* Check 8: File permissions
*/
private checkPermissions(): void {
const spinner = ora('Checking permissions').start();
const testFile = path.join(this.ccsDir, '.permission-test');
try {
fs.writeFileSync(testFile, 'test', 'utf8');
fs.unlinkSync(testFile);
spinner.succeed(` ${'Permissions'.padEnd(26)}${colored('[OK]', 'green')} Write access verified`);
this.results.addCheck('Permissions', 'success', undefined, undefined, {
status: 'OK',
info: 'Write access verified'
});
} catch (e) {
spinner.fail(` ${'Permissions'.padEnd(26)}${colored('[X]', 'red')} Cannot write to ~/.ccs/`);
this.results.addCheck(
'Permissions',
'error',
'Cannot write to ~/.ccs/',
'Fix: sudo chown -R $USER ~/.ccs ~/.claude && chmod 755 ~/.ccs ~/.claude',
{ status: 'ERROR', info: 'Cannot write to ~/.ccs/' }
);
}
}
/**
* Check 9: CCS symlinks to ~/.claude/
*/
private checkCcsSymlinks(): void {
const spinner = ora('Checking CCS symlinks').start();
try {
const ClaudeSymlinkManager = require('../utils/claude-symlink-manager');
const manager = new ClaudeSymlinkManager();
const health = manager.checkHealth();
if (health.healthy) {
const itemCount = manager.ccsItems.length;
spinner.succeed(` ${'CCS Symlinks'.padEnd(26)}${colored('[OK]', 'green')} ${itemCount}/${itemCount} items linked`);
this.results.addCheck('CCS Symlinks', 'success', 'All CCS items properly symlinked', undefined, {
status: 'OK',
info: `${itemCount}/${itemCount} items synced`
});
} else {
spinner.warn(` ${'CCS Symlinks'.padEnd(26)}${colored('[!]', 'yellow')} ${health.issues.length} issues found`);
this.results.addCheck(
'CCS Symlinks',
'warning',
health.issues.join(', '),
'Run: ccs sync',
{ status: 'WARN', info: `${health.issues.length} issues` }
);
}
} catch (e) {
spinner.warn(` ${'CCS Symlinks'.padEnd(26)}${colored('[!]', 'yellow')} Could not check`);
this.results.addCheck(
'CCS Symlinks',
'warning',
'Could not check CCS symlinks: ' + (e as Error).message,
'Run: ccs sync',
{ status: 'WARN', info: 'Could not check' }
);
}
}
/**
* Check 10: settings.json symlinks
*/
private checkSettingsSymlinks(): void {
const spinner = ora('Checking settings.json symlinks').start();
try {
const sharedDir = path.join(this.homedir, '.ccs', 'shared');
const sharedSettings = path.join(sharedDir, 'settings.json');
const claudeSettings = path.join(this.claudeDir, 'settings.json');
// Check shared settings exists and points to ~/.claude/
if (!fs.existsSync(sharedSettings)) {
spinner.warn(` ${'settings.json (shared)'.padEnd(26)}${colored('[!]', 'yellow')} Not found`);
this.results.addCheck(
'Settings Symlinks',
'warning',
'Shared settings.json not found',
'Run: ccs sync'
);
return;
}
const sharedStats = fs.lstatSync(sharedSettings);
if (!sharedStats.isSymbolicLink()) {
spinner.warn(` ${'settings.json (shared)'.padEnd(26)}${colored('[!]', 'yellow')} Not a symlink`);
this.results.addCheck(
'Settings Symlinks',
'warning',
'Shared settings.json is not a symlink',
'Run: ccs sync'
);
return;
}
const sharedTarget = fs.readlinkSync(sharedSettings);
const resolvedShared = path.resolve(path.dirname(sharedSettings), sharedTarget);
if (resolvedShared !== claudeSettings) {
spinner.warn(` ${'settings.json (shared)'.padEnd(26)}${colored('[!]', 'yellow')} Wrong target`);
this.results.addCheck(
'Settings Symlinks',
'warning',
`Points to ${resolvedShared} instead of ${claudeSettings}`,
'Run: ccs sync'
);
return;
}
// Check each instance
const instancesDir = path.join(this.ccsDir, 'instances');
if (!fs.existsSync(instancesDir)) {
spinner.succeed(` ${'settings.json'.padEnd(26)}${colored('[OK]', 'green')} Shared symlink valid`);
this.results.addCheck('Settings Symlinks', 'success', 'Shared symlink valid', undefined, {
status: 'OK',
info: 'Shared symlink valid'
});
return;
}
const instances = fs.readdirSync(instancesDir).filter(name => {
return fs.statSync(path.join(instancesDir, name)).isDirectory();
});
let broken = 0;
for (const instance of instances) {
const instancePath = path.join(instancesDir, instance);
const instanceSettings = path.join(instancePath, 'settings.json');
if (!fs.existsSync(instanceSettings)) {
broken++;
continue;
}
try {
const stats = fs.lstatSync(instanceSettings);
if (!stats.isSymbolicLink()) {
broken++;
continue;
}
const target = fs.readlinkSync(instanceSettings);
const resolved = path.resolve(path.dirname(instanceSettings), target);
if (resolved !== sharedSettings) {
broken++;
}
} catch (err) {
broken++;
}
}
if (broken > 0) {
spinner.warn(` ${'settings.json'.padEnd(26)}${colored('[!]', 'yellow')} ${broken} broken instance(s)`);
this.results.addCheck(
'Settings Symlinks',
'warning',
`${broken} instance(s) have broken symlinks`,
'Run: ccs sync',
{ status: 'WARN', info: `${broken} broken instance(s)` }
);
} else {
spinner.succeed(` ${'settings.json'.padEnd(26)}${colored('[OK]', 'green')} ${instances.length} instance(s) valid`);
this.results.addCheck('Settings Symlinks', 'success', 'All instance symlinks valid', undefined, {
status: 'OK',
info: `${instances.length} instance(s) valid`
});
}
} catch (err) {
spinner.warn(` ${'settings.json'.padEnd(26)}${colored('[!]', 'yellow')} Check failed`);
this.results.addCheck(
'Settings Symlinks',
'warning',
`Failed to check: ${(err as Error).message}`,
'Run: ccs sync',
{ status: 'WARN', info: 'Check failed' }
);
}
}
/**
* Show health check report
*/
private showReport(): void {
console.log('');
// Calculate exact table width to match header bars
// colWidths: [20, 10, 35] = 65 + borders (4) = 69 total
const tableWidth = 69;
const headerBar = '═'.repeat(tableWidth);
console.log(colored(headerBar, 'cyan'));
console.log(colored(' Health Check Summary', 'bold'));
console.log(colored(headerBar, 'cyan'));
// Create summary table with detailed information
const table = new Table({
head: [colored('Component', 'cyan'), colored('Status', 'cyan'), colored('Details', 'cyan')],
colWidths: [20, 10, 35],
wordWrap: true,
chars: {
'top': '═', 'top-mid': '╤', 'top-left': '╔', 'top-right': '╗',
'bottom': '═', 'bottom-mid': '╧', 'bottom-left': '╚', 'bottom-right': '╝',
'left': '║', 'left-mid': '╟', 'mid': '─', 'mid-mid': '┼',
'right': '║', 'right-mid': '╢', 'middle': '│'
}
});
// Populate table with collected details
for (const [component, detail] of Object.entries(this.results.details)) {
const statusColor = detail.status === 'OK' ? 'green' : detail.status === 'ERROR' ? 'red' : 'yellow';
table.push([
component,
colored(detail.status, statusColor),
detail.info || ''
]);
}
console.log(table.toString());
console.log('');
// Show errors and warnings if present
if (this.results.hasErrors()) {
console.log(colored('Errors:', 'red'));
this.results.errors.forEach(err => {
console.log(` [X] ${err.name}: ${err.message}`);
if (err.fix) {
console.log(` Fix: ${err.fix}`);
}
});
console.log('');
}
if (this.results.hasWarnings()) {
console.log(colored('Warnings:', 'yellow'));
this.results.warnings.forEach(warn => {
console.log(` [!] ${warn.name}: ${warn.message}`);
if (warn.fix) {
console.log(` Fix: ${warn.fix}`);
}
});
console.log('');
}
// Final status
if (this.results.isHealthy() && !this.results.hasWarnings()) {
console.log(colored('[OK] All checks passed! Your CCS installation is healthy.', 'green'));
} else if (this.results.hasErrors()) {
console.log(colored('[X] Status: Installation has errors', 'red'));
console.log('Run suggested fixes above to resolve issues.');
} else {
console.log(colored('[OK] Status: Installation healthy (warnings only)', 'green'));
}
console.log('');
}
/**
* Generate JSON report
*/
generateJsonReport(): string {
return JSON.stringify({
timestamp: new Date().toISOString(),
platform: process.platform,
nodeVersion: process.version,
ccsVersion: packageJson.version,
checks: this.results.checks,
errors: this.results.errors,
warnings: this.results.warnings,
healthy: this.results.isHealthy()
}, null, 2);
}
}
export default Doctor;
src/management/instance-manager.ts
+193
View File
@@ -0,0 +1,193 @@
/**
* Instance Manager (Simplified)
*
* Manages isolated Claude CLI instances per profile for concurrent sessions.
* Each instance is an isolated CLAUDE_CONFIG_DIR where users login directly.
* No credential copying/encryption - Claude manages credentials per instance.
*/
import * as fs from 'fs';
import * as path from 'path';
import * as os from 'os';
import SharedManager from './shared-manager';
/**
* Instance Manager Class
*/
class InstanceManager {
private readonly instancesDir: string;
private readonly sharedManager: SharedManager;
constructor() {
this.instancesDir = path.join(os.homedir(), '.ccs', 'instances');
this.sharedManager = new SharedManager();
}
/**
* Ensure instance exists for profile (lazy init only)
*/
ensureInstance(profileName: string): string {
const instancePath = this.getInstancePath(profileName);
// Lazy initialization
if (!fs.existsSync(instancePath)) {
this.initializeInstance(profileName, instancePath);
}
// Validate structure (auto-fix missing dirs)
this.validateInstance(instancePath);
return instancePath;
}
/**
* Get instance path for profile
*/
getInstancePath(profileName: string): string {
const safeName = this.sanitizeName(profileName);
return path.join(this.instancesDir, safeName);
}
/**
* Initialize new instance directory
*/
private initializeInstance(profileName: string, instancePath: string): void {
try {
// Create base directory
fs.mkdirSync(instancePath, { recursive: true, mode: 0o700 });
// Create Claude-expected subdirectories (profile-specific only)
const subdirs = [
'session-env',
'todos',
'logs',
'file-history',
'shell-snapshots',
'debug',
'.anthropic'
];
subdirs.forEach(dir => {
const dirPath = path.join(instancePath, dir);
if (!fs.existsSync(dirPath)) {
fs.mkdirSync(dirPath, { recursive: true, mode: 0o700 });
}
});
// Symlink shared directories (Phase 1: commands, skills)
this.sharedManager.linkSharedDirectories(instancePath);
// Copy global configs if exist (settings.json only)
this.copyGlobalConfigs(instancePath);
} catch (error) {
throw new Error(`Failed to initialize instance for ${profileName}: ${(error as Error).message}`);
}
}
/**
* Validate instance directory structure (auto-fix missing directories)
*/
private validateInstance(instancePath: string): void {
// Check required directories (auto-create if missing for migration)
const requiredDirs = [
'session-env',
'todos',
'logs',
'file-history',
'shell-snapshots',
'debug',
'.anthropic'
];
for (const dir of requiredDirs) {
const dirPath = path.join(instancePath, dir);
if (!fs.existsSync(dirPath)) {
// Auto-create missing directory (migration from older versions)
fs.mkdirSync(dirPath, { recursive: true, mode: 0o700 });
}
}
// Note: Credentials managed by Claude CLI in instance (no validation needed)
}
/**
* Delete instance for profile
*/
deleteInstance(profileName: string): void {
const instancePath = this.getInstancePath(profileName);
if (!fs.existsSync(instancePath)) {
return;
}
// Recursive delete
fs.rmSync(instancePath, { recursive: true, force: true });
}
/**
* List all instance names
*/
listInstances(): string[] {
if (!fs.existsSync(this.instancesDir)) {
return [];
}
return fs.readdirSync(this.instancesDir)
.filter(name => {
const instancePath = path.join(this.instancesDir, name);
return fs.statSync(instancePath).isDirectory();
});
}
/**
* Check if instance exists for profile
*/
hasInstance(profileName: string): boolean {
const instancePath = this.getInstancePath(profileName);
return fs.existsSync(instancePath);
}
/**
* Copy global configs to instance (optional)
*/
private copyGlobalConfigs(_instancePath: string): void {
// No longer needed - settings.json now symlinked via SharedManager
// Keeping method for backward compatibility (empty implementation)
// Can be removed in future major version
}
/**
* Copy directory recursively - Currently unused
*/
/*
private copyDirectory(src: string, dest: string): void {
if (!fs.existsSync(dest)) {
fs.mkdirSync(dest, { recursive: true, mode: 0o700 });
}
const entries = fs.readdirSync(src, { withFileTypes: true });
for (const entry of entries) {
const srcPath = path.join(src, entry.name);
const destPath = path.join(dest, entry.name);
if (entry.isDirectory()) {
this.copyDirectory(srcPath, destPath);
} else {
fs.copyFileSync(srcPath, destPath);
}
}
}
*/
/**
* Sanitize profile name for filesystem
*/
private sanitizeName(name: string): string {
// Replace unsafe characters with dash
return name.replace(/[^a-zA-Z0-9_-]/g, '-').toLowerCase();
}
}
export { InstanceManager };
export default InstanceManager;
src/management/recovery-manager.ts
+140
View File
@@ -0,0 +1,140 @@
/**
* Auto-recovery for missing or corrupted configuration
*/
import * as fs from 'fs';
import * as path from 'path';
import * as os from 'os';
/**
* Recovery Manager Class
*/
class RecoveryManager {
private readonly homedir: string;
private readonly ccsDir: string;
private readonly claudeDir: string;
private recovered: string[];
constructor() {
this.homedir = os.homedir();
this.ccsDir = path.join(this.homedir, '.ccs');
this.claudeDir = path.join(this.homedir, '.claude');
this.recovered = [];
}
/**
* Ensure ~/.ccs/ directory exists
*/
ensureCcsDirectory(): boolean {
if (!fs.existsSync(this.ccsDir)) {
fs.mkdirSync(this.ccsDir, { recursive: true, mode: 0o755 });
this.recovered.push('Created ~/.ccs/ directory');
return true;
}
return false;
}
/**
* Ensure ~/.ccs/config.json exists with defaults
*/
ensureConfigJson(): boolean {
const configPath = path.join(this.ccsDir, 'config.json');
// Check if exists and valid
if (fs.existsSync(configPath)) {
try {
const content = fs.readFileSync(configPath, 'utf8');
JSON.parse(content); // Validate JSON
return false; // No recovery needed
} catch (e) {
// Corrupted - backup and recreate
const backupPath = `${configPath}.backup.${Date.now()}`;
fs.renameSync(configPath, backupPath);
this.recovered.push(`Backed up corrupted config.json to ${path.basename(backupPath)}`);
}
}
// Create default config
const defaultConfig = {
profiles: {
glm: '~/.ccs/glm.settings.json',
kimi: '~/.ccs/kimi.settings.json',
default: '~/.claude/settings.json'
}
};
const tmpPath = `${configPath}.tmp`;
fs.writeFileSync(tmpPath, JSON.stringify(defaultConfig, null, 2) + '\n', 'utf8');
fs.renameSync(tmpPath, configPath);
this.recovered.push('Created ~/.ccs/config.json');
return true;
}
/**
* Ensure ~/.claude/settings.json exists
*/
ensureClaudeSettings(): boolean {
const claudeSettingsPath = path.join(this.claudeDir, 'settings.json');
// Create ~/.claude/ if missing
if (!fs.existsSync(this.claudeDir)) {
fs.mkdirSync(this.claudeDir, { recursive: true, mode: 0o755 });
this.recovered.push('Created ~/.claude/ directory');
}
// Create settings.json if missing
if (!fs.existsSync(claudeSettingsPath)) {
const tmpPath = `${claudeSettingsPath}.tmp`;
fs.writeFileSync(tmpPath, '{}\n', 'utf8');
fs.renameSync(tmpPath, claudeSettingsPath);
this.recovered.push('Created ~/.claude/settings.json');
return true;
}
return false;
}
/**
* Run all recovery operations
*/
recoverAll(): boolean {
this.recovered = [];
this.ensureCcsDirectory();
this.ensureConfigJson();
this.ensureClaudeSettings();
return this.recovered.length > 0;
}
/**
* Get recovery summary
*/
getRecoverySummary(): string[] {
return this.recovered;
}
/**
* Show recovery hints
*/
showRecoveryHints(): void {
if (this.recovered.length === 0) return;
console.log('');
console.log('[i] Auto-recovery completed:');
this.recovered.forEach(msg => console.log(` - ${msg}`));
// Show login hint if created Claude settings
if (this.recovered.some(msg => msg.includes('settings.json'))) {
console.log('');
console.log('[i] Next step: Login to Claude CLI');
console.log(' Run: claude /login');
}
console.log('');
}
}
export default RecoveryManager;
src/management/shared-manager.ts
+407
View File
@@ -0,0 +1,407 @@
/**
* SharedManager - Manages symlinked shared directories for CCS
* v3.2.0: Symlink-based architecture
*
* Purpose: Eliminates duplication by symlinking:
* ~/.claude/ ← ~/.ccs/shared/ ← instance/
*/
import * as fs from 'fs';
import * as path from 'path';
import * as os from 'os';
interface SharedItem {
name: string;
type: 'directory' | 'file';
}
/**
* SharedManager Class
*/
class SharedManager {
private readonly homeDir: string;
private readonly sharedDir: string;
private readonly claudeDir: string;
private readonly instancesDir: string;
private readonly sharedItems: SharedItem[];
constructor() {
this.homeDir = os.homedir();
this.sharedDir = path.join(this.homeDir, '.ccs', 'shared');
this.claudeDir = path.join(this.homeDir, '.claude');
this.instancesDir = path.join(this.homeDir, '.ccs', 'instances');
this.sharedItems = [
{ name: 'commands', type: 'directory' },
{ name: 'skills', type: 'directory' },
{ name: 'agents', type: 'directory' },
{ name: 'plugins', type: 'directory' },
{ name: 'settings.json', type: 'file' }
];
}
/**
* Detect circular symlink before creation
*/
private detectCircularSymlink(target: string, linkPath: string): boolean {
// Check if target exists and is symlink
if (!fs.existsSync(target)) {
return false;
}
try {
const stats = fs.lstatSync(target);
if (!stats.isSymbolicLink()) {
return false;
}
// Resolve target's link
const targetLink = fs.readlinkSync(target);
const resolvedTarget = path.resolve(path.dirname(target), targetLink);
// Check if target points back to our shared dir or link path
const sharedDir = path.join(this.homeDir, '.ccs', 'shared');
if (resolvedTarget.startsWith(sharedDir) || resolvedTarget === linkPath) {
console.log(`[!] Circular symlink detected: ${target} → ${resolvedTarget}`);
return true;
}
} catch (err) {
// If can't read, assume not circular
return false;
}
return false;
}
/**
* Ensure shared directories exist as symlinks to ~/.claude/
* Creates ~/.claude/ structure if missing
*/
ensureSharedDirectories(): void {
// Create ~/.claude/ if missing
if (!fs.existsSync(this.claudeDir)) {
console.log('[i] Creating ~/.claude/ directory structure');
fs.mkdirSync(this.claudeDir, { recursive: true, mode: 0o700 });
}
// Create shared directory
if (!fs.existsSync(this.sharedDir)) {
fs.mkdirSync(this.sharedDir, { recursive: true, mode: 0o700 });
}
// Create symlinks ~/.ccs/shared/* → ~/.claude/*
for (const item of this.sharedItems) {
const claudePath = path.join(this.claudeDir, item.name);
const sharedPath = path.join(this.sharedDir, item.name);
// Create in ~/.claude/ if missing
if (!fs.existsSync(claudePath)) {
if (item.type === 'directory') {
fs.mkdirSync(claudePath, { recursive: true, mode: 0o700 });
} else if (item.type === 'file') {
// Create empty settings.json if missing
fs.writeFileSync(claudePath, JSON.stringify({}, null, 2), 'utf8');
}
}
// Check for circular symlink
if (this.detectCircularSymlink(claudePath, sharedPath)) {
console.log(`[!] Skipping ${item.name}: circular symlink detected`);
continue;
}
// If already a symlink pointing to correct target, skip
if (fs.existsSync(sharedPath)) {
try {
const stats = fs.lstatSync(sharedPath);
if (stats.isSymbolicLink()) {
const currentTarget = fs.readlinkSync(sharedPath);
const resolvedTarget = path.resolve(path.dirname(sharedPath), currentTarget);
if (resolvedTarget === claudePath) {
continue; // Already correct
}
}
} catch (err) {
// Continue to recreate
}
// Remove existing file/directory/link
if (item.type === 'directory') {
fs.rmSync(sharedPath, { recursive: true, force: true });
} else {
fs.unlinkSync(sharedPath);
}
}
// Create symlink
try {
const symlinkType = item.type === 'directory' ? 'dir' : 'file';
fs.symlinkSync(claudePath, sharedPath, symlinkType);
} catch (err) {
// Windows fallback: copy
if (process.platform === 'win32') {
if (item.type === 'directory') {
this.copyDirectoryFallback(claudePath, sharedPath);
} else if (item.type === 'file') {
fs.copyFileSync(claudePath, sharedPath);
}
console.log(`[!] Symlink failed for ${item.name}, copied instead (enable Developer Mode)`);
} else {
throw err;
}
}
}
}
/**
* Link shared directories to instance
*/
linkSharedDirectories(instancePath: string): void {
this.ensureSharedDirectories();
for (const item of this.sharedItems) {
const linkPath = path.join(instancePath, item.name);
const targetPath = path.join(this.sharedDir, item.name);
// Remove existing file/directory/link
if (fs.existsSync(linkPath)) {
if (item.type === 'directory') {
fs.rmSync(linkPath, { recursive: true, force: true });
} else {
fs.unlinkSync(linkPath);
}
}
// Create symlink
try {
const symlinkType = item.type === 'directory' ? 'dir' : 'file';
fs.symlinkSync(targetPath, linkPath, symlinkType);
} catch (err) {
// Windows fallback
if (process.platform === 'win32') {
if (item.type === 'directory') {
this.copyDirectoryFallback(targetPath, linkPath);
} else if (item.type === 'file') {
fs.copyFileSync(targetPath, linkPath);
}
console.log(`[!] Symlink failed for ${item.name}, copied instead (enable Developer Mode)`);
} else {
throw err;
}
}
}
}
/**
* Migrate from v3.1.1 (copied data in ~/.ccs/shared/) to v3.2.0 (symlinks to ~/.claude/)
* Runs once on upgrade
*/
migrateFromV311(): void {
// Check if migration already done (shared dirs are symlinks)
const commandsPath = path.join(this.sharedDir, 'commands');
if (fs.existsSync(commandsPath)) {
try {
if (fs.lstatSync(commandsPath).isSymbolicLink()) {
return; // Already migrated
}
} catch (err) {
// Continue with migration
}
}
console.log('[i] Migrating from v3.1.1 to v3.2.0...');
// Ensure ~/.claude/ exists
if (!fs.existsSync(this.claudeDir)) {
fs.mkdirSync(this.claudeDir, { recursive: true, mode: 0o700 });
}
// Copy user modifications from ~/.ccs/shared/ to ~/.claude/
for (const item of this.sharedItems) {
const sharedPath = path.join(this.sharedDir, item.name);
const claudePath = path.join(this.claudeDir, item.name);
if (!fs.existsSync(sharedPath)) continue;
try {
const stats = fs.lstatSync(sharedPath);
// Handle directories
if (item.type === 'directory' && stats.isDirectory()) {
// Create claude dir if missing
if (!fs.existsSync(claudePath)) {
fs.mkdirSync(claudePath, { recursive: true, mode: 0o700 });
}
// Copy files from shared to claude (preserve user modifications)
const entries = fs.readdirSync(sharedPath, { withFileTypes: true });
let copied = 0;
for (const entry of entries) {
const src = path.join(sharedPath, entry.name);
const dest = path.join(claudePath, entry.name);
// Skip if already exists in claude
if (fs.existsSync(dest)) continue;
if (entry.isDirectory()) {
fs.cpSync(src, dest, { recursive: true });
} else {
fs.copyFileSync(src, dest);
}
copied++;
}
if (copied > 0) {
console.log(`[OK] Migrated ${copied} ${item.name} to ~/.claude/${item.name}`);
}
}
// Handle files (settings.json)
else if (item.type === 'file' && stats.isFile()) {
// Only copy if ~/.claude/ version doesn't exist
if (!fs.existsSync(claudePath)) {
fs.copyFileSync(sharedPath, claudePath);
console.log(`[OK] Migrated ${item.name} to ~/.claude/${item.name}`);
}
}
} catch (err) {
console.log(`[!] Failed to migrate ${item.name}: ${(err as Error).message}`);
}
}
// Now run ensureSharedDirectories to create symlinks
this.ensureSharedDirectories();
// Update all instances to use new symlinks
if (fs.existsSync(this.instancesDir)) {
try {
const instances = fs.readdirSync(this.instancesDir);
for (const instance of instances) {
const instancePath = path.join(this.instancesDir, instance);
try {
if (fs.statSync(instancePath).isDirectory()) {
this.linkSharedDirectories(instancePath);
}
} catch (err) {
console.log(`[!] Failed to update instance ${instance}: ${(err as Error).message}`);
}
}
} catch (err) {
// No instances to update
}
}
console.log('[OK] Migration to v3.2.0 complete');
}
/**
* Migrate existing instances from isolated to shared settings.json (v4.4+)
* Runs once on upgrade
*/
migrateToSharedSettings(): void {
console.log('[i] Migrating instances to shared settings.json...');
// Ensure ~/.claude/settings.json exists (authoritative source)
const claudeSettings = path.join(this.claudeDir, 'settings.json');
if (!fs.existsSync(claudeSettings)) {
// Create empty settings if missing
fs.writeFileSync(claudeSettings, JSON.stringify({}, null, 2), 'utf8');
console.log('[i] Created ~/.claude/settings.json');
}
// Ensure shared settings.json symlink exists
this.ensureSharedDirectories();
// Migrate each instance
if (!fs.existsSync(this.instancesDir)) {
console.log('[i] No instances to migrate');
return;
}
const instances = fs.readdirSync(this.instancesDir).filter(name => {
const instancePath = path.join(this.instancesDir, name);
return fs.statSync(instancePath).isDirectory();
});
let migrated = 0;
let skipped = 0;
for (const instance of instances) {
const instancePath = path.join(this.instancesDir, instance);
const instanceSettings = path.join(instancePath, 'settings.json');
try {
// Check if already symlink
if (fs.existsSync(instanceSettings)) {
const stats = fs.lstatSync(instanceSettings);
if (stats.isSymbolicLink()) {
skipped++;
continue; // Already migrated
}
// Backup existing settings
const backup = instanceSettings + '.pre-shared-migration';
if (!fs.existsSync(backup)) {
fs.copyFileSync(instanceSettings, backup);
console.log(`[i] Backed up ${instance}/settings.json`);
}
// Remove old settings.json
fs.unlinkSync(instanceSettings);
}
// Create symlink via SharedManager
const sharedSettings = path.join(this.sharedDir, 'settings.json');
try {
fs.symlinkSync(sharedSettings, instanceSettings, 'file');
migrated++;
} catch (err) {
// Windows fallback
if (process.platform === 'win32') {
fs.copyFileSync(sharedSettings, instanceSettings);
console.log(`[!] Symlink failed for ${instance}, copied instead`);
migrated++;
} else {
throw err;
}
}
} catch (err) {
console.log(`[!] Failed to migrate ${instance}: ${(err as Error).message}`);
}
}
console.log(`[OK] Migrated ${migrated} instance(s), skipped ${skipped}`);
}
/**
* Copy directory as fallback (Windows without Developer Mode)
*/
private copyDirectoryFallback(src: string, dest: string): void {
if (!fs.existsSync(src)) {
fs.mkdirSync(src, { recursive: true, mode: 0o700 });
return;
}
if (!fs.existsSync(dest)) {
fs.mkdirSync(dest, { recursive: true, mode: 0o700 });
}
const entries = fs.readdirSync(src, { withFileTypes: true });
for (const entry of entries) {
const srcPath = path.join(src, entry.name);
const destPath = path.join(dest, entry.name);
if (entry.isDirectory()) {
this.copyDirectoryFallback(srcPath, destPath);
} else {
fs.copyFileSync(srcPath, destPath);
}
}
}
}
export default SharedManager;
src/types/cli.ts
+53
View File
@@ -0,0 +1,53 @@
import { SpawnOptions as NodeSpawnOptions } from 'child_process';
/**
* CLI Runtime Types
*/
/**
* Parsed CLI arguments
*/
export interface ParsedArgs {
profile?: string; // Profile name (glm, kimi, work, etc.)
prompt?: string; // -p/--prompt flag value
isDelegation: boolean; // -p flag present
isContinue: boolean; // :continue suffix detected
remainingArgs: string[]; // Args to pass to Claude CLI
}
/**
* Spawn options for Claude CLI execution
*/
export interface ClaudeSpawnOptions extends NodeSpawnOptions {
stdio: 'inherit' | 'pipe';
windowsHide?: boolean;
shell?: boolean;
env: NodeJS.ProcessEnv;
}
/**
* Platform detection
*/
export type Platform = 'darwin' | 'linux' | 'win32';
/**
* Claude CLI detection result
*/
export interface ClaudeCliInfo {
path: string;
version?: string;
isWindows: boolean;
needsShell: boolean; // .cmd/.bat/.ps1 files
}
/**
* Exit codes
*/
export enum ExitCode {
SUCCESS = 0,
GENERIC_ERROR = 1,
CLAUDE_NOT_FOUND = 127,
CONFIG_ERROR = 2,
DELEGATION_ERROR = 3,
TIMEOUT = 124,
}
src/types/config.ts
+71
View File
@@ -0,0 +1,71 @@
/**
* CCS Configuration Types
* Source: ~/.ccs/config.json
*/
/**
* Profile configuration mapping
* Maps profile names to settings.json paths
*/
export interface ProfilesConfig {
[profileName: string]: string; // Path to settings.json
}
/**
* Main CCS configuration
* Located at: ~/.ccs/config.json
*/
export interface Config {
profiles: ProfilesConfig;
}
/**
* Environment variables (string-only constraint)
* CRITICAL: All values MUST be strings (no booleans/objects)
* Reason: PowerShell crashes on non-string values
*/
export type EnvValue = string;
export type EnvVars = Record<string, EnvValue>;
/**
* Claude CLI settings.json structure
* Located at: ~/.claude/settings.json or profile-specific
*/
export interface Settings {
env?: EnvVars;
[key: string]: unknown; // Allow other settings
}
/**
* Profile metadata (profiles.json)
* Located at: ~/.ccs/profiles.json
*/
export interface ProfileMetadata {
type?: string; // Profile type (e.g., 'account')
created: string; // Creation time
last_used?: string | null; // Last usage time
}
export interface ProfilesRegistry {
profiles: Record<string, ProfileMetadata>;
}
/**
* Type guards
*/
export function isConfig(obj: unknown): obj is Config {
return (
typeof obj === 'object' &&
obj !== null &&
'profiles' in obj &&
typeof obj.profiles === 'object'
);
}
export function isSettings(obj: unknown): obj is Settings {
if (typeof obj !== 'object' || obj === null) return false;
if (!('env' in obj)) return true; // env is optional
if (typeof obj.env !== 'object' || obj.env === null) return false;
// Validate all env values are strings
return Object.values(obj.env).every(v => typeof v === 'string');
}
src/types/delegation.ts
+67
View File
@@ -0,0 +1,67 @@
/**
* Delegation System Types
*/
/**
* Session metadata for delegation tracking
*/
export interface SessionMetadata {
id: string; // Unique session ID
profile: string; // Target profile (glm, kimi)
prompt: string; // Initial prompt
workingDir: string; // CWD at execution time
startTime: number; // Unix timestamp (ms)
endTime?: number; // Unix timestamp (ms)
exitCode?: number; // Process exit code
duration?: number; // Execution duration (seconds)
}
/**
* Delegation session (persisted)
*/
export interface DelegationSession {
metadata: SessionMetadata;
turns: number; // Conversation turns
lastPrompt?: string; // Last user prompt (for :continue)
}
/**
* Sessions registry
* Located at: ~/.ccs/delegation-sessions.json
*/
export interface DelegationSessionsRegistry {
sessions: Record<string, DelegationSession>; // sessionId → session
lastSessionId?: string; // Most recent session ID
}
/**
* Execution result
*/
export interface ExecutionResult {
exitCode: number;
duration: number; // Seconds
workingDir: string;
sessionId: string;
profile: string;
model?: string; // Model name from settings
cost?: number; // Estimated cost (if available)
turns: number;
}
/**
* Real-time output event
*/
export interface ToolEvent {
type: 'tool';
tool: string; // Tool name (Write, Edit, Bash, etc.)
args: string; // Simplified args (file path, command, etc.)
timestamp: number;
}
export interface OutputEvent {
type: 'stdout' | 'stderr';
data: string;
timestamp: number;
}
export type DelegationEvent = ToolEvent | OutputEvent;
src/types/external.d.ts
Vendored
+47
View File
@@ -0,0 +1,47 @@
/**
* Type shims for incomplete external dependencies
*/
declare module 'cli-table3' {
interface TableOptions {
head?: string[];
colWidths?: number[];
colAligns?: ('left' | 'center' | 'right')[];
style?: {
head?: string[];
border?: string[];
};
chars?: Record<string, string>;
}
class Table extends Array {
constructor(options?: TableOptions);
toString(): string;
}
export = Table;
}
// ora v9 has types but we want to ensure compatibility
declare module 'ora' {
interface Options {
text?: string;
color?: 'black' | 'red' | 'green' | 'yellow' | 'blue' | 'magenta' | 'cyan' | 'white';
spinner?: string | object;
stream?: NodeJS.WritableStream;
}
interface Ora {
start(text?: string): Ora;
stop(): Ora;
succeed(text?: string): Ora;
fail(text?: string): Ora;
warn(text?: string): Ora;
info(text?: string): Ora;
text: string;
color: string;
}
function ora(options?: string | Options): Ora;
export = ora;
}
src/types/glmt.ts
+105
View File
@@ -0,0 +1,105 @@
/**
* GLMT Proxy Types
* For Anthropic ↔ OpenAI format transformation
*/
/**
* Anthropic API types
*/
export interface AnthropicMessage {
role: 'user' | 'assistant';
content: string | ContentBlock[];
}
export interface ContentBlock {
type: 'text' | 'thinking' | 'tool_use' | 'tool_result';
text?: string;
id?: string;
name?: string;
input?: Record<string, unknown>;
tool_use_id?: string;
content?: string;
}
export interface AnthropicRequest {
model: string;
messages: AnthropicMessage[];
max_tokens: number;
temperature?: number;
tools?: AnthropicTool[];
stream?: boolean;
thinking?: {
type: 'enabled' | 'disabled';
budget_tokens?: number;
};
}
export interface AnthropicTool {
name: string;
description: string;
input_schema: Record<string, unknown>;
}
/**
* OpenAI API types (Z.AI endpoint)
*/
export interface OpenAIMessage {
role: 'system' | 'user' | 'assistant' | 'tool';
content: string | null;
reasoning_content?: string; // Thinking blocks
tool_calls?: OpenAIToolCall[];
tool_call_id?: string;
name?: string;
}
export interface OpenAIToolCall {
id: string;
type: 'function';
function: {
name: string;
arguments: string; // JSON string
};
}
export interface OpenAIRequest {
model: string;
messages: OpenAIMessage[];
max_completion_tokens?: number;
temperature?: number;
tools?: OpenAITool[];
stream?: boolean;
reasoning?: boolean; // Enable thinking mode
}
export interface OpenAITool {
type: 'function';
function: {
name: string;
description: string;
parameters: Record<string, unknown>;
};
}
/**
* SSE (Server-Sent Events) types
*/
export interface SSEEvent {
event?: string;
data?: string;
id?: string;
}
export interface DeltaChunk {
reasoning_content?: string;
content?: string;
tool_calls?: OpenAIToolCall[];
}
/**
* Transformation context
*/
export interface TransformationContext {
verbose: boolean;
debugLog: boolean;
streaming: boolean;
}
src/types/index.ts
+59
View File
@@ -0,0 +1,59 @@
/**
* CCS Type Definitions
* Single entry point for all types
*/
// Config types
export type {
Config,
ProfilesConfig,
Settings,
EnvVars,
EnvValue,
ProfileMetadata,
ProfilesRegistry,
} from './config';
export { isConfig, isSettings } from './config';
// CLI types
export type {
ParsedArgs,
ClaudeSpawnOptions,
Platform,
ClaudeCliInfo,
} from './cli';
export { ExitCode } from './cli';
// Delegation types
export type {
SessionMetadata,
DelegationSession,
DelegationSessionsRegistry,
ExecutionResult,
ToolEvent,
OutputEvent,
DelegationEvent,
} from './delegation';
// GLMT types
export type {
AnthropicMessage,
ContentBlock,
AnthropicRequest,
AnthropicTool,
OpenAIMessage,
OpenAIToolCall,
OpenAIRequest,
OpenAITool,
SSEEvent,
DeltaChunk,
TransformationContext,
} from './glmt';
// Utility types
export { ErrorCode, LogLevel } from './utils';
export type {
ColorName,
TerminalInfo,
Result,
} from './utils';
src/types/utils.ts
+37
View File
@@ -0,0 +1,37 @@
/**
* Utility Types
*/
// Re-export from error-codes for consistency
export { ERROR_CODES, ErrorCode, getErrorDocUrl, getErrorCategory } from '../utils/error-codes';
/**
* Log levels
*/
export enum LogLevel {
DEBUG = 'debug',
INFO = 'info',
WARN = 'warn',
ERROR = 'error',
}
/**
* Color codes (TTY-aware)
*/
export type ColorName = 'red' | 'green' | 'yellow' | 'blue' | 'cyan' | 'bold' | 'reset';
/**
* Terminal capabilities
*/
export interface TerminalInfo {
isTTY: boolean;
supportsColor: boolean;
noColorEnv: boolean; // NO_COLOR env var set
}
/**
* Helper result types
*/
export type Result<T, E = Error> =
| { ok: true; value: T }
| { ok: false; error: E };
src/utils/claude-detector.ts
+91
View File
@@ -0,0 +1,91 @@
import * as fs from 'fs';
import { execSync } from 'child_process';
import { expandPath } from './helpers';
import { ClaudeCliInfo } from '../types';
/**
* Detect Claude CLI executable
*/
export function detectClaudeCli(): string | null {
// Priority 1: CCS_CLAUDE_PATH environment variable (if user wants custom path)
if (process.env.CCS_CLAUDE_PATH) {
const ccsPath = expandPath(process.env.CCS_CLAUDE_PATH);
// Basic validation: file exists
if (fs.existsSync(ccsPath)) {
return ccsPath;
}
// Invalid CCS_CLAUDE_PATH - show warning and fall back to PATH
console.warn('[!] Warning: CCS_CLAUDE_PATH is set but file not found:', ccsPath);
console.warn(' Falling back to system PATH lookup...');
}
// Priority 2: Resolve 'claude' from PATH using which/where.exe
// This fixes Windows npm installation where spawn() can't resolve bare command names
// SECURITY: Commands are hardcoded literals with no user input - safe from injection
const isWindows = process.platform === 'win32';
try {
const cmd = isWindows ? 'where.exe claude' : 'which claude';
const result = execSync(cmd, {
encoding: 'utf8',
stdio: ['ignore', 'pipe', 'ignore'],
timeout: 5000 // 5 second timeout to prevent hangs
}).trim();
// where.exe may return multiple lines (all matches in PATH order)
const matches = result.split('\n').map(p => p.trim()).filter(p => p);
if (isWindows) {
// On Windows, prefer executables with extensions (.exe, .cmd, .bat)
// where.exe often returns file without extension first, then the actual .cmd wrapper
const withExtension = matches.find(p => /\.(exe|cmd|bat|ps1)$/i.test(p));
const claudePath = withExtension || matches[0];
if (claudePath && fs.existsSync(claudePath)) {
return claudePath;
}
} else {
// On Unix, first match is fine
const claudePath = matches[0];
if (claudePath && fs.existsSync(claudePath)) {
return claudePath;
}
}
} catch (err) {
// Command failed - claude not in PATH
// Fall through to return null
}
// Priority 3: Claude not found
return null;
}
/**
* Get detailed Claude CLI information
*/
export function getClaudeCliInfo(): ClaudeCliInfo | null {
const claudePath = detectClaudeCli();
if (!claudePath) {
return null;
}
const isWindows = process.platform === 'win32';
const needsShell = isWindows && /\.(cmd|bat|ps1)$/i.test(claudePath);
return {
path: claudePath,
isWindows,
needsShell
};
}
/**
* Show Claude not found error
*/
export function showClaudeNotFoundError(): never {
console.error('ERROR: Claude CLI not found in PATH');
console.error('Install from: https://docs.claude.com/en/docs/claude-code/installation');
process.exit(1);
}
src/utils/config-manager.ts
+113
View File
@@ -0,0 +1,113 @@
import * as fs from 'fs';
import * as path from 'path';
import * as os from 'os';
import { Config, isConfig, Settings, isSettings } from '../types';
import { expandPath } from './helpers';
import { error } from './helpers';
// TODO: Replace with proper imports after converting these files
// const { ErrorManager } = require('./error-manager');
// const RecoveryManager = require('./recovery-manager');
/**
* Get config file path
*/
export function getConfigPath(): string {
return process.env.CCS_CONFIG || path.join(os.homedir(), '.ccs', 'config.json');
}
/**
* Load and validate config.json
*/
export function loadConfig(): Config {
const configPath = getConfigPath();
if (!fs.existsSync(configPath)) {
// TODO: Add recovery manager logic
// const recovery = new RecoveryManager();
// recovery.ensureConfigJson();
error(`Config not found: ${configPath}`);
}
const raw = fs.readFileSync(configPath, 'utf8');
const parsed: unknown = JSON.parse(raw);
if (!isConfig(parsed)) {
error(`Invalid config format: ${configPath}`);
}
return parsed;
}
/**
* Load and validate settings.json
*/
export function loadSettings(settingsPath: string): Settings {
if (!fs.existsSync(settingsPath)) {
error(`Settings not found: ${settingsPath}`);
}
const raw = fs.readFileSync(settingsPath, 'utf8');
const parsed: unknown = JSON.parse(raw);
if (!isSettings(parsed)) {
error(`Invalid settings format: ${settingsPath}`);
}
return parsed;
}
/**
* Read and parse config (legacy compatibility)
*/
export function readConfig(): Config {
return loadConfig();
}
/**
* Get settings path for profile
*/
export function getSettingsPath(profile: string): string {
const config = readConfig();
// Get settings path
const settingsPath = config.profiles[profile];
if (!settingsPath) {
const availableProfiles = Object.keys(config.profiles);
const profileList = availableProfiles.map(p => ` - ${p}`);
error(`Profile '${profile}' not found. Available profiles:\n${profileList.join('\n')}`);
}
// Expand path
const expandedPath = expandPath(settingsPath);
// Validate settings file exists
if (!fs.existsSync(expandedPath)) {
// Auto-create if it's ~/.claude/settings.json
if (expandedPath.includes('.claude') && expandedPath.endsWith('settings.json')) {
// TODO: Add recovery manager logic
// const recovery = new RecoveryManager();
// recovery.ensureClaudeSettings();
console.log('[i] Auto-created missing settings file');
} else {
error(`Settings file not found: ${expandedPath}`);
}
}
// Validate settings file is valid JSON
try {
const settingsContent = fs.readFileSync(expandedPath, 'utf8');
JSON.parse(settingsContent);
} catch (e) {
if (e instanceof Error) {
error(`Invalid JSON in settings file: ${expandedPath} - ${e.message}`);
} else {
error(`Invalid JSON in settings file: ${expandedPath}`);
}
}
return expandedPath;
}
src/utils/delegation-validator.ts
+159
View File
@@ -0,0 +1,159 @@
#!/usr/bin/env node
import * as fs from 'fs';
import * as path from 'path';
import * as os from 'os';
interface ValidationResult {
valid: boolean;
error?: string;
suggestion?: string;
settingsPath?: string;
apiKey?: string;
}
/**
* Validates delegation profiles for CCS delegation system
* Ensures profiles exist and have valid API keys configured
*/
export class DelegationValidator {
/**
* Validate a delegation profile
* @param profileName - Name of profile to validate (e.g., 'glm', 'kimi')
* @returns Validation result { valid: boolean, error?: string, settingsPath?: string }
*/
static validate(profileName: string): ValidationResult {
const homeDir = os.homedir();
const settingsPath = path.join(homeDir, '.ccs', `${profileName}.settings.json`);
// Check if profile directory exists
if (!fs.existsSync(settingsPath)) {
return {
valid: false,
error: `Profile not found: ${profileName}`,
suggestion: `Profile settings missing at: ${settingsPath}\n\n` +
`To set up ${profileName} profile:\n` +
` 1. Copy base settings: cp config/base-${profileName}.settings.json ~/.ccs/${profileName}.settings.json\n` +
` 2. Edit settings: Edit ~/.ccs/${profileName}.settings.json\n` +
` 3. Set your API key in ANTHROPIC_AUTH_TOKEN field`
};
}
// Read and parse settings.json
let settings: any;
try {
const settingsContent = fs.readFileSync(settingsPath, 'utf8');
settings = JSON.parse(settingsContent);
} catch (error) {
return {
valid: false,
error: `Failed to parse settings.json for ${profileName}`,
suggestion: `Settings file is corrupted or invalid JSON.\n\n` +
`Location: ${settingsPath}\n` +
`Parse error: ${(error as Error).message}\n\n` +
`Fix: Restore from base config:\n` +
` cp config/base-${profileName}.settings.json ~/.ccs/${profileName}.settings.json`
};
}
// Validate API key exists and is not default
const apiKey = settings.env?.ANTHROPIC_AUTH_TOKEN;
if (!apiKey) {
return {
valid: false,
error: `API key not configured for ${profileName}`,
suggestion: `Missing ANTHROPIC_AUTH_TOKEN in settings.\n\n` +
`Edit: ${settingsPath}\n` +
`Set: env.ANTHROPIC_AUTH_TOKEN to your API key`
};
}
// Check for default placeholder values
const defaultPlaceholders = [
'YOUR_GLM_API_KEY_HERE',
'YOUR_KIMI_API_KEY_HERE',
'YOUR_API_KEY_HERE',
'your-api-key-here',
'PLACEHOLDER'
];
if (defaultPlaceholders.some(placeholder => apiKey.includes(placeholder))) {
return {
valid: false,
error: `Default API key placeholder detected for ${profileName}`,
suggestion: `API key is still set to default placeholder.\n\n` +
`To configure your profile:\n` +
` 1. Edit: ${settingsPath}\n` +
` 2. Replace ANTHROPIC_AUTH_TOKEN with your actual API key\n\n` +
`Get API key:\n` +
` GLM: https://z.ai/manage-apikey/apikey-list\n` +
` Kimi: https://platform.moonshot.cn/console/api-keys`
};
}
// Validation passed
return {
valid: true,
settingsPath,
apiKey: apiKey.substring(0, 8) + '...' // Show first 8 chars for verification
};
}
/**
* Format validation error for display
* @param result - Validation result from validate()
* @returns Formatted error message
*/
static formatError(result: ValidationResult): string {
if (result.valid) {
return '';
}
let message = `\n[X] ${result.error}\n\n`;
if (result.suggestion) {
message += `${result.suggestion}\n`;
}
return message;
}
/**
* Check if profile is delegation-ready (shorthand)
* @param profileName - Profile to check
* @returns True if ready for delegation
*/
static isReady(profileName: string): boolean {
const result = this.validate(profileName);
return result.valid;
}
/**
* Get all delegation-ready profiles
* @returns List of profile names ready for delegation
*/
static getReadyProfiles(): string[] {
const homeDir = os.homedir();
const ccsDir = path.join(homeDir, '.ccs');
if (!fs.existsSync(ccsDir)) {
return [];
}
const profiles: string[] = [];
const entries = fs.readdirSync(ccsDir, { withFileTypes: true });
// Look for *.settings.json files
for (const entry of entries) {
if (entry.isFile() && entry.name.endsWith('.settings.json')) {
const profileName = entry.name.replace('.settings.json', '');
if (this.isReady(profileName)) {
profiles.push(profileName);
}
}
}
return profiles;
}
}
src/utils/error-codes.ts
+61
View File
@@ -0,0 +1,61 @@
/**
* CCS Error Codes
* Documentation: ../../docs/errors/README.md
*/
export const ERROR_CODES = {
// Configuration Errors (E100-E199)
CONFIG_MISSING: 'E101',
CONFIG_INVALID_JSON: 'E102',
CONFIG_INVALID_PROFILE: 'E103',
// Profile Management Errors (E200-E299)
PROFILE_NOT_FOUND: 'E104',
PROFILE_ALREADY_EXISTS: 'E105',
PROFILE_CANNOT_DELETE_DEFAULT: 'E106',
PROFILE_INVALID_NAME: 'E107',
// Claude CLI Detection Errors (E300-E399)
CLAUDE_NOT_FOUND: 'E301',
CLAUDE_VERSION_INCOMPATIBLE: 'E302',
CLAUDE_EXECUTION_FAILED: 'E303',
// Network/API Errors (E400-E499)
GLMT_PROXY_TIMEOUT: 'E401',
API_KEY_MISSING: 'E402',
API_AUTH_FAILED: 'E403',
API_RATE_LIMIT: 'E404',
// File System Errors (E500-E599)
FS_CANNOT_CREATE_DIR: 'E501',
FS_CANNOT_WRITE_FILE: 'E502',
FS_CANNOT_READ_FILE: 'E503',
FS_INSTANCE_NOT_FOUND: 'E504',
// Internal Errors (E900-E999)
INTERNAL_ERROR: 'E900',
INVALID_STATE: 'E901'
} as const;
export type ErrorCode = typeof ERROR_CODES[keyof typeof ERROR_CODES];
/**
* Error code documentation URL generator
*/
export function getErrorDocUrl(errorCode: ErrorCode): string {
return `https://github.com/kaitranntt/ccs/blob/main/docs/errors/README.md#${errorCode.toLowerCase()}`;
}
/**
* Get error category from code
*/
export function getErrorCategory(errorCode: ErrorCode): string {
const code = parseInt(errorCode.substring(1));
if (code >= 100 && code < 200) return 'Configuration';
if (code >= 200 && code < 300) return 'Profile Management';
if (code >= 300 && code < 400) return 'Claude CLI Detection';
if (code >= 400 && code < 500) return 'Network/API';
if (code >= 500 && code < 600) return 'File System';
if (code >= 900 && code < 1000) return 'Internal';
return 'Unknown';
}
src/utils/error-manager.ts
+159
View File
@@ -0,0 +1,159 @@
import { colored } from './helpers';
import { ERROR_CODES, getErrorDocUrl, ErrorCode } from './error-codes';
/**
* Error types with structured messages (Legacy - kept for compatibility)
*/
export const ErrorTypes = {
NO_CLAUDE_CLI: 'NO_CLAUDE_CLI',
MISSING_SETTINGS: 'MISSING_SETTINGS',
INVALID_CONFIG: 'INVALID_CONFIG',
UNKNOWN_PROFILE: 'UNKNOWN_PROFILE',
PERMISSION_DENIED: 'PERMISSION_DENIED',
GENERIC: 'GENERIC'
} as const;
export type ErrorType = typeof ErrorTypes[keyof typeof ErrorTypes];
/**
* Enhanced error manager with context-aware messages
*/
export class ErrorManager {
/**
* Show error code and documentation URL
*/
static showErrorCode(errorCode: ErrorCode): void {
console.error(colored(`Error: ${errorCode}`, 'yellow'));
console.error(colored(getErrorDocUrl(errorCode), 'yellow'));
console.error('');
}
/**
* Show Claude CLI not found error
*/
static showClaudeNotFound(): void {
console.error('');
console.error(colored('[X] Claude CLI not found', 'red'));
console.error('');
console.error('CCS requires Claude CLI to be installed and available in PATH.');
console.error('');
console.error(colored('Solutions:', 'yellow'));
console.error(' 1. Install Claude CLI:');
console.error(' https://docs.claude.com/en/docs/claude-code/installation');
console.error('');
console.error(' 2. Verify installation:');
console.error(' command -v claude (Unix)');
console.error(' Get-Command claude (Windows)');
console.error('');
console.error(' 3. Custom path (if installed elsewhere):');
console.error(' export CCS_CLAUDE_PATH="/path/to/claude"');
console.error('');
this.showErrorCode(ERROR_CODES.CLAUDE_NOT_FOUND);
}
/**
* Show settings file not found error
*/
static showSettingsNotFound(settingsPath: string): void {
const isClaudeSettings = settingsPath.includes('.claude') && settingsPath.endsWith('settings.json');
console.error('');
console.error(colored('[X] Settings file not found', 'red'));
console.error('');
console.error(`File: ${settingsPath}`);
console.error('');
if (isClaudeSettings) {
console.error('This file is auto-created when you login to Claude CLI.');
console.error('');
console.error(colored('Solutions:', 'yellow'));
console.error(` echo '{}' > ${settingsPath}`);
console.error(' claude /login');
console.error('');
console.error('Why: Newer Claude CLI versions require explicit login.');
} else {
console.error(colored('Solutions:', 'yellow'));
console.error(' npm install -g @kaitranntt/ccs --force');
console.error('');
console.error('This will recreate missing profile settings.');
}
console.error('');
this.showErrorCode(ERROR_CODES.CONFIG_INVALID_PROFILE);
}
/**
* Show invalid configuration error
*/
static showInvalidConfig(configPath: string, errorDetail: string): void {
console.error('');
console.error(colored('[X] Configuration invalid', 'red'));
console.error('');
console.error(`File: ${configPath}`);
console.error(`Issue: ${errorDetail}`);
console.error('');
console.error(colored('Solutions:', 'yellow'));
console.error(' # Backup corrupted file');
console.error(` mv ${configPath} ${configPath}.backup`);
console.error('');
console.error(' # Reinstall CCS');
console.error(' npm install -g @kaitranntt/ccs --force');
console.error('');
console.error('Your profile settings will be preserved.');
console.error('');
this.showErrorCode(ERROR_CODES.CONFIG_INVALID_JSON);
}
/**
* Show profile not found error
*/
static showProfileNotFound(
profileName: string,
availableProfiles: string[],
suggestions: string[] = []
): void {
console.error('');
console.error(colored(`[X] Profile '${profileName}' not found`, 'red'));
console.error('');
if (suggestions && suggestions.length > 0) {
console.error(colored('Did you mean:', 'yellow'));
suggestions.forEach(s => console.error(` ${s}`));
console.error('');
}
console.error(colored('Available profiles:', 'cyan'));
availableProfiles.forEach(line => console.error(` ${line}`));
console.error('');
console.error(colored('Solutions:', 'yellow'));
console.error(' # Use existing profile');
console.error(' ccs <profile> "your prompt"');
console.error('');
console.error(' # Create new account profile');
console.error(' ccs auth create <name>');
console.error('');
this.showErrorCode(ERROR_CODES.PROFILE_NOT_FOUND);
}
/**
* Show permission denied error
*/
static showPermissionDenied(path: string): void {
console.error('');
console.error(colored('[X] Permission denied', 'red'));
console.error('');
console.error(`Cannot write to: ${path}`);
console.error('');
console.error(colored('Solutions:', 'yellow'));
console.error(' # Fix ownership');
console.error(' sudo chown -R $USER ~/.ccs ~/.claude');
console.error('');
console.error(' # Fix permissions');
console.error(' chmod 755 ~/.ccs ~/.claude');
console.error('');
console.error(' # Retry installation');
console.error(' npm install -g @kaitranntt/ccs --force');
console.error('');
this.showErrorCode(ERROR_CODES.FS_CANNOT_WRITE_FILE);
}
}
src/utils/helpers.ts
+140
View File
@@ -0,0 +1,140 @@
import * as path from 'path';
import * as os from 'os';
import { ColorName, TerminalInfo } from '../types';
/**
* TTY-aware color detection (matches lib/ccs bash logic)
*/
function getColors(): Record<ColorName, string> {
const forcedColors = process.env.FORCE_COLOR;
const noColor = process.env.NO_COLOR;
const isTTY = process.stdout.isTTY === true; // Must be explicitly true
const useColors = !!forcedColors || (isTTY && !noColor);
if (useColors) {
return {
red: '\x1b[0;31m',
yellow: '\x1b[1;33m',
cyan: '\x1b[0;36m',
green: '\x1b[0;32m',
blue: '\x1b[0;34m',
bold: '\x1b[1m',
reset: '\x1b[0m'
};
}
return { red: '', yellow: '', cyan: '', green: '', blue: '', bold: '', reset: '' };
}
// Colors object (dynamic)
export const colors = getColors();
/**
* Helper: Apply color to text (returns plain text if colors disabled)
*/
export function colored(text: string, colorName: ColorName = 'reset'): string {
const currentColors = getColors();
const color = currentColors[colorName] || '';
return color ? `${color}${text}${currentColors.reset}` : text;
}
/**
* Simple error formatting
*/
export function error(message: string): never {
console.error(`ERROR: ${message}`);
console.error('Try: npm install -g @kaitranntt/ccs --force');
process.exit(1);
}
/**
* Path expansion (~ and env vars)
*/
export function expandPath(pathStr: string): string {
// Handle tilde expansion
if (pathStr.startsWith('~/') || pathStr.startsWith('~\\')) {
pathStr = path.join(os.homedir(), pathStr.slice(2));
}
// Expand environment variables (Windows and Unix)
pathStr = pathStr.replace(/\$\{([^}]+)\}/g, (_, name) => process.env[name] || '');
pathStr = pathStr.replace(/\$([A-Z_][A-Z0-9_]*)/gi, (_, name) => process.env[name] || '');
// Windows %VAR% style
if (process.platform === 'win32') {
pathStr = pathStr.replace(/%([^%]+)%/g, (_, name) => process.env[name] || '');
}
return path.normalize(pathStr);
}
/**
* Detect terminal capabilities
*/
export function getTerminalInfo(): TerminalInfo {
return {
isTTY: process.stdout.isTTY ?? false,
supportsColor: (process.stdout.isTTY ?? false) && !process.env.NO_COLOR,
noColorEnv: !!process.env.NO_COLOR,
};
}
/**
* Calculate Levenshtein distance between two strings
*/
export function levenshteinDistance(a: string, b: string): number {
if (a.length === 0) return b.length;
if (b.length === 0) return a.length;
const matrix: number[][] = [];
// Initialize first row and column
for (let i = 0; i <= b.length; i++) {
matrix[i] = [i];
}
for (let j = 0; j <= a.length; j++) {
matrix[0][j] = j;
}
// Fill in the rest of the matrix
for (let i = 1; i <= b.length; i++) {
for (let j = 1; j <= a.length; j++) {
if (b.charAt(i - 1) === a.charAt(j - 1)) {
matrix[i][j] = matrix[i - 1][j - 1];
} else {
matrix[i][j] = Math.min(
matrix[i - 1][j - 1] + 1, // substitution
matrix[i][j - 1] + 1, // insertion
matrix[i - 1][j] + 1 // deletion
);
}
}
}
return matrix[b.length][a.length];
}
/**
* Find similar strings using fuzzy matching
*/
export function findSimilarStrings(
target: string,
candidates: string[],
maxDistance: number = 2
): string[] {
const targetLower = target.toLowerCase();
const matches = candidates
.map(candidate => ({
name: candidate,
distance: levenshteinDistance(targetLower, candidate.toLowerCase())
}))
.filter(item => item.distance <= maxDistance && item.distance > 0)
.sort((a, b) => a.distance - b.distance)
.slice(0, 3) // Show at most 3 suggestions
.map(item => item.name);
return matches;
}
src/utils/prompt.ts
+130
View File
@@ -0,0 +1,130 @@
import * as readline from 'readline';
/**
* Interactive Prompt Utilities (NO external dependencies)
*
* Features:
* - TTY detection (auto-confirm in non-TTY)
* - --yes flag support for automation
* - --no-input flag support for CI
* - Safe defaults (N for destructive actions)
* - Input validation with retry
*/
interface ConfirmOptions {
default?: boolean;
}
interface InputOptions {
default?: string;
validate?: (value: string) => string | null;
}
export class InteractivePrompt {
/**
* Ask for confirmation
*/
static async confirm(message: string, options: ConfirmOptions = {}): Promise<boolean> {
const { default: defaultValue = false } = options;
// Check for --yes flag (automation) - always returns true
if (process.env.CCS_YES === '1' || process.argv.includes('--yes') || process.argv.includes('-y')) {
return true;
}
// Check for --no-input flag (CI)
if (process.env.CCS_NO_INPUT === '1' || process.argv.includes('--no-input')) {
throw new Error('Interactive input required but --no-input specified');
}
// Non-TTY: use default
if (!process.stdin.isTTY) {
return defaultValue;
}
// Interactive prompt
const rl = readline.createInterface({
input: process.stdin,
output: process.stderr,
terminal: true
});
const promptText = defaultValue
? `${message} [Y/n]: `
: `${message} [y/N]: `;
return new Promise((resolve) => {
rl.question(promptText, (answer: string) => {
rl.close();
const normalized = answer.trim().toLowerCase();
// Empty answer: use default
if (normalized === '') {
resolve(defaultValue);
return;
}
// Valid answers
if (normalized === 'y' || normalized === 'yes') {
resolve(true);
return;
}
if (normalized === 'n' || normalized === 'no') {
resolve(false);
return;
}
// Invalid input: retry
console.error('[!] Please answer y or n');
resolve(InteractivePrompt.confirm(message, options));
});
});
}
/**
* Get text input from user
*/
static async input(message: string, options: InputOptions = {}): Promise<string> {
const { default: defaultValue = '', validate = null } = options;
// Non-TTY: use default or error
if (!process.stdin.isTTY) {
if (defaultValue) {
return defaultValue;
}
throw new Error('Interactive input required but stdin is not a TTY');
}
const rl = readline.createInterface({
input: process.stdin,
output: process.stderr,
terminal: true
});
const promptText = defaultValue
? `${message} [${defaultValue}]: `
: `${message}: `;
return new Promise((resolve) => {
rl.question(promptText, (answer: string) => {
rl.close();
const value = answer.trim() || defaultValue;
// Validate input if validator provided
if (validate) {
const error = validate(value);
if (error) {
console.error(`[!] ${error}`);
resolve(InteractivePrompt.input(message, options));
return;
}
}
resolve(value);
});
});
}
}
src/utils/shell-completion.ts
+263
View File
@@ -0,0 +1,263 @@
import * as fs from 'fs';
import * as path from 'path';
import * as os from 'os';
// import { execSync } from 'child_process'; // Currently unused
type ShellType = 'bash' | 'zsh' | 'fish' | 'powershell' | null;
interface InstallResult {
success: boolean;
alreadyInstalled?: boolean;
message?: string;
reload?: string;
}
/**
* Shell Completion Installer
* Auto-configures shell completion for bash, zsh, fish, PowerShell
*/
export class ShellCompletionInstaller {
private homeDir: string;
private ccsDir: string;
private completionDir: string;
private scriptsDir: string;
constructor() {
this.homeDir = os.homedir();
this.ccsDir = path.join(this.homeDir, '.ccs');
this.completionDir = path.join(this.ccsDir, 'completions');
this.scriptsDir = path.join(__dirname, '../../scripts/completion');
}
/**
* Detect current shell
*/
detectShell(): ShellType {
const shell = process.env.SHELL || '';
if (shell.includes('bash')) return 'bash';
if (shell.includes('zsh')) return 'zsh';
if (shell.includes('fish')) return 'fish';
if (process.platform === 'win32') return 'powershell';
return null;
}
/**
* Ensure completion files are in ~/.ccs/completions/
*/
ensureCompletionFiles(): void {
if (!fs.existsSync(this.completionDir)) {
fs.mkdirSync(this.completionDir, { recursive: true });
}
// Copy completion scripts
const files = ['ccs.bash', 'ccs.zsh', 'ccs.fish', 'ccs.ps1'];
files.forEach(file => {
const src = path.join(this.scriptsDir, file);
const dest = path.join(this.completionDir, file);
if (fs.existsSync(src)) {
fs.copyFileSync(src, dest);
}
});
}
/**
* Safely create directory, checking for file conflicts
*/
private ensureDirectory(dirPath: string): void {
if (fs.existsSync(dirPath)) {
const stat = fs.statSync(dirPath);
if (!stat.isDirectory()) {
throw new Error(
`Cannot create directory: ${dirPath} exists but is a file.\n` +
`Please remove or rename this file and try again.`
);
}
// Directory exists, nothing to do
return;
}
// Check parent directories recursively
const parentDir = path.dirname(dirPath);
if (parentDir !== dirPath) {
this.ensureDirectory(parentDir);
}
// Create the directory
fs.mkdirSync(dirPath);
}
/**
* Install bash completion
*/
private installBash(): InstallResult {
const rcFile = path.join(this.homeDir, '.bashrc');
const completionPath = path.join(this.completionDir, 'ccs.bash');
if (!fs.existsSync(completionPath)) {
throw new Error('Completion file not found. Please reinstall CCS.');
}
const marker = '# CCS shell completion';
const sourceCmd = `source "${completionPath}"`;
const block = `\n${marker}\n${sourceCmd}\n`;
// Check if already installed
if (fs.existsSync(rcFile)) {
const content = fs.readFileSync(rcFile, 'utf8');
if (content.includes(marker)) {
return { success: true, alreadyInstalled: true };
}
}
// Append to .bashrc
fs.appendFileSync(rcFile, block);
return {
success: true,
message: `Added to ${rcFile}`,
reload: 'source ~/.bashrc'
};
}
/**
* Install zsh completion
*/
private installZsh(): InstallResult {
const rcFile = path.join(this.homeDir, '.zshrc');
const completionPath = path.join(this.completionDir, 'ccs.zsh');
const zshCompDir = path.join(this.homeDir, '.zsh', 'completion');
if (!fs.existsSync(completionPath)) {
throw new Error('Completion file not found. Please reinstall CCS.');
}
// Create zsh completion directory (with file conflict checking)
this.ensureDirectory(zshCompDir);
// Copy to zsh completion directory
const destFile = path.join(zshCompDir, '_ccs');
fs.copyFileSync(completionPath, destFile);
const marker = '# CCS shell completion';
const setupCmds = [
'fpath=(~/.zsh/completion $fpath)',
'autoload -Uz compinit && compinit'
];
const block = `\n${marker}\n${setupCmds.join('\n')}\n`;
// Check if already installed
if (fs.existsSync(rcFile)) {
const content = fs.readFileSync(rcFile, 'utf8');
if (content.includes(marker)) {
return { success: true, alreadyInstalled: true };
}
}
// Append to .zshrc
fs.appendFileSync(rcFile, block);
return {
success: true,
message: `Added to ${rcFile}`,
reload: 'source ~/.zshrc'
};
}
/**
* Install fish completion
*/
private installFish(): InstallResult {
const completionPath = path.join(this.completionDir, 'ccs.fish');
const fishCompDir = path.join(this.homeDir, '.config', 'fish', 'completions');
if (!fs.existsSync(completionPath)) {
throw new Error('Completion file not found. Please reinstall CCS.');
}
// Create fish completion directory (with file conflict checking)
this.ensureDirectory(fishCompDir);
// Copy to fish completion directory (fish auto-loads from here)
const destFile = path.join(fishCompDir, 'ccs.fish');
fs.copyFileSync(completionPath, destFile);
return {
success: true,
message: `Installed to ${destFile}`,
reload: 'Fish auto-loads completions (no reload needed)'
};
}
/**
* Install PowerShell completion
*/
private installPowerShell(): InstallResult {
const profilePath = process.env.PROFILE || path.join(
this.homeDir,
'Documents',
'PowerShell',
'Microsoft.PowerShell_profile.ps1'
);
const completionPath = path.join(this.completionDir, 'ccs.ps1');
if (!fs.existsSync(completionPath)) {
throw new Error('Completion file not found. Please reinstall CCS.');
}
const marker = '# CCS shell completion';
const sourceCmd = `. "${completionPath.replace(/\\/g, '\\\\')}"`;
const block = `\n${marker}\n${sourceCmd}\n`;
// Create profile directory if needed (with file conflict checking)
const profileDir = path.dirname(profilePath);
this.ensureDirectory(profileDir);
// Check if already installed
if (fs.existsSync(profilePath)) {
const content = fs.readFileSync(profilePath, 'utf8');
if (content.includes(marker)) {
return { success: true, alreadyInstalled: true };
}
}
// Append to PowerShell profile
fs.appendFileSync(profilePath, block);
return {
success: true,
message: `Added to ${profilePath}`,
reload: '. $PROFILE'
};
}
/**
* Install for detected or specified shell
*/
install(shell: ShellType = null): InstallResult {
const targetShell = shell || this.detectShell();
if (!targetShell) {
throw new Error('Could not detect shell. Please specify: --bash, --zsh, --fish, or --powershell');
}
// Ensure completion files exist
this.ensureCompletionFiles();
// Install for target shell
switch (targetShell) {
case 'bash':
return this.installBash();
case 'zsh':
return this.installZsh();
case 'fish':
return this.installFish();
case 'powershell':
return this.installPowerShell();
default:
throw new Error(`Unsupported shell: ${targetShell}`);
}
}
}
tsconfig.json
+57
View File
@@ -0,0 +1,57 @@
{
"compilerOptions": {
// Output
"outDir": "./dist",
"rootDir": "./src",
"sourceMap": true,
// Module system
"module": "commonjs",
"target": "ES2020",
"lib": ["ES2020"],
// Module resolution
"moduleResolution": "node",
"esModuleInterop": true,
"allowSyntheticDefaultImports": true,
"resolveJsonModule": true,
"skipLibCheck": true,
// Type checking (start strict)
"strict": true,
"noImplicitAny": true,
"strictNullChecks": true,
"strictFunctionTypes": true,
"strictPropertyInitialization": true,
"noImplicitThis": true,
"alwaysStrict": true,
// Additional checks
"noUnusedLocals": true,
"noUnusedParameters": true,
"noImplicitReturns": true,
"noFallthroughCasesInSwitch": true,
// Output options
"declaration": true,
"declarationMap": true,
"removeComments": false,
"preserveConstEnums": true,
// Interop
"forceConsistentCasingInFileNames": true,
// Performance
"incremental": true
},
"include": [
"src/**/*"
],
"exclude": [
"node_modules",
"dist",
"tests",
"lib",
"scripts"
]
}