@burgan-tech/vnext-workflow-cli 1.0.2 → 1.0.3

package/README.md

@@ -254,18 +254,85 @@ wf csx --file x.csx # Process a single file
 **Purpose**: Configuration management
 
 ```bash
-wf config get              # Show all settings
+wf config get              # Show all settings (active domain)
 wf config get PROJECT_ROOT # Show a specific setting
-wf config set DB_PASSWORD pass # Change a setting
+wf config set DB_PASSWORD pass # Change a setting (on active domain)
 ```
 
+**Note:** `config get` and `config set` always operate on the **active domain**. Use `wf domain use <name>` to switch domains.
+
+---
+
+### `wf domain [action] [name] [options]`
+
+**Purpose**: Multidomain management
+
+Manage multiple domain configurations. Switch between domains with a single command. All CLI commands automatically use the active domain's settings.
+
+```bash
+# Show active domain name
+wf domain active
+
+# List all domains
+wf domain list
+wf domain --list
+
+# Add a new domain
+wf domain add staging --API_BASE_URL http://staging.example.com:4201 --DB_NAME vNext_StagingDb
+
+# Add a domain with multiple settings
+wf domain add production \
+  --API_BASE_URL http://prod.example.com:4201 \
+  --DB_NAME vNext_ProdDb \
+  --DB_HOST prod-db.example.com \
+  --DB_USER prod_user \
+  --DB_PASSWORD prod_pass
+
+# Switch active domain
+wf domain use staging
+
+# Remove a domain
+wf domain remove staging
+```
+
+**Notes:**
+- When adding a domain, any unspecified settings are inherited from the `default` domain.
+- The `default` domain cannot be removed.
+- If the active domain is removed, the CLI automatically switches to `default`.
+
 ---
 
 ## ⚙️ Configuration Variables
 
 Config file location: `~/.config/vnext-workflow-cli/config.json`
 
-### All Available Settings
+### Config File Format
+
+The config file uses a domain-aware structure. Each domain has its own set of configuration values:
+
+```json
+{
+  "ACTIVE_DOMAIN": "default",
+  "DOMAINS": [
+    {
+      "DOMAIN_NAME": "default",
+      "AUTO_DISCOVER": true,
+      "API_BASE_URL": "http://localhost:4201",
+      "API_VERSION": "v1",
+      "DB_HOST": "localhost",
+      "DB_PORT": 5432,
+      "DB_NAME": "vNext_WorkflowDb",
+      "DB_USER": "postgres",
+      "DB_PASSWORD": "postgres",
+      "USE_DOCKER": false,
+      "DOCKER_POSTGRES_CONTAINER": "vnext-postgres",
+      "DEBUG_MODE": false
+    }
+  ]
+}
+```
+
+### All Available Settings (Per Domain)
 
 | Variable | Default | Description |
 |----------|---------|-------------|
@@ -287,7 +354,7 @@ Config file location: `~/.config/vnext-workflow-cli/config.json`
 ### Quick Setup Examples
 
 ```bash
-# API settings
+# API settings (applied to active domain)
 wf config set API_BASE_URL http://localhost:4201
 wf config set API_VERSION v1
 
@@ -351,6 +418,26 @@ wf reset
 wf csx
 ```
 
+### 6. Multidomain Workflow
+```bash
+# Add domains
+wf domain add domain-a --API_BASE_URL http://localhost:4201 --DB_NAME vNext_DomainA
+wf domain add domain-b --API_BASE_URL http://localhost:4221 --DB_NAME vNext_DomainB
+
+# Work on Domain A
+wf domain use domain-a
+wf check
+wf update
+
+# Switch to Domain B - config is applied automatically
+wf domain use domain-b
+wf check
+wf update
+
+# See all domains
+wf domain list
+```
+
 ---
 
 ## 🔄 Command Comparison
@@ -364,6 +451,89 @@ wf csx
 
 ---
 
+## 🔀 Multidomain Support
+
+### Overview
+
+The CLI supports managing multiple domain configurations. Each domain has its own `API_BASE_URL`, `DB_NAME`, and other settings. Switch between domains with a single command.
+
+### Backward Compatibility
+
+- Existing single-domain configurations are automatically migrated to the new format.
+- A `default` domain is created with your existing settings.
+- If you don't use multidomain features, everything works exactly as before.
+- All `wf config get/set` commands continue to work (they operate on the active domain).
+
+### Migration
+
+When upgrading from an older version, the CLI automatically migrates the config file:
+
+**Before (old flat format):**
+```json
+{
+  "API_BASE_URL": "http://localhost:4201",
+  "DB_NAME": "vNext_WorkflowDb"
+}
+```
+
+**After (new domain-aware format):**
+```json
+{
+  "ACTIVE_DOMAIN": "default",
+  "DOMAINS": [
+    {
+      "DOMAIN_NAME": "default",
+      "AUTO_DISCOVER": true,
+      "API_BASE_URL": "http://localhost:4201",
+      "API_VERSION": "v1",
+      "DB_HOST": "localhost",
+      "DB_PORT": 5432,
+      "DB_NAME": "vNext_WorkflowDb",
+      "DB_USER": "postgres",
+      "DB_PASSWORD": "postgres",
+      "USE_DOCKER": false,
+      "DOCKER_POSTGRES_CONTAINER": "vnext-postgres",
+      "DEBUG_MODE": false
+    }
+  ]
+}
+```
+
+Your existing values are preserved. Any missing keys are filled in from defaults (11 keys total).
+
+No manual action is required. The migration happens automatically on first run.
+
+### Domain Commands
+
+| Command | Description |
+|---------|-------------|
+| `wf domain active` | Show active domain name |
+| `wf domain list` | List all domains with active indicator |
+| `wf domain --list` | List all domains (shorthand) |
+| `wf domain add <name> [options]` | Add a new domain |
+| `wf domain use <name>` | Switch active domain |
+| `wf domain remove <name>` | Remove a domain |
+
+### Available Options for `wf domain add`
+
+| Option | Description |
+|--------|-------------|
+| `--API_BASE_URL <url>` | API base URL |
+| `--API_VERSION <version>` | API version |
+| `--DB_HOST <host>` | Database host |
+| `--DB_PORT <port>` | Database port |
+| `--DB_NAME <name>` | Database name |
+| `--DB_USER <user>` | Database user |
+| `--DB_PASSWORD <password>` | Database password |
+| `--AUTO_DISCOVER <true/false>` | Auto discover components |
+| `--USE_DOCKER <true/false>` | Use Docker for DB |
+| `--DOCKER_POSTGRES_CONTAINER <name>` | Docker container name |
+| `--DEBUG_MODE <true/false>` | Debug mode |
+
+Unspecified options inherit from the `default` domain.
+
+---
+
 ## 🆘 Troubleshooting
 
 ### "vnext.config.json not found"
@@ -501,6 +671,7 @@ vnext-workflow-cli/
 │   │   ├── check.js
 │   │   ├── config.js
 │   │   ├── csx.js
+│   │   ├── domain.js        # Multidomain management
 │   │   ├── reset.js
 │   │   ├── sync.js
 │   │   └── update.js

package/bin/workflow.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-const { program } = require('commander');
+const { program, Argument } = require('commander');
 const chalk = require('chalk');
 const pkg = require('../package.json');
 
@@ -11,6 +11,7 @@ const updateCommand = require('../src/commands/update');
 const syncCommand = require('../src/commands/sync');
 const resetCommand = require('../src/commands/reset');
 const configCommand = require('../src/commands/config');
+const domainCommand = require('../src/commands/domain');
 
 program
   .name('workflow')
@@ -20,46 +21,80 @@ program
 // Check command
 program
   .command('check')
-  .description('Sistem kontrolü (API, DB, klasörler)')
+  .description('System check (API, DB, directories)')
   .action(checkCommand);
 
 // CSX command
 program
   .command('csx')
-  .description('CSX dosyalarını güncelle')
-  .option('-a, --all', 'Tüm CSX dosyalarını güncelle')
-  .option('-f, --file <path>', 'Belirli bir CSX dosyasını güncelle')
+  .description('Update CSX files')
+  .option('-a, --all', 'Update all CSX files')
+  .option('-f, --file <path>', 'Update a specific CSX file')
   .action(csxCommand);
 
 // Update command
 program
   .command('update')
-  .description('Workflow\'ları güncelle')
-  .option('-a, --all', 'Tüm workflow\'ları güncelle')
-  .option('-f, --file <path>', 'Belirli bir workflow\'u güncelle')
+  .description('Update workflows')
+  .option('-a, --all', 'Update all workflows')
+  .option('-f, --file <path>', 'Update a specific workflow')
   .action(updateCommand);
 
 // Sync command
 program
   .command('sync')
-  .description('DB\'de eksik olanları ekle')
+  .description('Add missing entries to DB')
   .action(syncCommand);
 
 // Reset command
 program
   .command('reset')
-  .description('Workflow\'ları resetle (force update)')
+  .description('Reset workflows (force update)')
   .action(resetCommand);
 
 // Config command
 program
   .command('config')
-  .description('Konfigürasyon yönetimi')
-  .argument('<action>', 'set veya get')
+  .description('Configuration management')
+  .argument('<action>', 'set or get')
   .argument('[key]', 'Config key')
   .argument('[value]', 'Config value')
   .action(configCommand);
 
+// Domain command
+program
+  .command('domain')
+  .description('Domain management (multidomain support)')
+  .addArgument(new Argument('[action]', 'Action to perform').choices(['active', 'add', 'use', 'list', 'remove']))
+  .argument('[name]', 'Domain name')
+  .option('-l, --list', 'List domains')
+  .option('--API_BASE_URL <url>', 'API base URL')
+  .option('--API_VERSION <version>', 'API version')
+  .option('--DB_HOST <host>', 'Database host')
+  .option('--DB_PORT <port>', 'Database port')
+  .option('--DB_NAME <dbname>', 'Database name')
+  .option('--DB_USER <user>', 'Database username')
+  .option('--DB_PASSWORD <password>', 'Database password')
+  .option('--AUTO_DISCOVER <value>', 'Auto discover (true/false)')
+  .option('--USE_DOCKER <value>', 'Use Docker (true/false)')
+  .option('--DOCKER_POSTGRES_CONTAINER <container>', 'Docker PostgreSQL container name')
+  .option('--DEBUG_MODE <value>', 'Debug mode (true/false)')
+  .addHelpText('after', `
+Examples:
+  wf domain active                                                   Show active domain name
+  wf domain list                                                     List domains
+  wf domain --list                                                   List domains
+  wf domain add domain-a --API_BASE_URL http://localhost:4201 --DB_NAME myDb   Add a new domain
+  wf domain use domain-a                                             Switch active domain
+  wf domain remove domain-a                                          Remove a domain
+
+Notes:
+  - When adding a domain, unspecified settings are inherited from the default domain.
+  - The default domain cannot be deleted.
+  - If the active domain is deleted, it automatically switches back to default.
+`)
+  .action(domainCommand);
+
 // Parse arguments
 program.parse(process.argv);
 
@@ -67,4 +102,3 @@ program.parse(process.argv);
 if (!process.argv.slice(2).length) {
   program.outputHelp();
 }
-

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@burgan-tech/vnext-workflow-cli",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "vNext Workflow Manager - CLI tool for managing workflows, tasks, schemas and more",
   "main": "dist/index.js",
   "bin": {

package/src/commands/config.js

@@ -7,21 +7,28 @@ async function configCommand(action, key, value) {
       const val = config.get(key);
       console.log(chalk.cyan(`${key}:`), val);
     } else {
-      // Show all config
-      console.log(chalk.cyan.bold('\n📝 Current Configuration:\n'));
+      // Show all config with active domain info
       const all = config.getAll();
+      console.log(chalk.cyan.bold('\n📝 Current Configuration:\n'));
+      console.log(chalk.yellow(`  Active Domain: ${all.ACTIVE_DOMAIN}\n`));
       for (const [k, v] of Object.entries(all)) {
-        console.log(chalk.cyan(`${k}:`), chalk.white(v));
+        if (k === 'ACTIVE_DOMAIN' || k === 'DOMAIN_NAME') continue;
+        console.log(chalk.cyan(`  ${k}:`), chalk.white(v));
       }
-      console.log(chalk.dim(`\nConfig file: ${config.path}\n`));
+      console.log(chalk.dim(`\n  Config file: ${config.path}`));
+      console.log(chalk.dim(`  Tip: Use "wf domain list" to see all domains.\n`));
     }
   } else if (action === 'set') {
     if (!key || value === undefined) {
       console.log(chalk.red('Usage: workflow config set <key> <value>'));
       return;
     }
-    config.set(key, value);
-    console.log(chalk.green(`✓ ${key} = ${value}`));
+    try {
+      config.set(key, value);
+      console.log(chalk.green(`✓ ${key} = ${value}`));
+    } catch (error) {
+      console.log(chalk.red(`✗ ${error.message}`));
+    }
   } else {
     console.log(chalk.red('Invalid action. Use: get or set'));
   }

package/src/commands/domain.js

@@ -0,0 +1,161 @@
+const chalk = require('chalk');
+const config = require('../lib/config');
+
+const VALID_KEYS = [
+  'API_BASE_URL', 'API_VERSION', 'DB_HOST', 'DB_PORT', 'DB_NAME',
+  'DB_USER', 'DB_PASSWORD', 'AUTO_DISCOVER', 'USE_DOCKER',
+  'DOCKER_POSTGRES_CONTAINER', 'DEBUG_MODE'
+];
+
+const NUMERIC_KEYS = ['DB_PORT'];
+const BOOLEAN_KEYS = ['AUTO_DISCOVER', 'USE_DOCKER', 'DEBUG_MODE'];
+
+/**
+ * Coerces a string value to the correct type based on key.
+ * Only known numeric keys become numbers; only known boolean keys become booleans.
+ * All other values remain as strings.
+ */
+function coerceValue(key, value) {
+  if (BOOLEAN_KEYS.includes(key)) {
+    return value === 'true';
+  }
+  if (NUMERIC_KEYS.includes(key)) {
+    const num = Number(value);
+    return isNaN(num) ? value : num;
+  }
+  return value;
+}
+
+/**
+ * Extracts and coerces valid domain config options from Commander options object.
+ */
+function extractOptions(options) {
+  const parsed = {};
+  for (const key of VALID_KEYS) {
+    if (options[key] !== undefined) {
+      parsed[key] = coerceValue(key, options[key]);
+    }
+  }
+  return parsed;
+}
+
+/**
+ * Main domain command handler.
+ * Dispatches to add, use, list, or remove based on action argument.
+ */
+async function domainCommand(action, name, options) {
+  // Support wf domain --list
+  if (options.list || action === 'list') {
+    return listDomains();
+  }
+
+  if (action === 'active') {
+    return showActiveDomain();
+  }
+
+  if (action === 'add') {
+    return addDomain(name, options);
+  }
+
+  if (action === 'use') {
+    return useDomain(name);
+  }
+
+  if (action === 'remove') {
+    return removeDomain(name);
+  }
+
+  // No valid action - show usage
+  console.log(chalk.cyan.bold('\n🌐 Domain Management\n'));
+  console.log('Usage:');
+  console.log(chalk.white('  wf domain active                                       Show active domain'));
+  console.log(chalk.white('  wf domain list                                         List all domains'));
+  console.log(chalk.white('  wf domain add <name> [--API_BASE_URL ...] [--DB_NAME ...]  Add a domain'));
+  console.log(chalk.white('  wf domain use <name>                                   Switch active domain'));
+  console.log(chalk.white('  wf domain remove <name>                                Remove a domain'));
+  console.log('');
+}
+
+function showActiveDomain() {
+  console.log(config.get('ACTIVE_DOMAIN'));
+}
+
+function addDomain(name, options) {
+  if (!name) {
+    console.log(chalk.red('Usage: wf domain add <name> [--API_BASE_URL <url>] [--DB_NAME <name>] ...'));
+    return;
+  }
+
+  try {
+    const parsed = extractOptions(options);
+    const domain = config.addDomain(name, parsed);
+
+    console.log(chalk.green(`\n✓ Domain "${name}" added successfully.\n`));
+    printDomainConfig(domain);
+  } catch (error) {
+    console.log(chalk.red(`\n✗ Error: ${error.message}\n`));
+  }
+}
+
+function useDomain(name) {
+  if (!name) {
+    console.log(chalk.red('Usage: wf domain use <name>'));
+    return;
+  }
+
+  try {
+    config.useDomain(name);
+    console.log(chalk.green(`\n✓ Active domain switched to "${name}".\n`));
+
+    // Show key applied config values
+    const domainConfig = config.getActiveDomainConfig();
+    console.log(chalk.cyan('Applied settings:'));
+    console.log(chalk.cyan('  API_BASE_URL:'), chalk.white(domainConfig.API_BASE_URL));
+    console.log(chalk.cyan('  DB_NAME:     '), chalk.white(domainConfig.DB_NAME));
+    console.log('');
+  } catch (error) {
+    console.log(chalk.red(`\n✗ Error: ${error.message}\n`));
+  }
+}
+
+function listDomains() {
+  const { activeDomain, domains } = config.listDomains();
+
+  console.log(chalk.cyan.bold('\n🌐 Domains:\n'));
+
+  for (const domain of domains) {
+    const isActive = domain.DOMAIN_NAME === activeDomain;
+    const marker = isActive ? chalk.green('▸ ') : '  ';
+    const label = isActive
+      ? chalk.green.bold(domain.DOMAIN_NAME) + chalk.green(' (active)')
+      : chalk.white(domain.DOMAIN_NAME);
+
+    console.log(`${marker}${label}`);
+    console.log(chalk.dim(`    API: ${domain.API_BASE_URL}  DB: ${domain.DB_NAME}`));
+  }
+
+  console.log('');
+}
+
+function removeDomain(name) {
+  if (!name) {
+    console.log(chalk.red('Usage: wf domain remove <name>'));
+    return;
+  }
+
+  try {
+    config.removeDomain(name);
+    console.log(chalk.green(`\n✓ Domain "${name}" removed.\n`));
+  } catch (error) {
+    console.log(chalk.red(`\n✗ Error: ${error.message}\n`));
+  }
+}
+
+function printDomainConfig(domain) {
+  for (const [key, value] of Object.entries(domain)) {
+    console.log(chalk.cyan(`  ${key}:`), chalk.white(value));
+  }
+  console.log('');
+}
+
+module.exports = domainCommand;

package/src/lib/api.js

@@ -1,9 +1,9 @@
 const axios = require('axios');
 
 /**
- * API bağlantısını test eder
+ * Tests the API connection
  * @param {string} baseUrl - API base URL
- * @returns {Promise<boolean>} Bağlantı durumu
+ * @returns {Promise<boolean>} Connection status
  */
 async function testApiConnection(baseUrl) {
   try {
@@ -17,9 +17,9 @@ async function testApiConnection(baseUrl) {
 }
 
 /**
- * Komponenti API'ye publish eder
+ * Publishes a component to the API
  * @param {string} baseUrl - API base URL
- * @param {Object} componentData - Komponent JSON verisi
+ * @param {Object} componentData - Component JSON data
  * @returns {Promise<Object>} API response
  */
 async function publishComponent(baseUrl, componentData) {
@@ -39,7 +39,7 @@ async function publishComponent(baseUrl, componentData) {
       data: response.data
     };
   } catch (error) {
-    // API hata detaylarını çıkar
+    // Extract API error details
     let errorMessage = error.message;
     let errorDetails = null;
     
@@ -68,10 +68,10 @@ async function publishComponent(baseUrl, componentData) {
 }
 
 /**
- * Sistemi yeniden başlatır
+ * Reinitializes the system
  * @param {string} baseUrl - API base URL
  * @param {string} version - API version
- * @returns {Promise<boolean>} Başarı durumu
+ * @returns {Promise<boolean>} Success status
  */
 async function reinitializeSystem(baseUrl, version) {
   const url = `${baseUrl}/api/${version}/definitions/re-initialize`;

package/src/lib/config.js

@@ -1,67 +1,239 @@
 const Conf = require('conf');
-const path = require('path');
+
+// Default config values for a domain
+const DEFAULT_DOMAIN_CONFIG = {
+  AUTO_DISCOVER: true,
+  API_BASE_URL: 'http://localhost:4201',
+  API_VERSION: 'v1',
+  DB_HOST: 'localhost',
+  DB_PORT: 5432,
+  DB_NAME: 'vNext_WorkflowDb',
+  DB_USER: 'postgres',
+  DB_PASSWORD: 'postgres',
+  USE_DOCKER: false,
+  DOCKER_POSTGRES_CONTAINER: 'vnext-postgres',
+  DEBUG_MODE: false
+};
+
+const DOMAIN_CONFIG_KEYS = Object.keys(DEFAULT_DOMAIN_CONFIG);
 
 const config = new Conf({
-  projectName: 'vnext-workflow-cli',
-  defaults: {
-    AUTO_DISCOVER: true,
-    API_BASE_URL: 'http://localhost:4201',
-    API_VERSION: 'v1',
-    DB_HOST: 'localhost',
-    DB_PORT: 5432,
-    DB_NAME: 'vNext_WorkflowDb',
-    DB_USER: 'postgres',
-    DB_PASSWORD: 'postgres',
-    USE_DOCKER: false,
-    DOCKER_POSTGRES_CONTAINER: 'vnext-postgres',
-    DEBUG_MODE: false
-  }
+  projectName: 'vnext-workflow-cli'
 });
 
 /**
- * Gets a config value
- * PROJECT_ROOT always returns current working directory (process.cwd())
+ * Migrates old flat config to new domain-aware format.
+ * Old: { API_BASE_URL: "...", DB_NAME: "..." }
+ * New: { ACTIVE_DOMAIN: "default", DOMAINS: [{ DOMAIN_NAME: "default", ... }] }
+ */
+function migrateConfig() {
+  const store = config.store;
+
+  // Already in new format - skip
+  if (store.ACTIVE_DOMAIN !== undefined && Array.isArray(store.DOMAINS)) {
+    return;
+  }
+
+  // Collect existing values from old flat config
+  const existingValues = {};
+  for (const key of DOMAIN_CONFIG_KEYS) {
+    if (store[key] !== undefined) {
+      existingValues[key] = store[key];
+    }
+  }
+
+  // Create default domain: defaults + any existing overrides
+  const defaultDomain = {
+    DOMAIN_NAME: 'default',
+    ...DEFAULT_DOMAIN_CONFIG,
+    ...existingValues
+  };
+
+  // Clear old keys and set new format via conf API
+  for (const key of DOMAIN_CONFIG_KEYS) {
+    config.delete(key);
+  }
+  config.set('ACTIVE_DOMAIN', 'default');
+  config.set('DOMAINS', [defaultDomain]);
+}
+
+// Run migration on module load
+migrateConfig();
+
+/**
+ * Returns the active domain config object.
+ * @returns {Object} Active domain config
+ */
+function getActiveDomainConfig() {
+  const activeDomain = config.get('ACTIVE_DOMAIN');
+  const domains = config.get('DOMAINS') || [];
+  const domain = domains.find(d => d.DOMAIN_NAME === activeDomain);
+
+  if (!domain) {
+    throw new Error(`Active domain "${activeDomain}" not found in config.`);
+  }
+  return domain;
+}
+
+/**
+ * Gets a config value from the active domain.
+ * PROJECT_ROOT always returns process.cwd().
  * @param {string} key - Config key
  * @returns {any} Config value
  */
 function get(key) {
-  // PROJECT_ROOT is always the current working directory
   if (key === 'PROJECT_ROOT') {
     return process.cwd();
   }
-  return config.get(key);
+  if (key === 'ACTIVE_DOMAIN') {
+    return config.get('ACTIVE_DOMAIN');
+  }
+  const domainConfig = getActiveDomainConfig();
+  return domainConfig[key];
 }
 
 /**
- * Sets a config value
- * PROJECT_ROOT cannot be set (ignored)
+ * Sets a config value on the active domain.
+ * PROJECT_ROOT cannot be set (always uses cwd).
  * @param {string} key - Config key
  * @param {any} value - Config value
  */
 function set(key, value) {
-  // PROJECT_ROOT cannot be saved - always uses cwd
-  if (key === 'PROJECT_ROOT') {
-    console.log('Note: PROJECT_ROOT is always the current working directory and cannot be changed.');
-    return;
+  const RESERVED_KEYS = {
+    PROJECT_ROOT: 'PROJECT_ROOT is always the current working directory and cannot be changed.',
+    DOMAIN_NAME: 'DOMAIN_NAME cannot be changed directly. Use "wf domain add/remove" instead.',
+    ACTIVE_DOMAIN: 'ACTIVE_DOMAIN cannot be changed directly. Use "wf domain use <name>" instead.'
+  };
+
+  if (RESERVED_KEYS[key]) {
+    throw new Error(RESERVED_KEYS[key]);
+  }
+
+  const activeDomainName = config.get('ACTIVE_DOMAIN');
+  const domains = config.get('DOMAINS') || [];
+  const idx = domains.findIndex(d => d.DOMAIN_NAME === activeDomainName);
+
+  if (idx === -1) {
+    throw new Error(`Active domain "${activeDomainName}" not found.`);
   }
-  config.set(key, value);
+
+  domains[idx][key] = value;
+  config.set('DOMAINS', domains);
 }
 
 /**
- * Gets all config values including PROJECT_ROOT
- * @returns {Object} All config values
+ * Gets all config values from the active domain.
+ * @returns {Object} All config values including PROJECT_ROOT and ACTIVE_DOMAIN
  */
 function getAll() {
+  const domainConfig = getActiveDomainConfig();
   return {
     PROJECT_ROOT: process.cwd(),
-    ...config.store
+    ACTIVE_DOMAIN: config.get('ACTIVE_DOMAIN'),
+    ...domainConfig
   };
 }
 
+/**
+ * Resets config to default state.
+ */
+function clear() {
+  config.clear();
+  config.set('ACTIVE_DOMAIN', 'default');
+  config.set('DOMAINS', [{
+    DOMAIN_NAME: 'default',
+    ...DEFAULT_DOMAIN_CONFIG
+  }]);
+}
+
+/**
+ * Adds a new domain. Missing values are inherited from the default domain.
+ * @param {string} name - Domain name
+ * @param {Object} options - Domain config overrides
+ * @returns {Object} Created domain config
+ */
+function addDomain(name, options) {
+  const domains = config.get('DOMAINS') || [];
+
+  if (domains.find(d => d.DOMAIN_NAME === name)) {
+    throw new Error(`Domain "${name}" already exists.`);
+  }
+
+  // Use default domain as base, fall back to DEFAULT_DOMAIN_CONFIG
+  const defaultDomain = domains.find(d => d.DOMAIN_NAME === 'default');
+  const base = defaultDomain
+    ? { ...defaultDomain }
+    : { ...DEFAULT_DOMAIN_CONFIG };
+  delete base.DOMAIN_NAME;
+
+  const newDomain = {
+    DOMAIN_NAME: name,
+    ...base,
+    ...options
+  };
+
+  domains.push(newDomain);
+  config.set('DOMAINS', domains);
+  return newDomain;
+}
+
+/**
+ * Switches the active domain.
+ * @param {string} name - Domain name to activate
+ */
+function useDomain(name) {
+  const domains = config.get('DOMAINS') || [];
+  if (!domains.find(d => d.DOMAIN_NAME === name)) {
+    throw new Error(`Domain "${name}" not found.`);
+  }
+  config.set('ACTIVE_DOMAIN', name);
+}
+
+/**
+ * Lists all domains with active domain info.
+ * @returns {Object} { activeDomain, domains }
+ */
+function listDomains() {
+  return {
+    activeDomain: config.get('ACTIVE_DOMAIN'),
+    domains: config.get('DOMAINS') || []
+  };
+}
+
+/**
+ * Removes a domain. Cannot remove the default domain.
+ * If the removed domain was active, switches to default.
+ * @param {string} name - Domain name to remove
+ */
+function removeDomain(name) {
+  if (name === 'default') {
+    throw new Error('Cannot remove the default domain.');
+  }
+
+  const domains = config.get('DOMAINS') || [];
+  const filtered = domains.filter(d => d.DOMAIN_NAME !== name);
+
+  if (filtered.length === domains.length) {
+    throw new Error(`Domain "${name}" not found.`);
+  }
+
+  config.set('DOMAINS', filtered);
+
+  if (config.get('ACTIVE_DOMAIN') === name) {
+    config.set('ACTIVE_DOMAIN', 'default');
+  }
+}
+
 module.exports = {
   get,
   set,
   getAll,
-  clear: () => config.clear(),
-  path: config.path
+  clear,
+  path: config.path,
+  addDomain,
+  useDomain,
+  listDomains,
+  removeDomain,
+  getActiveDomainConfig,
+  DEFAULT_DOMAIN_CONFIG
 };

package/src/lib/db.js

@@ -5,11 +5,11 @@ const util = require('util');
 const execPromise = util.promisify(exec);
 
 /**
- * DB bağlantısını test eder
+ * Tests the DB connection
  */
 async function testDbConnection(dbConfig) {
   if (dbConfig.useDocker) {
-    // Docker üzerinden test
+    // Test via Docker
     try {
       const cmd = `docker exec ${dbConfig.dockerContainer} psql -U ${dbConfig.user} -d ${dbConfig.database} -c "SELECT 1;"`;
       await execPromise(cmd);
@@ -18,7 +18,7 @@ async function testDbConnection(dbConfig) {
       return false;
     }
   } else {
-    // Direkt bağlantı
+    // Direct connection
     const client = new Client({
       host: dbConfig.host,
       port: dbConfig.port,
@@ -39,15 +39,15 @@ async function testDbConnection(dbConfig) {
 }
 
 /**
- * Workflow'un DB'deki ID'sini bulur
- * NOT: Version kontrolü yapmıyoruz, sadece Key'e bakıyoruz (bash script gibi)
+ * Finds the workflow's ID in the DB
+ * NOTE: We don't check version, only the Key (like the bash script)
  */
 async function getInstanceId(dbConfig, schema, key, version) {
   const dbSchema = schema.replace(/-/g, '_');
   const query = `SELECT "Id" FROM "${dbSchema}"."Instances" WHERE "Key" = $1 ORDER BY "CreatedAt" DESC LIMIT 1`;
   
   if (dbConfig.useDocker) {
-    // Docker üzerinden - SQL içindeki double quote'ları backslash ile escape et
+    // Via Docker - escape double quotes in SQL with backslash
     const cmd = `docker exec ${dbConfig.dockerContainer} psql -U ${dbConfig.user} -d ${dbConfig.database} -t -c "SELECT \\"Id\\" FROM \\"${dbSchema}\\".\\"Instances\\" WHERE \\"Key\\" = '${key}' ORDER BY \\"CreatedAt\\" DESC LIMIT 1"`;
     try {
       const { stdout } = await execPromise(cmd);
@@ -57,7 +57,7 @@ async function getInstanceId(dbConfig, schema, key, version) {
       return null;
     }
   } else {
-    // Direkt bağlantı
+    // Direct connection
     const client = new Client({
       host: dbConfig.host,
       port: dbConfig.port,
@@ -78,13 +78,13 @@ async function getInstanceId(dbConfig, schema, key, version) {
 }
 
 /**
- * Workflow'u DB'den siler
+ * Deletes a workflow from the DB
  */
 async function deleteWorkflow(dbConfig, schema, instanceId) {
   const dbSchema = schema.replace(/-/g, '_');
   
   if (dbConfig.useDocker) {
-    // Docker üzerinden - Double quote'ları escape et
+    // Via Docker - escape double quotes
     const cmd = `docker exec ${dbConfig.dockerContainer} psql -U ${dbConfig.user} -d ${dbConfig.database} -c "DELETE FROM \\"${dbSchema}\\".\\"Instances\\" WHERE \\"Id\\" = '${instanceId}'"`;
     try {
       await execPromise(cmd);
@@ -93,7 +93,7 @@ async function deleteWorkflow(dbConfig, schema, instanceId) {
       return false;
     }
   } else {
-    // Direkt bağlantı
+    // Direct connection
     const query = `DELETE FROM "${dbSchema}"."Instances" WHERE "Id" = $1`;
     const client = new Client({
       host: dbConfig.host,