​

Configuration Schema Reference

​

Version History

​

Root Schema

version: 14 # REQUIRED - Schema version
default: <profile-name> # OPTIONAL - Default profile name

accounts: { ... } # Account-based profiles
profiles: { ... } # API-based profiles
cliproxy: { ... } # OAuth provider configuration and user routing rules
proxy: { ... } # OpenAI-compatible local proxy configuration (v13+)
logging: { ... } # CCS-owned structured runtime logging
preferences: { ... } # User preferences
websearch: { ... } # WebSearch configuration
global_env: { ... } # Global environment variables
copilot: { ... } # Deprecated GitHub Copilot compatibility
cliproxy_server: { ... } # Remote/local proxy configuration
quota_management: { ... } # Quota management (v7+)
thinking: { ... } # Thinking/reasoning budget (v8+)
channels: { ... } # Official Channels runtime auto-enable (v12+)
dashboard_auth: { ... } # Dashboard authentication
browser: { ... } # Browser automation settings (v13+)
image_analysis: { ... } # Image analysis configuration (v8+)
continuity: { ... } # Cross-profile continuity inheritance (v9+)
docker: { ... } # Docker deployment configuration (auto-generated)

​

CLIProxy Configuration

​

cliproxy.backend

cliproxy:
  backend: original # Default: original

• original: CLIProxyAPI (works for agy, claude, codex, gemini, iflow, kimi, xai)
• plus: CCS-maintained CLIProxyAPIPlus community fork for plus-only providers. Legacy deleted-upstream Plus installs migrate safely to original
• Backend-specific binaries stored in ~/.ccs/cliproxy/bin/original/ and ~/.ccs/cliproxy/bin/plus/
• Generated local CLIProxy configs also select the matching CPAMC dashboard: upstream CPAMC for original, maintained CCS dashboard fork for plus

• Require backend: plus: kiro, cursor, gitlab, codebuddy, kilo, qoder, and deprecated ghcp compatibility
• Work on either backend: agy, claude, codex, gemini, iflow, kimi, xai

• Use original for the stable default backend and the standard provider set
• Use plus only when you need Kiro, Cursor, GitLab Duo, CodeBuddy, Kilo AI, Qoder, or deprecated GitHub Copilot compatibility

​

cliproxy.management_panel_repository

cliproxy:
  backend: plus
  management_panel_repository: https://github.com/kaitranntt/Cli-Proxy-API-Management-Center

• When omitted, backend: original uses router-for-me/Cli-Proxy-API-Management-Center
• When omitted, backend: plus uses kaitranntt/Cli-Proxy-API-Management-Center
• When set, this value is written to remote-management.panel-github-repository
• CCS regenerates stale local CLIProxy config when the expected panel repository changes

• Pin Plus users to the CCS-maintained management dashboard fork
• Test or maintain a private CPAMC fork without editing generated CLIProxy files

​

cliproxy.variants.<name>.target

cliproxy:
  variants:
    my-variant:
      provider: gemini
      target: droid # Always route to Droid CLI (claude, droid, or codex)

• claude (default): Use Claude Code CLI
• droid: Use Droid CLI (@factory/cli)
• codex: Use OpenAI Codex CLI
• Overridden by --target CLI flag

• profiles.<name>.target (API profiles)
• cliproxy.variants.<name>.target (CLIProxy variant profiles)
• Composite variant configs

​

cliproxy.variants.<name>.auth

cliproxy:
  variants:
    my-gemini:
      provider: gemini
      auth:
        api_key: "custom-key-123"
        management_secret: "custom-secret-456"

• Overrides global cliproxy.auth for specific variant
• Useful for different auth credentials per variant
• Both keys optional (falls back to global)

• Separate auth for dev/prod variants
• Per-team auth credentials
• Testing with different API keys

​

cliproxy.variants.<name>.port

cliproxy:
  variants:
    gemini-dev:
      provider: gemini
      port: 8318
    gemini-prod:
      provider: gemini
      port: 8319

• Assigns unique port for variant isolation
• Allows multiple variants to run simultaneously
• Accepts any valid port (1-65535), recommended range: 8318-8417 for CCS variants
• Default: Auto-assigned if not specified

• Run dev and prod variants concurrently
• Isolate variants for different teams
• Avoid port conflicts in multi-user environments

​

cliproxy.auth.api_key

cliproxy:
  auth:
    api_key: "ccs-internal-managed" # Default

• Used for CLIProxyAPI authentication
• Sent in x-api-key header
• Can be overridden per-variant via variants.<name>.auth.api_key
• Default: "ccs-internal-managed"

​

cliproxy.auth.management_secret

cliproxy:
  auth:
    management_secret: "ccs" # Default

• Used for CLIProxyAPI management endpoints
• Sent in x-management-secret header
• Can be overridden per-variant via variants.<name>.auth.management_secret
• Default: "ccs"

• Separate auth for management vs API operations
• Enhanced security for admin endpoints

​

cliproxy.kiro_no_incognito

cliproxy:
  kiro_no_incognito: true # Default: true

• true: Use normal browser mode (default, saves cookies/session)
• false: Force incognito mode

• Persistent AWS SSO login for Kiro
• Avoid re-entering credentials on each auth
• Development/testing with saved browser state

​

cliproxy.routing.strategy

cliproxy:
  routing:
    strategy: round-robin

• round-robin: Spread requests across matching healthy accounts
• fill-first: Drain one healthy account before touching backups
• Default stays round-robin until you explicitly change it

​

cliproxy.retry

cliproxy:
  retry:
    request_retry: 0
    max_retry_interval: 0

​

cliproxy.logging.enabled

cliproxy:
  logging:
    enabled: false # Default: false

• false: No disk logging (default, prevents bloat)
• true: Write logs to ~/.ccs/cliproxy/logs/

​

cliproxy.logging.request_log

cliproxy:
  logging:
    enabled: true
    request_log: false # Default: false

• false: Log errors/warnings only
• true: Log all HTTP requests/responses
• Requires logging.enabled: true

​

CCS Logging Configuration

​

logging.enabled

logging:
  enabled: true

​

logging.level

logging:
  level: info

​

logging.rotate_mb

logging:
  rotate_mb: 10

​

logging.retain_days

logging:
  retain_days: 7

​

logging.redact

logging:
  redact: true

​

logging.live_buffer_size

logging:
  live_buffer_size: 250

​

cliproxy.token_refresh.enabled

cliproxy:
  token_refresh:
    enabled: false # Default: false

• false: On-demand refresh only (5 min before expiry)
• true: Background worker refreshes tokens at intervals

• Long-running services needing proactive refresh
• Preventing mid-request token expiry
• CI/CD environments with extended sessions

​

cliproxy.token_refresh.interval_minutes

cliproxy:
  token_refresh:
    enabled: true
    interval_minutes: 30 # Default: 30

• Worker checks all tokens every N minutes
• Only refreshes tokens approaching expiry

​

cliproxy.token_refresh.preemptive_minutes

cliproxy:
  token_refresh:
    enabled: true
    preemptive_minutes: 45 # Default: 45

• Tokens expiring within this window are refreshed
• Higher values = more proactive refresh
• Prevents UND_ERR_SOCKET errors from stale tokens

​

cliproxy.token_refresh.max_retries

cliproxy:
  token_refresh:
    enabled: true
    max_retries: 3 # Default: 3

• Retries on transient failures
• Logs warning after max retries exceeded
• Does not re-authenticate (requires user action)

​

cliproxy.token_refresh.verbose

cliproxy:
  token_refresh:
    enabled: true
    verbose: true # Default: false

• Logs all refresh attempts to console
• Useful for debugging token issues
• Output: timestamps, providers, success/failure

​

cliproxy.oauth_model_alias

cliproxy:
  oauth_model_alias:
    codex:
      - name: gpt-5.6-sol
        alias: gpt-5.6-sol-fast
        fork: true
    future-provider:
      - name: upstream-model
        alias: client-model

• cliproxy.oauth_model_alias is the CCS unified config key
• CCS generates the upstream oauth-model-alias block inside local CLIProxy config from this structured input
• Each provider maps to an ordered array of { name, alias, fork? }
• name is the upstream model ID, alias is the client-visible model ID, and fork: true keeps both names visible when upstream supports it
• Entries are deduplicated and replaced by client alias within each provider
• Configured aliases replace matching generated aliases in place, while unmatched existing aliases and provider sections stay in order
• Unknown provider sections are preserved during regeneration

• Lets CCS keep user-owned aliases separate from generated upstream config
• Prevents regeneration from deleting custom provider alias sections
• Supports a Codex fast alias such as gpt-5.6-sol-fast without inventing a new upstream model ID

oauth-model-alias:
  codex:
    - name: gpt-5.6-sol
      alias: gpt-5.6-sol-fast
      fork: true

​

cliproxy.payload

cliproxy:
  payload:
    default:
      - models:
          - name: keep-default
        params:
          temperature: 0.2
    override:
      - models:
          - name: gpt-5.6-sol-fast
            protocol: codex
        params:
          service_tier: priority

• cliproxy.payload.override is an ordered array of scoped override rules
• Each rule must define models and params
• Model selectors can include name, optional protocol, and any extra selector constraints supported by CLIProxy
• CCS preserves extra selector fields and extra payload subsections that are not part of the override list
• A configured override replaces an existing one only when the full predicate matches aside from params
• Distinct predicates remain distinct even if they target the same model
• Matching configured rules win over existing generated-config rules during regeneration

• Keeps manual payload sections intact while CCS refreshes generated config
• Lets a Codex-specific alias pair with service_tier: priority in a stable way
• Preserves extra match constraints instead of flattening them away

payload:
  override:
    - models:
        - name: gpt-5.6-sol-fast
          protocol: codex
      params:
        service_tier: priority

​

CLIProxy Server Configuration

​

cliproxy_server.fallback.enabled

cliproxy_server:
  fallback:
    enabled: true # Default: true

• true: Try local proxy if remote unreachable
• false: Fail with PROXY_ERROR if remote fails

• Graceful degradation for network issues
• Offline work capability
• Testing without remote infrastructure

​

cliproxy_server.fallback.auto_start

cliproxy_server:
  fallback:
    enabled: true
    auto_start: false # Default: false

• false: Use existing local proxy only
• true: Spawn local proxy if not running

• Seamless fallback without manual intervention
• Ensure proxy always available

​

cliproxy_server.remote.management_key

cliproxy_server:
  remote:
    enabled: true
    host: "proxy.example.com"
    auth_token: "api-token-123"
    management_key: "mgmt-key-456" # Optional

• Used for management endpoints on remote proxy
• Falls back to auth_token if not specified
• Allows separate credentials for API vs management

​

cliproxy_server.remote.timeout

cliproxy_server:
  remote:
    enabled: true
    host: "proxy.example.com"
    timeout: 2000 # Milliseconds (defaults to 2000ms if not specified)

• Used for initial health check only
• Higher values for slow networks
• Does NOT affect API request timeouts

​

OpenAI-Compatible Local Proxy Configuration

​

proxy.port

proxy:
  port: 45000

• Used as the preferred starting port for compatible profiles
• Legacy 3456 is treated as unset unless explicitly pinned at launch
• Overridden by --port and proxy.profile_ports.<profile>

​

proxy.profile_ports

proxy:
  profile_ports:
    hf: 3460
    openrouter: 3461

• Lets multiple OpenAI-compatible profiles run at the same time
• ccs proxy status <profile> and ccs proxy activate <profile> report the actual running port

​

proxy.routing

proxy:
  routing:
    default: "deepseek:deepseek-chat"
    background: "ollama:qwen2.5-coder:0.5b"
    think: "deepseek:deepseek-reasoner"
    longContext: "openrouter:google/gemini-2.5-pro"
    longContextThreshold: 60000
    webSearch: "openrouter:perplexity/sonar-pro"

• Supports profile:model, profile, and exact model-id selectors
• Applies scenario routes for background, thinking, long-context, and web-search requests
• longContextThreshold uses an approximate token estimate

​

Browser Automation Configuration

browser:
  claude:
    enabled: false
    policy: manual
    user_data_dir: "~/.ccs/browser/chrome-user-data"
    devtools_port: 9222
    eval_mode: readonly
  codex:
    enabled: false
    policy: manual
    eval_mode: readonly

​

browser.claude

• enabled: turn the Claude attach lane on or off
• policy: manual or auto
• user_data_dir: Chrome user-data directory for attach mode
• devtools_port: expected Chrome remote debugging port
• eval_mode: disabled, readonly, or readwrite

​

browser.codex

• enabled: turn managed Codex browser tooling on or off
• policy: manual or auto
• eval_mode: disabled, readonly, or readwrite

• New installs default both lanes to disabled/manual
• manual hides browser tooling until a launch uses --browser
• --no-browser suppresses tooling even when policy is auto

​

Quota Management Configuration

​

Supported Quota Providers

​

quota_management.mode

quota_management:
  mode: hybrid # Default: hybrid

• auto: CCS selects account based on quota/tier automatically
• manual: Only use paused/forced_default settings
• hybrid: Auto-selection respects manual overrides (recommended)

​

quota_management.auto.preflight_check

quota_management:
  auto:
    preflight_check: true # Default: true

• true: Check account quota before request, auto-switch if exhausted
• false: Skip pre-flight check, rely on 429 error handling

• Prevent delays from exhausted accounts
• Smoother multi-account experience

​

quota_management.auto.exhaustion_threshold

quota_management:
  auto:
    exhaustion_threshold: 5 # Default: 5%

• Accounts below threshold are skipped in rotation
• Prevents using nearly-exhausted accounts

​

quota_management.auto.tier_priority

quota_management:
  auto:
    tier_priority: ["ultra", "pro", "free"] # Default: ["ultra", "pro", "free"]

• Accounts sorted by tier priority, then by quota %
• Tiers not in list get lowest priority

• ultra - Ultra subscription accounts
• pro - Pro subscription accounts
• free - Free tier accounts

​

quota_management.auto.cooldown_minutes

quota_management:
  auto:
    cooldown_minutes: 5 # Default: 5

• Exhausted accounts are skipped for cooldown period
• Prevents repeated failed attempts on same account

​

quota_management.manual.paused_accounts

quota_management:
  manual:
    paused_accounts: [] # Default: []

• Listed accounts are never selected automatically
• Set via ccs cliproxy pause <provider> <account>
• Remove via ccs cliproxy resume <provider> <account>

​

quota_management.manual.forced_default

quota_management:
  manual:
    forced_default: null # Default: null

• null: Normal account rotation
• <email>: Always use this account

• Testing specific account
• Temporarily override rotation

​

quota_management.manual.tier_lock

quota_management:
  manual:
    tier_lock: null # Default: null

• null: Use all tiers
• paid: Only paid accounts
• free: Only free accounts

​

Global Environment Variables

​

global_env.enabled

global_env:
  enabled: true # Default: true

• true: Inject global_env.env into all non-Claude profiles
• false: Disable feature

• Disable Claude Code telemetry for proxy providers
• Set common env vars across all profiles

​

global_env.env

global_env:
  enabled: true
  env:
    DISABLE_BUG_COMMAND: "1"
    DISABLE_ERROR_REPORTING: "1"
    DISABLE_TELEMETRY: "1"

• Applied to settings-based and CLIProxy profiles
• NOT applied to native Claude or account-based profiles
• Merged with profile-specific env vars

• DISABLE_BUG_COMMAND: "1"
• DISABLE_ERROR_REPORTING: "1"
• DISABLE_TELEMETRY: "1"

• Disable Claude Code telemetry globally
• Set API base URLs
• Configure logging levels

​

WebSearch Configuration

​

websearch.providers.gemini.model

websearch:
  providers:
    gemini:
      enabled: true
      model: "gemini-2.5-flash" # Default
      timeout: 55

• Used by WebSearch hook for third-party profiles
• Free tier: 1000 requests/day
• Falls back to OpenCode/Grok if fails

• gemini-2.5-flash (default, fastest)
• gemini-2.5-pro (more accurate)

​

websearch.providers.gemini.timeout

websearch:
  providers:
    gemini:
      timeout: 55 # Default: 55 seconds

• Max time for single WebSearch request
• Prevents hanging on slow responses
• Falls back to next provider on timeout

​

websearch.providers.opencode

websearch:
  providers:
    opencode:
      enabled: false # Default: false
      model: "opencode/grok-code"
      timeout: 90

• Free provider via Zen platform
• Requires OpenCode CLI installed
• Fallback option after Gemini

• Set enabled: true
• Install: npm install -g opencode

​

websearch.providers.grok

websearch:
  providers:
    grok:
      enabled: false # Default: false
      timeout: 55

• Requires GROK_API_KEY environment variable
• Paid API, better quality than free providers
• Last fallback option

• Set enabled: true
• Set GROK_API_KEY env var
• Install: npm install -g @vibe-kit/grok-cli

​

Copilot Configuration (Deprecated)

​

copilot.account_type

copilot:
  enabled: false
  account_type: individual # Default: individual

• individual: Personal subscription
• business: Enterprise/team subscription
• enterprise: Enterprise subscription

• Billing/usage tracking
• Feature access control

​

copilot.rate_limit

copilot:
  rate_limit: null # Default: null (no limit)

• null: No rate limiting
• Integer: Seconds between requests

• Prevent API abuse
• Control costs for business accounts

​

copilot.wait_on_limit

copilot:
  rate_limit: 60
  wait_on_limit: true # Default: true

• true: Wait until rate limit window resets
• false: Fail with error immediately

​

Configuration Patterns

​

Priority Resolution

1. CLI Flags (highest priority)
2. Environment Variables
3. config.yaml
4. Defaults (lowest priority)

# All three set the same value
ccs codex --proxy-host proxy.example.com                 # CLI flag
CCS_PROXY_HOST=proxy.example.com ccs codex               # Env var
# config.yaml: cliproxy_server.remote.host: proxy.example.com

​

Variant Isolation Pattern

cliproxy:
  variants:
    codex-dev:
      provider: codex
      port: 8318
      auth:
        api_key: "dev-key"
        management_secret: "dev-secret"

    codex-prod:
      provider: codex
      port: 8319
      auth:
        api_key: "prod-key"
        management_secret: "prod-secret"

ccs codex-dev   # Port 8318, dev credentials
ccs codex-prod  # Port 8319, prod credentials

​

Remote Proxy with Fallback Pattern

cliproxy_server:
  remote:
    enabled: true
    host: "proxy.example.com"
    port: 8443
    protocol: "https"
    auth_token: "remote-token"
    timeout: 5000

  fallback:
    enabled: true
    auto_start: true

  local:
    port: 8317
    auto_start: true

1. Try remote proxy at https://proxy.example.com:8443
2. If unreachable after 5s, fall back to local proxy
3. Auto-start local proxy if not running
4. Use local proxy on port 8317

​

Thinking Configuration

​

thinking.mode

thinking:
  mode: auto # Default: auto

• auto: Apply tier-based defaults (opus→high, sonnet→medium, haiku→low)
• off: Disable thinking entirely
• manual: Use explicit override value

​

thinking.override

thinking:
  mode: manual
  override: "high" # Or numeric budget value

• Used when mode: manual
• Can be level name (e.g., “high”, “medium”, “low”) or numeric budget
• Applies to all providers unless overridden

​

thinking.tier_defaults

thinking:
  tier_defaults:
    opus: "high" # Default
    sonnet: "medium" # Default
    haiku: "low" # Default

• Maps Claude tier names to thinking level names
• Used when mode: auto
• Customizable per tier

​

thinking.provider_overrides

thinking:
  provider_overrides:
    gemini:
      opus: "high"
      sonnet: "medium"

• Overrides global tier defaults for specific providers
• Useful for provider-specific configurations

​

thinking.show_warnings

thinking:
  show_warnings: true # Default: true

• true: Show warning when budget values are adjusted
• false: Silent clamping

​

Official Channels Configuration

​

channels.selected

channels:
  selected: [] # Default: []

• Accepted values: telegram, discord, imessage
• all is accepted by the CLI helper, but config.yaml stores the explicit array
• CCS adds --channels with every selected ready official plugin at runtime
• Applies only to native Claude default and account sessions
• Ignored for API-key profiles, CLIProxy, Copilot, Cursor proxy, and Droid target flows
• iMessage is macOS-only
• Telegram and Discord use Claude channel env files for bot tokens

​

channels.unattended

channels:
  unattended: false # Default: false

• true: Adds --dangerously-skip-permissions only when at least one selected official channel is auto-enabled
• false: Leaves permission mode unchanged
• Explicit user permission flags override this default

​

Image Analysis Configuration

​

image_analysis.enabled

image_analysis:
  enabled: true # Default: true

• true: Expose the managed ImageAnalysis path when the runtime is healthy
• false: Disable image analysis

​

image_analysis.timeout

image_analysis:
  timeout: 60 # Default: 60

• Max time for single vision analysis request
• Prevents hanging on slow responses

​

image_analysis.provider_models

image_analysis:
  provider_models:
    agy: "gemini-2.5-flash"
    gemini: "gemini-2.5-flash"
    codex: "gpt-5.1-codex-mini"
    kiro: "kiro-claude-haiku-4-5"
    ghcp: "claude-haiku-4.5"
    claude: "claude-haiku-4-5-20251001"
    kimi: "kimi-k2.5"

• Maps provider names to vision model IDs
• Customizable per provider
• Defaults provided for all supported providers

​

image_analysis.fallback_backend

image_analysis:
  fallback_backend: gemini

​

image_analysis.profile_backends

image_analysis:
  profile_backends:
    glm: agy

​

Dashboard Authentication

​

dashboard_auth.enabled

dashboard_auth:
  enabled: false # Default: false

• false: Dashboard accessible without login (default)
• true: Requires username/password to access dashboard

​

dashboard_auth.username

dashboard_auth:
  username: "admin"

​

dashboard_auth.password_hash

dashboard_auth:
  password_hash: "$2b$10$..."

npx bcrypt-cli hash 'your-password'

​

dashboard_auth.session_timeout_hours

dashboard_auth:
  session_timeout_hours: 24 # Default: 24

​

Dashboard Auth Environment Variables

​

Continuity Configuration

​

continuity.inherit_from_account

continuity:
  inherit_from_account:
    glm: pro # GLM profile inherits from "pro" account
    albb: work # albb profile inherits from "work" account
    gemini-dev: dev # gemini-dev variant inherits from "dev" account

• Maps a non-account profile name to an account profile name
• When the mapped profile runs with target: claude, it uses the account’s CLAUDE_CONFIG_DIR
• Conversation history, project state, and sessions are shared with that account profile
• The inherited profile and source account now reuse the same underlying Claude config directory
• Only applies when target='claude' — has no effect on target: droid profiles
• Never applies to account profiles themselves

• Settings-based profiles (profiles.<name>)
• CLIProxy variant profiles (cliproxy.variants.<name>)
• Built-in API presets (glm, albb, etc.)

• Account profiles (type: account)
• Copilot profiles

# config.yaml
continuity:
  inherit_from_account:
    glm: pro # GLM reuses the "pro" account's Claude config dir

# Now running "ccs glm" will:
# 1. Load GLM's API endpoint and key
# 2. Set CLAUDE_CONFIG_DIR to the "pro" account's instance path
# 3. Access same project files/conversations as "ccs pro"

​

Migration from v12 to v13

• Added proxy section for local compatible-provider proxy ports and routing
• Added browser section for Claude Browser Attach and Codex Browser Tools
• New installs default browser lanes to disabled/manual

​

Migration from v8 to v9

• Added continuity section with inherit_from_account mapping
• Config version bumped from 8 to 9

• None (automatic migration with empty defaults)
• Optional: Configure continuity.inherit_from_account to share workspace context between profiles

​

Migration from v7 to v8

• Added thinking section for reasoning budget control
• Added image_analysis section for vision model configuration
• Updated config version from 7 to 8

• None (automatic migration with defaults)
• Optional: Customize thinking levels or vision models

​

Migration from v6 to v7

• Added quota_management section
• Added tier-based quota prioritization
• Added manual account controls (pause/force/tier-lock)

• None (automatic migration with defaults)
• Optional: Configure quota management preferences

​

Migration from v5 to v6

• Added cliproxy.auth.api_key (default: "ccs-internal-managed")
• Added cliproxy.auth.management_secret (default: "ccs")
• Added cliproxy.variants.<name>.auth for per-variant override
• Added cliproxy_server.remote.management_key for separate management auth

• None (automatic migration with defaults)
• Optional: Customize auth keys for enhanced security

​

Validation Rules

• version must be integer >= 1
• Ports must be 1-65535
• Boolean fields reject non-boolean values

• Variant names must not conflict with built-in providers
• Profile names cannot be reserved words
• Email addresses must be valid format
• Hostnames must be valid DNS/IP

• Run ccs doctor --fix for auto-repair
• Run ccs migrate for version upgrades
• Delete corrupt config and run ccs setup

​

Docker Deployment Configuration

​

docker.compose_file

docker:
  compose_file: "~/.ccs/docker/docker-compose.yml"

• Auto-written by ccs docker up
• Points to the bundled compose file in ~/.ccs/docker/
• Override only if using a custom compose setup

​

docker.host

docker:
  host: "user@myserver.com" # or null for local

• null: All ccs docker commands target localhost
• "user@host": All ccs docker commands default to remote target
• Overridden by --host CLI flag per-command

​

Full Docker Section Example

docker:
  compose_file: "~/.ccs/docker/docker-compose.yml"
  host: null # null = local, or "user@host" for remote default

​

Related Resources

• CLI Flags Reference
• CLI Commands Reference
• Error Codes
• Migration Guide