@jonnyhoo/ccs 1.0.0

package/scripts/postinstall.js

@@ -0,0 +1,358 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+/**
+ * CCS Postinstall Script
+ * Automatically creates config files in ~/.ccs/ after npm install
+ *
+ * Runs when: npm install -g @kaitranntt/ccs
+ * Idempotent: Safe to run multiple times (won't overwrite existing configs)
+ * Cross-platform: Works on Unix, macOS, Windows
+ *
+ * Test isolation: Set CCS_HOME env var to redirect all operations to a test directory
+ */
+
+/**
+ * Get the CCS home directory (respects CCS_HOME env var for test isolation)
+ * @returns {string} Home directory path
+ */
+function getCcsHome() {
+  return process.env.CCS_HOME || os.homedir();
+}
+
+/**
+ * Check if path is a broken symlink and remove it if so
+ * Fixes: ENOENT error when mkdir tries to create over a dangling symlink
+ * @param {string} targetPath - Path to check
+ * @returns {boolean} true if broken symlink was removed
+ */
+function removeIfBrokenSymlink(targetPath) {
+  try {
+    // lstatSync doesn't follow symlinks - it checks the link itself
+    const stats = fs.lstatSync(targetPath);
+    if (stats.isSymbolicLink()) {
+      // Check if symlink target exists
+      try {
+        fs.statSync(targetPath); // This follows symlinks
+        return false; // Symlink is valid
+      } catch {
+        // Target doesn't exist - broken symlink
+        fs.unlinkSync(targetPath);
+        console.log(`[!] Removed broken symlink: ${targetPath}`);
+        return true;
+      }
+    }
+    return false;
+  } catch {
+    // Path doesn't exist at all
+    return false;
+  }
+}
+
+/**
+ * Validate created configuration files
+ * @returns {object} { success: boolean, errors: string[], warnings: string[] }
+ */
+function validateConfiguration() {
+  const homedir = getCcsHome();
+  const errors = [];
+  const warnings = [];
+
+  // Check ~/.ccs/ directory
+  const ccsDir = path.join(homedir, '.ccs');
+  if (!fs.existsSync(ccsDir)) {
+    errors.push('~/.ccs/ directory not found');
+  }
+
+  // Check for config file - prefer config.yaml, fallback to config.json
+  const configYaml = path.join(ccsDir, 'config.yaml');
+  const configJson = path.join(ccsDir, 'config.json');
+  const hasConfig = fs.existsSync(configYaml) || fs.existsSync(configJson);
+
+  if (!hasConfig) {
+    errors.push('config.yaml (or config.json) not found');
+  }
+
+  // Check ~/.claude/settings.json (warning only, not critical)
+  const claudeSettings = path.join(homedir, '.claude', 'settings.json');
+  if (!fs.existsSync(claudeSettings)) {
+    warnings.push('~/.claude/settings.json not found - run "claude /login"');
+  }
+
+  return { success: errors.length === 0, errors, warnings };
+}
+
+function createConfigFiles() {
+  try {
+    // Get user home directory (cross-platform, respects CCS_HOME for test isolation)
+    const homedir = getCcsHome();
+    const ccsDir = path.join(homedir, '.ccs');
+
+    // Create ~/.ccs/ directory if missing
+    if (fs.existsSync(ccsDir)) {
+      // Check if it's a file instead of directory (edge case)
+      const stats = fs.statSync(ccsDir);
+      if (!stats.isDirectory()) {
+        console.error('[X] ~/.ccs exists but is not a directory');
+        console.error('    Remove or rename it: mv ~/.ccs ~/.ccs.bak');
+        process.exit(1);
+      }
+    } else {
+      fs.mkdirSync(ccsDir, { recursive: true, mode: 0o755 });
+      console.log('[OK] Created directory: ~/.ccs/');
+    }
+
+    // Create ~/.ccs/shared/ directory structure (Phase 1)
+    const sharedDir = path.join(ccsDir, 'shared');
+    // Handle broken symlinks (common when upgrading from older versions)
+    removeIfBrokenSymlink(sharedDir);
+    if (!fs.existsSync(sharedDir)) {
+      fs.mkdirSync(sharedDir, { recursive: true, mode: 0o755 });
+      console.log('[OK] Created directory: ~/.ccs/shared/');
+    }
+
+    // Create shared subdirectories
+    const sharedSubdirs = ['commands', 'skills', 'agents', 'plugins'];
+    for (const subdir of sharedSubdirs) {
+      const subdirPath = path.join(sharedDir, subdir);
+      // Handle broken symlinks before creating directory
+      removeIfBrokenSymlink(subdirPath);
+      if (!fs.existsSync(subdirPath)) {
+        fs.mkdirSync(subdirPath, { recursive: true, mode: 0o755 });
+        console.log(`[OK] Created directory: ~/.ccs/shared/${subdir}/`);
+      }
+    }
+
+    // Migrate from v3.1.1 to v3.2.0 (symlink architecture)
+    console.log('');
+    try {
+      const SharedManager = require('../dist/management/shared-manager').default;
+      const sharedManager = new SharedManager();
+      sharedManager.migrateFromV311();
+      sharedManager.ensureSharedDirectories();
+
+      // Run v4.4 migration: Migrate instances to shared settings.json
+      sharedManager.migrateToSharedSettings();
+    } catch (err) {
+      console.warn('[!] Migration warning:', err.message);
+      console.warn('    Migration will retry on next run');
+    }
+    console.log('');
+
+    // NOTE: .claude/ directory installation moved to "ccs sync" command
+    // Users can run "ccs sync" to install CCS commands/skills to ~/.claude/
+    // This gives users control over when to modify their Claude configuration
+
+    // Create config.yaml if missing (primary format)
+    // NOTE: gemini/codex profiles NOT included - they are added on-demand when user
+    // runs `ccs gemini` or `ccs codex` for first time (requires OAuth auth first)
+    // NOTE: GLM/GLMT/Kimi profiles are now created via UI/CLI presets, not auto-created
+    const configYamlPath = path.join(ccsDir, 'config.yaml');
+    const legacyConfigPath = path.join(ccsDir, 'config.json');
+
+    if (!fs.existsSync(configYamlPath)) {
+      // Check for legacy config.json - autoMigrate() in ccs.ts will handle migration
+      if (fs.existsSync(legacyConfigPath)) {
+        // Validate legacy config.json before assuming migration will work
+        try {
+          const content = fs.readFileSync(legacyConfigPath, 'utf8');
+          JSON.parse(content);
+          console.log('[OK] Legacy config.json found - will migrate to config.yaml on first run');
+        } catch {
+          console.warn('[!] Legacy config.json is corrupted/invalid');
+          console.warn('    Backup: mv ~/.ccs/config.json ~/.ccs/config.json.bak');
+          console.warn('    Creating fresh config.yaml instead');
+          // Fall through to create new config.yaml
+          fs.renameSync(legacyConfigPath, `${legacyConfigPath}.bak`);
+        }
+      }
+
+      // Create config.yaml if it doesn't exist (and legacy wasn't valid)
+      if (!fs.existsSync(configYamlPath) && !fs.existsSync(legacyConfigPath)) {
+        // Try to use unified config loader if dist is available
+        try {
+          const { saveUnifiedConfig } = require('../dist/config/unified-config-loader');
+          const { createEmptyUnifiedConfig, UNIFIED_CONFIG_VERSION } = require('../dist/config/unified-config-types');
+
+          const config = createEmptyUnifiedConfig();
+          config.version = UNIFIED_CONFIG_VERSION;
+          saveUnifiedConfig(config);
+
+          console.log('[OK] Created config: ~/.ccs/config.yaml');
+        } catch (loaderErr) {
+          // Dist not built yet (fresh clone) - create minimal config.yaml manually
+          // Wrap js-yaml require in try-catch in case it's not available
+          let yaml;
+          try {
+            yaml = require('js-yaml');
+          } catch {
+            // js-yaml not available - fallback to JSON
+            console.warn('[!] js-yaml not available, creating legacy config.json');
+            const fallbackConfig = { profiles: {} };
+            const tmpPath = `${legacyConfigPath}.tmp`;
+            fs.writeFileSync(tmpPath, JSON.stringify(fallbackConfig, null, 2) + '\n', 'utf8');
+            fs.renameSync(tmpPath, legacyConfigPath);
+            console.log('[OK] Created config: ~/.ccs/config.json (fallback)');
+            yaml = null;
+          }
+
+          if (yaml) {
+            const config = {
+              version: '2.0',
+              profiles: {},
+              accounts: {},
+              cliproxy: {
+                variants: {},
+                oauth_accounts: {}
+              },
+              cliproxy_server: {
+                local: {
+                  port: 8317,
+                  auto_start: true
+                }
+              }
+            };
+
+            try {
+              const yamlContent = yaml.dump(config, {
+                indent: 2,
+                lineWidth: -1,
+                noRefs: true,
+                sortKeys: false
+              });
+              const tmpPath = `${configYamlPath}.tmp`;
+              fs.writeFileSync(tmpPath, yamlContent, 'utf8');
+              fs.renameSync(tmpPath, configYamlPath);
+              console.log('[OK] Created config: ~/.ccs/config.yaml');
+            } catch (yamlErr) {
+              // Final fallback: create legacy config.json
+              console.warn('[!] YAML write failed, creating legacy config.json');
+              const fallbackConfig = { profiles: {} };
+              const tmpPath = `${legacyConfigPath}.tmp`;
+              fs.writeFileSync(tmpPath, JSON.stringify(fallbackConfig, null, 2) + '\n', 'utf8');
+              fs.renameSync(tmpPath, legacyConfigPath);
+              console.log('[OK] Created config: ~/.ccs/config.json (fallback)');
+            }
+          }
+        }
+      }
+    } else {
+      console.log('[OK] Config exists: ~/.ccs/config.yaml (preserved)');
+    }
+
+    // Warn if both config files exist (user may want to clean up)
+    if (fs.existsSync(legacyConfigPath) && fs.existsSync(configYamlPath)) {
+      console.log('[!] Both config.yaml and config.json exist');
+      console.log('    config.json will be ignored - consider removing it');
+    }
+
+    // NOTE: GLM, GLMT, and Kimi profiles are NO LONGER auto-created during install
+    // Users can create these via:
+    //   - UI: Profile Create Dialog → Provider Presets
+    //   - CLI: ccs api create --preset glm|glmt|kimi
+    // This gives users control over which providers they want to use
+    // Existing profiles are preserved for backward compatibility
+
+    // Copy shell completion files to ~/.ccs/completions/
+    const completionsDir = path.join(ccsDir, 'completions');
+    const scriptsCompletionDir = path.join(__dirname, '../scripts/completion');
+
+    if (!fs.existsSync(completionsDir)) {
+      fs.mkdirSync(completionsDir, { recursive: true, mode: 0o755 });
+    }
+
+    const completionFiles = ['ccs.bash', 'ccs.zsh', 'ccs.fish', 'ccs.ps1'];
+    completionFiles.forEach(file => {
+      const src = path.join(scriptsCompletionDir, file);
+      const dest = path.join(completionsDir, file);
+
+      if (fs.existsSync(src)) {
+        fs.copyFileSync(src, dest);
+      }
+    });
+
+    console.log('[OK] Installed shell completions: ~/.ccs/completions/');
+    console.log('');
+    console.log('  [i] Enable auto-completion:');
+    console.log('      Run: ccs --shell-completion');
+    console.log('');
+
+    // Create ~/.claude/settings.json if missing (NEW)
+    const claudeDir = path.join(homedir, '.claude');
+    const claudeSettingsPath = path.join(claudeDir, 'settings.json');
+
+    if (!fs.existsSync(claudeDir)) {
+      fs.mkdirSync(claudeDir, { recursive: true, mode: 0o755 });
+      console.log('[OK] Created directory: ~/.claude/');
+    }
+
+    if (!fs.existsSync(claudeSettingsPath)) {
+      // Create empty settings (matches Claude CLI behavior)
+      const tmpPath = `${claudeSettingsPath}.tmp`;
+      fs.writeFileSync(tmpPath, '{}\n', 'utf8');
+      fs.renameSync(tmpPath, claudeSettingsPath);
+
+      console.log('[OK] Created default settings: ~/.claude/settings.json');
+      console.log('');
+      console.log('  [i] Configure Claude CLI:');
+      console.log('      Run: claude /login');
+      console.log('');
+    } else {
+      console.log('[OK] Claude settings exist: ~/.claude/settings.json (preserved)');
+    }
+
+    // Validate configuration
+    console.log('');
+    console.log('[i] Validating configuration...');
+    const validation = validateConfiguration();
+
+    if (!validation.success) {
+      console.error('');
+      console.error('[X] Configuration validation failed:');
+      validation.errors.forEach(err => console.error(`    - ${err}`));
+      console.error('');
+      throw new Error('Configuration incomplete');
+    }
+
+    // Show warnings (non-critical)
+    if (validation.warnings.length > 0) {
+      console.warn('');
+      console.warn('[!] Warnings:');
+      validation.warnings.forEach(warn => console.warn(`    - ${warn}`));
+    }
+
+    console.log('');
+    console.log('[OK] CCS configuration ready!');
+    console.log('  Run: ccs --version');
+
+  } catch (err) {
+    // Show error details
+    console.error('');
+    console.error('[X] CCS configuration failed');
+    console.error(`    Error: ${err.message}`);
+    console.error('');
+    console.error('Recovery steps:');
+    console.error('  1. Create directory manually:');
+    console.error('     mkdir -p ~/.ccs ~/.claude');
+    console.error('');
+    console.error('  2. Create empty settings:');
+    console.error('     echo "{}" > ~/.claude/settings.json');
+    console.error('');
+    console.error('  3. Retry installation:');
+    console.error('     npm install -g @kaitranntt/ccs --force');
+    console.error('');
+    console.error('  4. If issue persists, report at:');
+    console.error('     https://github.com/kaitranntt/ccs/issues');
+    console.error('');
+
+    // Exit with error code (npm will show warning)
+    process.exit(1);
+  }
+}
+
+// Run postinstall
+createConfigFiles();

package/scripts/postuninstall.js

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+/**
+ * CCS Postuninstall Script
+ *
+ * Cleans up CCS-specific files after npm uninstall.
+ * Does NOT touch global ~/.claude/settings.json (hooks are per-profile now).
+ *
+ * Self-contained, no external dependencies.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Note: Uses os.homedir() directly because this script runs during npm uninstall,
+// not in test context. CCS_HOME isolation is for src/ code only.
+const CCS_DIR = path.join(os.homedir(), '.ccs');
+const HOOKS_DIR = path.join(CCS_DIR, 'hooks');
+const MIGRATION_MARKER = path.join(CCS_DIR, '.hook-migrated');
+
+function cleanupCcsFiles() {
+  try {
+    // Remove WebSearch hook file
+    const hookPath = path.join(HOOKS_DIR, 'websearch-transformer.cjs');
+    if (fs.existsSync(hookPath)) {
+      fs.unlinkSync(hookPath);
+    }
+
+    // Remove migration marker (so fresh install re-runs migration)
+    if (fs.existsSync(MIGRATION_MARKER)) {
+      fs.unlinkSync(MIGRATION_MARKER);
+    }
+
+    // Note: Do NOT touch ~/.claude/settings.json
+    // Per-profile hooks in ~/.ccs/*.settings.json will be cleaned up
+    // when the user removes ~/.ccs/ directory.
+  } catch (err) {
+    // Silent fail - not critical, but log for debugging
+    try {
+      const logPath = path.join(CCS_DIR, 'uninstall.log');
+      fs.appendFileSync(logPath, `${new Date().toISOString()}: ${err.message}\n`);
+    } catch {
+      // Ignore logging failures
+    }
+  }
+}
+
+cleanupCcsFiles();

package/scripts/pre-release.sh

@@ -0,0 +1,39 @@
+#!/bin/bash
+# Pre-Release Checklist for CCS
+set -euo pipefail
+
+echo "=== Pre-Release Checklist ==="
+echo ""
+
+# 1. Version check
+echo "[i] Current version: $(node -p "require('./package.json').version")"
+
+# 2. Clean build
+echo "[i] Clean build..."
+rm -rf dist
+bun run build:all
+
+# 3. Bundle size
+echo "[i] Bundle size check..."
+node scripts/verify-bundle.js
+
+# 4. Lint & typecheck
+echo "[i] Lint & typecheck..."
+bun run validate
+
+# 5. Tests
+echo "[i] Running tests..."
+bun test
+
+# 6. Help consistency check
+echo "[i] Checking help text includes config command..."
+if ! grep -q "ccs config" src/commands/help-command.ts; then
+    echo "[!] Missing config in help-command.ts"
+fi
+
+# 7. Package contents
+echo "[i] Package contents..."
+npm pack --dry-run 2>&1 | head -20
+
+echo ""
+echo "=== Ready for release ==="

package/scripts/preinstall.js

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * CCS Preinstall Script
+ * Installs dependencies in ui/ folder before main install
+ *
+ * Runs when: bun install, npm install, yarn install
+ * Skips when: CI environment or global install (npm -g)
+ */
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+// Skip in CI environments or global installs
+if (process.env.CI || process.env.npm_config_global === 'true') {
+  process.exit(0);
+}
+
+const uiDir = path.join(__dirname, '..', 'ui');
+const uiPackageJson = path.join(uiDir, 'package.json');
+
+// Skip if ui/ folder or package.json doesn't exist
+if (!fs.existsSync(uiPackageJson)) {
+  process.exit(0);
+}
+
+// Detect package manager (prefer bun > npm)
+function getPackageManager() {
+  // Check if running via bun
+  if (process.env.npm_execpath?.includes('bun') || process.env._?.includes('bun')) {
+    return 'bun';
+  }
+  // Check if bun is available
+  try {
+    execSync('bun --version', { stdio: 'ignore' });
+    return 'bun';
+  } catch {
+    return 'npm';
+  }
+}
+
+const pm = getPackageManager();
+
+console.log(`[i] Installing ui/ dependencies with ${pm}...`);
+
+try {
+  execSync(`${pm} install`, {
+    cwd: uiDir,
+    stdio: 'inherit',
+    env: { ...process.env, npm_config_global: undefined }
+  });
+  console.log('[OK] ui/ dependencies installed');
+} catch (err) {
+  console.error('[!] Failed to install ui/ dependencies:', err.message);
+  console.error('    You can manually install: cd ui && bun install');
+  // Don't fail the main install - ui is optional for CLI usage
+}