@kaitranntt/ccs 5.11.0 → 5.12.0

package/dist/web-server/health-service.js

@@ -2,7 +2,8 @@
 /**
  * Health Check Service (Phase 06)
  *
- * Runs health checks for CCS dashboard: Claude CLI, config files, CLIProxy binary.
+ * Runs comprehensive health checks for CCS dashboard matching `ccs doctor` output.
+ * Groups: System, Configuration, Profiles & Delegation, System Health, CLIProxy
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -27,54 +28,124 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fixHealthIssue = exports.runHealthChecks = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const os = __importStar(require("os"));
 const child_process_1 = require("child_process");
 const config_manager_1 = require("../utils/config-manager");
 const cliproxy_1 = require("../cliproxy");
+const claude_detector_1 = require("../utils/claude-detector");
+const port_utils_1 = require("../utils/port-utils");
+const package_json_1 = __importDefault(require("../../package.json"));
 /**
  * Run all health checks and return report
  */
-function runHealthChecks() {
-    const checks = [];
-    // Check 1: Claude CLI
-    checks.push(checkClaudeCli());
-    // Check 2: Config file
-    checks.push(checkConfigFile());
-    // Check 3: Profiles file
-    checks.push(checkProfilesFile());
-    // Check 4: CLIProxy binary
-    checks.push(checkCliproxy());
-    // Check 5: CCS directory
-    checks.push(checkCcsDirectory());
+async function runHealthChecks() {
+    const homedir = os.homedir();
+    const ccsDir = (0, config_manager_1.getCcsDir)();
+    const claudeDir = path.join(homedir, '.claude');
+    const version = package_json_1.default.version;
+    const groups = [];
+    // Group 1: System
+    const systemChecks = [];
+    systemChecks.push(await checkClaudeCli());
+    systemChecks.push(checkCcsDirectory(ccsDir));
+    groups.push({ id: 'system', name: 'System', icon: 'Monitor', checks: systemChecks });
+    // Group 2: Configuration
+    const configChecks = [];
+    configChecks.push(checkConfigFile());
+    configChecks.push(...checkSettingsFiles(ccsDir));
+    configChecks.push(checkClaudeSettings(claudeDir));
+    groups.push({
+        id: 'configuration',
+        name: 'Configuration',
+        icon: 'Settings',
+        checks: configChecks,
+    });
+    // Group 3: Profiles & Delegation
+    const profileChecks = [];
+    profileChecks.push(checkProfiles(ccsDir));
+    profileChecks.push(checkInstances(ccsDir));
+    profileChecks.push(checkDelegation(ccsDir));
+    groups.push({
+        id: 'profiles',
+        name: 'Profiles & Delegation',
+        icon: 'Users',
+        checks: profileChecks,
+    });
+    // Group 4: System Health
+    const healthChecks = [];
+    healthChecks.push(checkPermissions(ccsDir));
+    healthChecks.push(checkCcsSymlinks());
+    healthChecks.push(checkSettingsSymlinks(homedir, ccsDir, claudeDir));
+    groups.push({
+        id: 'system-health',
+        name: 'System Health',
+        icon: 'Shield',
+        checks: healthChecks,
+    });
+    // Group 5: CLIProxy
+    const cliproxyChecks = [];
+    cliproxyChecks.push(checkCliproxyBinary());
+    cliproxyChecks.push(checkCliproxyConfig());
+    cliproxyChecks.push(...checkOAuthProviders());
+    cliproxyChecks.push(await checkCliproxyPort());
+    groups.push({
+        id: 'cliproxy',
+        name: 'CLIProxy (OAuth)',
+        icon: 'Zap',
+        checks: cliproxyChecks,
+    });
+    // Flatten all checks for backward compatibility
+    const allChecks = groups.flatMap((g) => g.checks);
     // Calculate summary
     const summary = {
-        total: checks.length,
-        passed: checks.filter((c) => c.status === 'ok').length,
-        warnings: checks.filter((c) => c.status === 'warning').length,
-        errors: checks.filter((c) => c.status === 'error').length,
+        total: allChecks.length,
+        passed: allChecks.filter((c) => c.status === 'ok').length,
+        warnings: allChecks.filter((c) => c.status === 'warning').length,
+        errors: allChecks.filter((c) => c.status === 'error').length,
+        info: allChecks.filter((c) => c.status === 'info').length,
     };
     return {
         timestamp: Date.now(),
-        checks,
+        version,
+        groups,
+        checks: allChecks,
         summary,
     };
 }
 exports.runHealthChecks = runHealthChecks;
-function checkClaudeCli() {
+// Check 1: Claude CLI
+async function checkClaudeCli() {
+    const cliInfo = (0, claude_detector_1.getClaudeCliInfo)();
+    if (!cliInfo) {
+        return {
+            id: 'claude-cli',
+            name: 'Claude CLI',
+            status: 'error',
+            message: 'Not found in PATH',
+            fix: 'Install: npm install -g @anthropic-ai/claude-code',
+        };
+    }
     try {
         const version = (0, child_process_1.execSync)('claude --version', {
             encoding: 'utf8',
             timeout: 5000,
             stdio: ['pipe', 'pipe', 'pipe'],
         }).trim();
+        const versionMatch = version.match(/(\d+\.\d+\.\d+)/);
+        const versionStr = versionMatch ? versionMatch[1] : 'unknown';
         return {
             id: 'claude-cli',
             name: 'Claude CLI',
             status: 'ok',
-            message: `Installed: ${version}`,
+            message: `v${versionStr}`,
+            details: cliInfo.path,
         };
     }
     catch {
@@ -82,17 +153,40 @@ function checkClaudeCli() {
             id: 'claude-cli',
             name: 'Claude CLI',
             status: 'error',
-            message: 'Not found in PATH',
-            details: 'Install: npm install -g @anthropic-ai/claude-code',
+            message: 'Not working',
+            details: cliInfo.path,
+            fix: 'Reinstall Claude CLI',
+        };
+    }
+}
+// Check 2: CCS Directory
+function checkCcsDirectory(ccsDir) {
+    if (fs.existsSync(ccsDir)) {
+        return {
+            id: 'ccs-dir',
+            name: 'CCS Directory',
+            status: 'ok',
+            message: 'Exists',
+            details: '~/.ccs/',
         };
     }
+    return {
+        id: 'ccs-dir',
+        name: 'CCS Directory',
+        status: 'error',
+        message: 'Not found',
+        details: ccsDir,
+        fix: 'Run: npm install -g @kaitranntt/ccs --force',
+        fixable: true,
+    };
 }
+// Check 3: Config file
 function checkConfigFile() {
     const configPath = (0, config_manager_1.getConfigPath)();
     if (!fs.existsSync(configPath)) {
         return {
             id: 'config-file',
-            name: 'Config File',
+            name: 'config.json',
             status: 'warning',
             message: 'Not found',
             details: configPath,
@@ -104,94 +198,479 @@ function checkConfigFile() {
         JSON.parse(content);
         return {
             id: 'config-file',
-            name: 'Config File',
+            name: 'config.json',
             status: 'ok',
-            message: 'Valid JSON',
+            message: 'Valid',
             details: configPath,
         };
     }
     catch {
         return {
             id: 'config-file',
-            name: 'Config File',
+            name: 'config.json',
             status: 'error',
             message: 'Invalid JSON',
             details: configPath,
         };
     }
 }
-function checkProfilesFile() {
-    const ccsDir = (0, config_manager_1.getCcsDir)();
-    const profilesPath = path.join(ccsDir, 'profiles.json');
-    if (!fs.existsSync(profilesPath)) {
+// Check 4: Settings files (glm, kimi)
+function checkSettingsFiles(ccsDir) {
+    const checks = [];
+    const files = [
+        { name: 'glm.settings.json', profile: 'glm' },
+        { name: 'kimi.settings.json', profile: 'kimi' },
+    ];
+    const { DelegationValidator } = require('../utils/delegation-validator');
+    for (const file of files) {
+        const filePath = path.join(ccsDir, file.name);
+        if (!fs.existsSync(filePath)) {
+            checks.push({
+                id: `settings-${file.profile}`,
+                name: file.name,
+                status: 'info',
+                message: 'Not configured',
+                details: filePath,
+            });
+            continue;
+        }
+        try {
+            const content = fs.readFileSync(filePath, 'utf8');
+            JSON.parse(content);
+            const validation = DelegationValidator.validate(file.profile);
+            if (validation.valid) {
+                checks.push({
+                    id: `settings-${file.profile}`,
+                    name: file.name,
+                    status: 'ok',
+                    message: 'Key configured',
+                    details: filePath,
+                });
+            }
+            else if (validation.error && validation.error.includes('placeholder')) {
+                checks.push({
+                    id: `settings-${file.profile}`,
+                    name: file.name,
+                    status: 'warning',
+                    message: 'Placeholder key',
+                    details: filePath,
+                });
+            }
+            else {
+                checks.push({
+                    id: `settings-${file.profile}`,
+                    name: file.name,
+                    status: 'ok',
+                    message: 'Valid JSON',
+                    details: filePath,
+                });
+            }
+        }
+        catch {
+            checks.push({
+                id: `settings-${file.profile}`,
+                name: file.name,
+                status: 'error',
+                message: 'Invalid JSON',
+                details: filePath,
+            });
+        }
+    }
+    return checks;
+}
+// Check 5: Claude settings
+function checkClaudeSettings(claudeDir) {
+    const settingsPath = path.join(claudeDir, 'settings.json');
+    if (!fs.existsSync(settingsPath)) {
         return {
-            id: 'profiles-file',
-            name: 'Profiles Registry',
+            id: 'claude-settings',
+            name: '~/.claude/settings.json',
             status: 'warning',
-            message: 'Not found (will be created on first account)',
-            details: profilesPath,
-            fixable: true,
+            message: 'Not found',
+            fix: 'Run: claude /login',
         };
     }
     try {
-        const content = fs.readFileSync(profilesPath, 'utf8');
+        const content = fs.readFileSync(settingsPath, 'utf8');
         JSON.parse(content);
         return {
-            id: 'profiles-file',
-            name: 'Profiles Registry',
+            id: 'claude-settings',
+            name: '~/.claude/settings.json',
             status: 'ok',
             message: 'Valid',
-            details: profilesPath,
         };
     }
     catch {
         return {
-            id: 'profiles-file',
-            name: 'Profiles Registry',
-            status: 'error',
+            id: 'claude-settings',
+            name: '~/.claude/settings.json',
+            status: 'warning',
             message: 'Invalid JSON',
-            details: profilesPath,
+            fix: 'Run: claude /login',
+        };
+    }
+}
+// Check 6: Profiles
+function checkProfiles(ccsDir) {
+    const configPath = path.join(ccsDir, 'config.json');
+    if (!fs.existsSync(configPath)) {
+        return {
+            id: 'profiles',
+            name: 'Profiles',
+            status: 'info',
+            message: 'config.json not found',
+        };
+    }
+    try {
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+        if (!config.profiles || typeof config.profiles !== 'object') {
+            return {
+                id: 'profiles',
+                name: 'Profiles',
+                status: 'error',
+                message: 'Missing profiles object',
+                fix: 'Run: npm install -g @kaitranntt/ccs --force',
+            };
+        }
+        const profileCount = Object.keys(config.profiles).length;
+        const profileNames = Object.keys(config.profiles).join(', ');
+        return {
+            id: 'profiles',
+            name: 'Profiles',
+            status: 'ok',
+            message: `${profileCount} configured`,
+            details: profileNames.length > 40 ? profileNames.substring(0, 37) + '...' : profileNames,
+        };
+    }
+    catch (e) {
+        return {
+            id: 'profiles',
+            name: 'Profiles',
+            status: 'error',
+            message: e.message,
+        };
+    }
+}
+// Check 7: Instances
+function checkInstances(ccsDir) {
+    const instancesDir = path.join(ccsDir, 'instances');
+    if (!fs.existsSync(instancesDir)) {
+        return {
+            id: 'instances',
+            name: 'Instances',
+            status: 'ok',
+            message: 'No account profiles',
+        };
+    }
+    const instances = fs.readdirSync(instancesDir).filter((name) => {
+        return fs.statSync(path.join(instancesDir, name)).isDirectory();
+    });
+    if (instances.length === 0) {
+        return {
+            id: 'instances',
+            name: 'Instances',
+            status: 'ok',
+            message: 'No account profiles',
+        };
+    }
+    return {
+        id: 'instances',
+        name: 'Instances',
+        status: 'ok',
+        message: `${instances.length} account profile${instances.length !== 1 ? 's' : ''}`,
+    };
+}
+// Check 8: Delegation
+function checkDelegation(ccsDir) {
+    const ccsClaudeCommandsDir = path.join(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) {
+        return {
+            id: 'delegation',
+            name: 'Delegation',
+            status: 'warning',
+            message: 'Not installed',
+            fix: 'Run: npm install -g @kaitranntt/ccs --force',
+        };
+    }
+    const { DelegationValidator } = require('../utils/delegation-validator');
+    const readyProfiles = [];
+    for (const profile of ['glm', 'kimi']) {
+        const validation = DelegationValidator.validate(profile);
+        if (validation.valid) {
+            readyProfiles.push(profile);
+        }
+    }
+    if (readyProfiles.length === 0) {
+        return {
+            id: 'delegation',
+            name: 'Delegation',
+            status: 'warning',
+            message: 'No profiles ready',
+            fix: 'Configure profiles with valid API keys',
+        };
+    }
+    return {
+        id: 'delegation',
+        name: 'Delegation',
+        status: 'ok',
+        message: `${readyProfiles.length} profiles ready`,
+        details: readyProfiles.join(', '),
+    };
+}
+// Check 9: Permissions
+function checkPermissions(ccsDir) {
+    const testFile = path.join(ccsDir, '.permission-test');
+    try {
+        fs.writeFileSync(testFile, 'test', 'utf8');
+        fs.unlinkSync(testFile);
+        return {
+            id: 'permissions',
+            name: 'Permissions',
+            status: 'ok',
+            message: 'Write access verified',
+        };
+    }
+    catch {
+        return {
+            id: 'permissions',
+            name: 'Permissions',
+            status: 'error',
+            message: 'Cannot write to ~/.ccs/',
+            fix: 'sudo chown -R $USER ~/.ccs ~/.claude && chmod 755 ~/.ccs ~/.claude',
+        };
+    }
+}
+// Check 10: CCS Symlinks
+function checkCcsSymlinks() {
+    try {
+        const { ClaudeSymlinkManager } = require('../utils/claude-symlink-manager');
+        const manager = new ClaudeSymlinkManager();
+        const health = manager.checkHealth();
+        if (health.healthy) {
+            const itemCount = manager.ccsItems.length;
+            return {
+                id: 'ccs-symlinks',
+                name: 'CCS Symlinks',
+                status: 'ok',
+                message: `${itemCount}/${itemCount} items linked`,
+            };
+        }
+        return {
+            id: 'ccs-symlinks',
+            name: 'CCS Symlinks',
+            status: 'warning',
+            message: `${health.issues.length} issues found`,
+            fix: 'Run: ccs sync',
+        };
+    }
+    catch (e) {
+        return {
+            id: 'ccs-symlinks',
+            name: 'CCS Symlinks',
+            status: 'warning',
+            message: 'Could not check',
+            details: e.message,
+            fix: 'Run: ccs sync',
+        };
+    }
+}
+// Check 11: Settings Symlinks
+function checkSettingsSymlinks(homedir, ccsDir, claudeDir) {
+    try {
+        const sharedDir = path.join(homedir, '.ccs', 'shared');
+        const sharedSettings = path.join(sharedDir, 'settings.json');
+        const claudeSettings = path.join(claudeDir, 'settings.json');
+        if (!fs.existsSync(sharedSettings)) {
+            return {
+                id: 'settings-symlinks',
+                name: 'settings.json',
+                status: 'warning',
+                message: 'Shared not found',
+                fix: 'Run: ccs sync',
+            };
+        }
+        const sharedStats = fs.lstatSync(sharedSettings);
+        if (!sharedStats.isSymbolicLink()) {
+            return {
+                id: 'settings-symlinks',
+                name: 'settings.json',
+                status: 'warning',
+                message: 'Not a symlink',
+                fix: 'Run: ccs sync',
+            };
+        }
+        const sharedTarget = fs.readlinkSync(sharedSettings);
+        const resolvedShared = path.resolve(path.dirname(sharedSettings), sharedTarget);
+        if (resolvedShared !== claudeSettings) {
+            return {
+                id: 'settings-symlinks',
+                name: 'settings.json',
+                status: 'warning',
+                message: 'Wrong target',
+                fix: 'Run: ccs sync',
+            };
+        }
+        // Check instances
+        const instancesDir = path.join(ccsDir, 'instances');
+        if (!fs.existsSync(instancesDir)) {
+            return {
+                id: 'settings-symlinks',
+                name: 'settings.json',
+                status: 'ok',
+                message: 'Shared symlink valid',
+            };
+        }
+        const instances = fs.readdirSync(instancesDir).filter((name) => {
+            return fs.statSync(path.join(instancesDir, name)).isDirectory();
+        });
+        let broken = 0;
+        for (const instance of instances) {
+            const instanceSettings = path.join(instancesDir, instance, '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 {
+                broken++;
+            }
+        }
+        if (broken > 0) {
+            return {
+                id: 'settings-symlinks',
+                name: 'settings.json',
+                status: 'warning',
+                message: `${broken} broken instance(s)`,
+                fix: 'Run: ccs sync',
+            };
+        }
+        return {
+            id: 'settings-symlinks',
+            name: 'settings.json',
+            status: 'ok',
+            message: `${instances.length} instance(s) valid`,
+        };
+    }
+    catch (e) {
+        return {
+            id: 'settings-symlinks',
+            name: 'settings.json',
+            status: 'warning',
+            message: 'Check failed',
+            details: e.message,
+            fix: 'Run: ccs sync',
         };
     }
 }
-function checkCliproxy() {
+// Check 12: CLIProxy Binary
+function checkCliproxyBinary() {
     if ((0, cliproxy_1.isCLIProxyInstalled)()) {
         const version = (0, cliproxy_1.getInstalledCliproxyVersion)();
         const binaryPath = (0, cliproxy_1.getCLIProxyPath)();
         return {
-            id: 'cliproxy',
-            name: 'CLIProxy',
+            id: 'cliproxy-binary',
+            name: 'CLIProxy Binary',
             status: 'ok',
-            message: `Installed: ${version}`,
+            message: `v${version}`,
             details: binaryPath,
         };
     }
     return {
-        id: 'cliproxy',
-        name: 'CLIProxy',
-        status: 'warning',
-        message: 'Not installed (optional)',
-        details: 'Required for gemini/codex/agy providers. Install: ccs cliproxy --latest',
+        id: 'cliproxy-binary',
+        name: 'CLIProxy Binary',
+        status: 'info',
+        message: 'Not installed',
+        details: 'Downloads on first use',
     };
 }
-function checkCcsDirectory() {
-    const ccsDir = (0, config_manager_1.getCcsDir)();
-    if (!fs.existsSync(ccsDir)) {
+// Check 13: CLIProxy Config
+function checkCliproxyConfig() {
+    const configPath = (0, cliproxy_1.getConfigPath)();
+    if (fs.existsSync(configPath)) {
         return {
-            id: 'ccs-dir',
-            name: 'CCS Directory',
-            status: 'warning',
-            message: 'Not found',
-            details: ccsDir,
-            fixable: true,
+            id: 'cliproxy-config',
+            name: 'CLIProxy Config',
+            status: 'ok',
+            message: 'cliproxy/config.yaml',
         };
     }
     return {
-        id: 'ccs-dir',
-        name: 'CCS Directory',
-        status: 'ok',
-        message: 'Exists',
-        details: ccsDir,
+        id: 'cliproxy-config',
+        name: 'CLIProxy Config',
+        status: 'info',
+        message: 'Not created',
+        details: 'Generated on first use',
+    };
+}
+// Check 14: OAuth Providers
+function checkOAuthProviders() {
+    const authStatuses = (0, cliproxy_1.getAllAuthStatus)();
+    const checks = [];
+    for (const status of authStatuses) {
+        const providerName = status.provider.charAt(0).toUpperCase() + status.provider.slice(1);
+        if (status.authenticated) {
+            const lastAuth = status.lastAuth ? status.lastAuth.toLocaleDateString() : '';
+            checks.push({
+                id: `oauth-${status.provider}`,
+                name: `${providerName} Auth`,
+                status: 'ok',
+                message: 'Authenticated',
+                details: lastAuth,
+            });
+        }
+        else {
+            checks.push({
+                id: `oauth-${status.provider}`,
+                name: `${providerName} Auth`,
+                status: 'info',
+                message: 'Not authenticated',
+                fix: `Run: ccs ${status.provider} --auth`,
+            });
+        }
+    }
+    return checks;
+}
+// Check 15: CLIProxy Port
+async function checkCliproxyPort() {
+    const portProcess = await (0, port_utils_1.getPortProcess)(cliproxy_1.CLIPROXY_DEFAULT_PORT);
+    if (!portProcess) {
+        return {
+            id: 'cliproxy-port',
+            name: 'CLIProxy Port',
+            status: 'info',
+            message: `${cliproxy_1.CLIPROXY_DEFAULT_PORT} free`,
+            details: 'Proxy not running',
+        };
+    }
+    if ((0, port_utils_1.isCLIProxyProcess)(portProcess)) {
+        return {
+            id: 'cliproxy-port',
+            name: 'CLIProxy Port',
+            status: 'ok',
+            message: 'CLIProxy running',
+            details: `PID ${portProcess.pid}`,
+        };
+    }
+    return {
+        id: 'cliproxy-port',
+        name: 'CLIProxy Port',
+        status: 'warning',
+        message: `Occupied by ${portProcess.processName}`,
+        details: `PID ${portProcess.pid}`,
+        fix: `Kill process: kill ${portProcess.pid}`,
     };
 }
 /**