mirror of
https://github.com/tiennm99/ccs.git
synced 2026-07-15 22:21:20 +00:00
kaitranntt
134511c38b
- Update base-kimi.settings.json with model fields - Update install.sh KIMI_MODEL variable - Update postinstall.js template and migration to add model fields - Migration now adds model fields instead of removing them (v5.5.0)
526 lines
19 KiB
JavaScript
Executable File
526 lines
19 KiB
JavaScript
Executable File
#!/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 required files
|
|
const requiredFiles = [
|
|
{ path: path.join(ccsDir, 'config.json'), name: 'config.json' },
|
|
{ path: path.join(ccsDir, 'glm.settings.json'), name: 'glm.settings.json' },
|
|
{ path: path.join(ccsDir, 'glmt.settings.json'), name: 'glmt.settings.json' },
|
|
{ path: path.join(ccsDir, 'kimi.settings.json'), name: 'kimi.settings.json' }
|
|
];
|
|
|
|
for (const file of requiredFiles) {
|
|
if (!fs.existsSync(file.path)) {
|
|
errors.push(`${file.name} not found`);
|
|
continue;
|
|
}
|
|
|
|
// Validate JSON syntax
|
|
try {
|
|
const content = fs.readFileSync(file.path, 'utf8');
|
|
JSON.parse(content);
|
|
} catch (e) {
|
|
errors.push(`${file.name} has invalid JSON: ${e.message}`);
|
|
}
|
|
}
|
|
|
|
// 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)) {
|
|
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.json if missing
|
|
// 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)
|
|
const configPath = path.join(ccsDir, 'config.json');
|
|
if (!fs.existsSync(configPath)) {
|
|
// NOTE: No 'default' entry - when no profile specified, CCS passes through
|
|
// to Claude's native auth without --settings flag. This prevents env var
|
|
// pollution from affecting the default profile.
|
|
const config = {
|
|
profiles: {
|
|
glm: '~/.ccs/glm.settings.json',
|
|
glmt: '~/.ccs/glmt.settings.json',
|
|
kimi: '~/.ccs/kimi.settings.json'
|
|
}
|
|
};
|
|
|
|
// Atomic write: temp file → rename
|
|
const tmpPath = `${configPath}.tmp`;
|
|
fs.writeFileSync(tmpPath, JSON.stringify(config, null, 2) + '\n', 'utf8');
|
|
fs.renameSync(tmpPath, configPath);
|
|
|
|
console.log('[OK] Created config: ~/.ccs/config.json');
|
|
} else {
|
|
// Update existing config (migration for older versions)
|
|
const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
|
|
// Ensure profiles object exists
|
|
if (!config.profiles) {
|
|
config.profiles = {};
|
|
}
|
|
let configUpdated = false;
|
|
|
|
// Migration: Add glmt if missing (v3.x)
|
|
if (!config.profiles.glmt) {
|
|
config.profiles.glmt = '~/.ccs/glmt.settings.json';
|
|
configUpdated = true;
|
|
}
|
|
|
|
// Migration: Remove 'default' entry pointing to ~/.claude/settings.json (v5.4.0)
|
|
// This entry caused the default profile to pass --settings flag, which could
|
|
// pick up stale env vars (ANTHROPIC_BASE_URL) from previous profile sessions.
|
|
// Fix: Let CCS pass through to Claude's native auth without --settings flag.
|
|
if (config.profiles.default === '~/.claude/settings.json') {
|
|
delete config.profiles.default;
|
|
configUpdated = true;
|
|
console.log('[OK] Removed legacy default profile (now uses native Claude auth)');
|
|
}
|
|
|
|
// NOTE: gemini/codex profiles added on-demand, not during migration
|
|
if (configUpdated) {
|
|
const tmpPath = `${configPath}.tmp`;
|
|
fs.writeFileSync(tmpPath, JSON.stringify(config, null, 2) + '\n', 'utf8');
|
|
fs.renameSync(tmpPath, configPath);
|
|
if (!config.profiles.glmt) {
|
|
console.log('[OK] Updated config with glmt profile');
|
|
}
|
|
} else {
|
|
console.log('[OK] Config exists: ~/.ccs/config.json (preserved)');
|
|
}
|
|
}
|
|
|
|
// Create glm.settings.json if missing
|
|
const glmSettingsPath = path.join(ccsDir, 'glm.settings.json');
|
|
if (!fs.existsSync(glmSettingsPath)) {
|
|
const glmSettings = {
|
|
env: {
|
|
ANTHROPIC_BASE_URL: 'https://api.z.ai/api/anthropic',
|
|
ANTHROPIC_AUTH_TOKEN: 'YOUR_GLM_API_KEY_HERE',
|
|
ANTHROPIC_MODEL: 'glm-4.6',
|
|
ANTHROPIC_DEFAULT_OPUS_MODEL: 'glm-4.6',
|
|
ANTHROPIC_DEFAULT_SONNET_MODEL: 'glm-4.6',
|
|
ANTHROPIC_DEFAULT_HAIKU_MODEL: 'glm-4.6'
|
|
}
|
|
};
|
|
|
|
// Atomic write
|
|
const tmpPath = `${glmSettingsPath}.tmp`;
|
|
fs.writeFileSync(tmpPath, JSON.stringify(glmSettings, null, 2) + '\n', 'utf8');
|
|
fs.renameSync(tmpPath, glmSettingsPath);
|
|
|
|
console.log('[OK] Created GLM profile: ~/.ccs/glm.settings.json');
|
|
console.log('');
|
|
console.log(' [!] Configure GLM API key:');
|
|
console.log(' 1. Get key from: https://api.z.ai');
|
|
console.log(' 2. Edit: ~/.ccs/glm.settings.json');
|
|
console.log(' 3. Replace: YOUR_GLM_API_KEY_HERE');
|
|
} else {
|
|
console.log('[OK] GLM profile exists: ~/.ccs/glm.settings.json (preserved)');
|
|
}
|
|
|
|
// Create glmt.settings.json if missing
|
|
const glmtSettingsPath = path.join(ccsDir, 'glmt.settings.json');
|
|
if (!fs.existsSync(glmtSettingsPath)) {
|
|
const glmtSettings = {
|
|
env: {
|
|
ANTHROPIC_BASE_URL: 'https://api.z.ai/api/coding/paas/v4/chat/completions',
|
|
ANTHROPIC_AUTH_TOKEN: 'YOUR_GLM_API_KEY_HERE',
|
|
ANTHROPIC_MODEL: 'glm-4.6',
|
|
ANTHROPIC_DEFAULT_OPUS_MODEL: 'glm-4.6',
|
|
ANTHROPIC_DEFAULT_SONNET_MODEL: 'glm-4.6',
|
|
ANTHROPIC_DEFAULT_HAIKU_MODEL: 'glm-4.6',
|
|
ANTHROPIC_TEMPERATURE: '0.2',
|
|
ANTHROPIC_MAX_TOKENS: '65536',
|
|
MAX_THINKING_TOKENS: '32768',
|
|
ENABLE_STREAMING: 'true',
|
|
ANTHROPIC_SAFE_MODE: 'false',
|
|
API_TIMEOUT_MS: '3000000'
|
|
},
|
|
alwaysThinkingEnabled: true
|
|
};
|
|
|
|
// Atomic write
|
|
const tmpPath = `${glmtSettingsPath}.tmp`;
|
|
fs.writeFileSync(tmpPath, JSON.stringify(glmtSettings, null, 2) + '\n', 'utf8');
|
|
fs.renameSync(tmpPath, glmtSettingsPath);
|
|
|
|
console.log('[OK] Created GLMT profile: ~/.ccs/glmt.settings.json');
|
|
console.log('');
|
|
console.log(' [!] Configure GLMT API key:');
|
|
console.log(' 1. Get key from: https://api.z.ai');
|
|
console.log(' 2. Edit: ~/.ccs/glmt.settings.json');
|
|
console.log(' 3. Replace: YOUR_GLM_API_KEY_HERE');
|
|
console.log(' Note: GLMT enables GLM thinking mode (reasoning)');
|
|
console.log(' Defaults: Temperature 0.2, thinking enabled, 50min timeout');
|
|
} else {
|
|
console.log('[OK] GLMT profile exists: ~/.ccs/glmt.settings.json (preserved)');
|
|
}
|
|
|
|
// Migrate existing GLMT configs to include new defaults (v3.3.0)
|
|
if (fs.existsSync(glmtSettingsPath)) {
|
|
try {
|
|
const existing = JSON.parse(fs.readFileSync(glmtSettingsPath, 'utf8'));
|
|
let updated = false;
|
|
|
|
// Ensure env object exists
|
|
if (!existing.env) {
|
|
existing.env = {};
|
|
updated = true;
|
|
}
|
|
|
|
// Add missing env vars (preserve existing values)
|
|
const envDefaults = {
|
|
ANTHROPIC_TEMPERATURE: '0.2',
|
|
ANTHROPIC_MAX_TOKENS: '65536',
|
|
MAX_THINKING_TOKENS: '32768',
|
|
ENABLE_STREAMING: 'true',
|
|
ANTHROPIC_SAFE_MODE: 'false',
|
|
API_TIMEOUT_MS: '3000000'
|
|
};
|
|
|
|
for (const [key, value] of Object.entries(envDefaults)) {
|
|
if (existing.env[key] === undefined) {
|
|
existing.env[key] = value;
|
|
updated = true;
|
|
}
|
|
}
|
|
|
|
// Add alwaysThinkingEnabled if missing
|
|
if (existing.alwaysThinkingEnabled === undefined) {
|
|
existing.alwaysThinkingEnabled = true;
|
|
updated = true;
|
|
}
|
|
|
|
// Write back if updated
|
|
if (updated) {
|
|
const tmpPath = `${glmtSettingsPath}.tmp`;
|
|
fs.writeFileSync(tmpPath, JSON.stringify(existing, null, 2) + '\n', 'utf8');
|
|
fs.renameSync(tmpPath, glmtSettingsPath);
|
|
console.log('[OK] Migrated GLMT config with new defaults (v3.3.0)');
|
|
console.log(' Added: temperature, max_tokens, thinking settings, alwaysThinkingEnabled');
|
|
}
|
|
} catch (err) {
|
|
console.warn('[!] GLMT config migration failed:', err.message);
|
|
console.warn(' Existing config preserved, may be missing new defaults');
|
|
console.warn(' You can manually add fields or delete file to regenerate');
|
|
}
|
|
}
|
|
|
|
// Create kimi.settings.json if missing
|
|
const kimiSettingsPath = path.join(ccsDir, 'kimi.settings.json');
|
|
if (!fs.existsSync(kimiSettingsPath)) {
|
|
const kimiSettings = {
|
|
env: {
|
|
ANTHROPIC_BASE_URL: 'https://api.kimi.com/coding/',
|
|
ANTHROPIC_AUTH_TOKEN: 'YOUR_KIMI_API_KEY_HERE',
|
|
ANTHROPIC_MODEL: 'kimi-k2-thinking-turbo',
|
|
ANTHROPIC_DEFAULT_OPUS_MODEL: 'kimi-k2-thinking-turbo',
|
|
ANTHROPIC_DEFAULT_SONNET_MODEL: 'kimi-k2-thinking-turbo',
|
|
ANTHROPIC_DEFAULT_HAIKU_MODEL: 'kimi-k2-thinking-turbo'
|
|
},
|
|
alwaysThinkingEnabled: true
|
|
};
|
|
|
|
// Atomic write
|
|
const tmpPath = `${kimiSettingsPath}.tmp`;
|
|
fs.writeFileSync(tmpPath, JSON.stringify(kimiSettings, null, 2) + '\n', 'utf8');
|
|
fs.renameSync(tmpPath, kimiSettingsPath);
|
|
|
|
console.log('[OK] Created Kimi profile: ~/.ccs/kimi.settings.json');
|
|
console.log('');
|
|
console.log(' [!] Configure Kimi API key:');
|
|
console.log(' 1. Get key from: https://www.kimi.com/coding (membership page)');
|
|
console.log(' 2. Edit: ~/.ccs/kimi.settings.json');
|
|
console.log(' 3. Replace: YOUR_KIMI_API_KEY_HERE');
|
|
} else {
|
|
console.log('[OK] Kimi profile exists: ~/.ccs/kimi.settings.json (preserved)');
|
|
}
|
|
|
|
// NOTE: gemini.settings.json and codex.settings.json are NOT created during install
|
|
// They are created on-demand when user runs `ccs gemini` or `ccs codex` for the first time
|
|
// This prevents confusion - users need to run `--auth` first anyway
|
|
|
|
// Migrate existing Kimi configs to use kimi-k2-thinking-turbo model (v5.5.0)
|
|
// Kimi API now supports model specification with thinking models
|
|
if (fs.existsSync(kimiSettingsPath)) {
|
|
try {
|
|
const existing = JSON.parse(fs.readFileSync(kimiSettingsPath, 'utf8'));
|
|
let updated = false;
|
|
const defaultModel = 'kimi-k2-thinking-turbo';
|
|
|
|
// Ensure env object exists
|
|
if (!existing.env) {
|
|
existing.env = {};
|
|
updated = true;
|
|
}
|
|
|
|
// Add/update model fields to use kimi-k2-thinking-turbo
|
|
const modelFields = {
|
|
ANTHROPIC_MODEL: defaultModel,
|
|
ANTHROPIC_DEFAULT_OPUS_MODEL: defaultModel,
|
|
ANTHROPIC_DEFAULT_SONNET_MODEL: defaultModel,
|
|
ANTHROPIC_DEFAULT_HAIKU_MODEL: defaultModel
|
|
};
|
|
|
|
for (const [field, value] of Object.entries(modelFields)) {
|
|
if (existing.env[field] !== value) {
|
|
existing.env[field] = value;
|
|
updated = true;
|
|
}
|
|
}
|
|
|
|
// Remove deprecated ANTHROPIC_SMALL_FAST_MODEL if present
|
|
if (existing.env.ANTHROPIC_SMALL_FAST_MODEL !== undefined) {
|
|
delete existing.env.ANTHROPIC_SMALL_FAST_MODEL;
|
|
updated = true;
|
|
}
|
|
|
|
// Ensure required fields exist
|
|
if (!existing.env.ANTHROPIC_BASE_URL) {
|
|
existing.env.ANTHROPIC_BASE_URL = 'https://api.kimi.com/coding/';
|
|
updated = true;
|
|
}
|
|
|
|
// Add alwaysThinkingEnabled if missing
|
|
if (existing.alwaysThinkingEnabled === undefined) {
|
|
existing.alwaysThinkingEnabled = true;
|
|
updated = true;
|
|
}
|
|
|
|
// Write back if updated
|
|
if (updated) {
|
|
const tmpPath = `${kimiSettingsPath}.tmp`;
|
|
fs.writeFileSync(tmpPath, JSON.stringify(existing, null, 2) + '\n', 'utf8');
|
|
fs.renameSync(tmpPath, kimiSettingsPath);
|
|
console.log('[OK] Migrated Kimi config (v5.5.0): updated to kimi-k2-thinking-turbo model');
|
|
}
|
|
} catch (err) {
|
|
console.warn('[!] Kimi config migration failed:', err.message);
|
|
console.warn(' Existing config preserved');
|
|
}
|
|
}
|
|
|
|
// 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();
|