@kaitranntt/ccs 7.61.0-dev.1 → 7.61.1-dev.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kaitranntt/ccs",
-  "version": "7.61.0-dev.1",
+  "version": "7.61.1-dev.1",
   "description": "Claude Code Switch - Instant profile switching between Claude, GLM, Kimi, and more",
   "keywords": [
     "cli",
@@ -35,7 +35,6 @@
     "lib/",
     "scripts/",
     "config/",
-    "docker/",
     ".claude/",
     "VERSION",
     "README.md",

package/scripts/github/ccs-backlog-sync-lib.mjs

@@ -0,0 +1,379 @@
+const REQUIRED_PROJECT_FIELDS = ['Status', 'Priority', 'Follow-up', 'Next review'];
+const DEFAULT_REPO_FULL_NAME = 'kaitranntt/ccs';
+const DEFAULT_CLOSED_LOOKBACK_DAYS = 14;
+const PRIORITY_FOR = { bug: 'P1', default: 'P2', split: 'P3' };
+const FOLLOW_UP_FOR = {
+  ready: 'Ready',
+  repro: 'Needs repro',
+  upstream: 'Blocked upstream',
+  split: 'Needs split',
+  docs: 'Docs follow-up',
+};
+
+const PROJECT_QUERY = `query($owner: String!, $number: Int!, $itemCursor: String) {
+  user(login: $owner) {
+    projectV2(number: $number) {
+      id
+      fields(first: 50) { nodes { __typename ... on ProjectV2Field { id name } ... on ProjectV2SingleSelectField { id name options { id name } } } }
+      items(first: 100, after: $itemCursor) {
+        pageInfo { hasNextPage endCursor }
+        nodes { id content { __typename ... on Issue { number id repository { nameWithOwner } } } }
+      }
+    }
+  }
+}`;
+const ADD_ITEM_MUTATION = `mutation($projectId: ID!, $contentId: ID!) {
+  addProjectV2ItemById(input: {projectId: $projectId, contentId: $contentId}) { item { id } }
+}`;
+const SET_SINGLE_SELECT_MUTATION = `mutation($projectId: ID!, $itemId: ID!, $fieldId: ID!, $optionId: String!) {
+  updateProjectV2ItemFieldValue(input: {
+    projectId: $projectId, itemId: $itemId, fieldId: $fieldId, value: { singleSelectOptionId: $optionId }
+  }) { projectV2Item { id } }
+}`;
+const SET_DATE_MUTATION = `mutation($projectId: ID!, $itemId: ID!, $fieldId: ID!, $date: Date!) {
+  updateProjectV2ItemFieldValue(input: {
+    projectId: $projectId, itemId: $itemId, fieldId: $fieldId, value: { date: $date }
+  }) { projectV2Item { id } }
+}`;
+const CLEAR_FIELD_MUTATION = `mutation($projectId: ID!, $itemId: ID!, $fieldId: ID!) {
+  clearProjectV2ItemFieldValue(input: {projectId: $projectId, itemId: $itemId, fieldId: $fieldId}) { projectV2Item { id } }
+}`;
+
+export function isoDate(daysFromNow, now = new Date()) {
+  const date = new Date(now);
+  date.setUTCDate(date.getUTCDate() + daysFromNow);
+  return date.toISOString().slice(0, 10);
+}
+
+export function classify(labels, state, now = new Date()) {
+  const names = new Set(labels.map((label) => label.name));
+  const priority = names.has('bug')
+    ? PRIORITY_FOR.bug
+    : names.has('needs-split')
+      ? PRIORITY_FOR.split
+      : PRIORITY_FOR.default;
+  if (state === 'closed')
+    return { priority, followUp: FOLLOW_UP_FOR.ready, nextReview: null, status: 'Done' };
+  if (names.has('upstream-blocked'))
+    return {
+      priority,
+      followUp: FOLLOW_UP_FOR.upstream,
+      nextReview: isoDate(7, now),
+      status: 'Todo',
+    };
+  if (names.has('needs-repro'))
+    return {
+      priority,
+      followUp: FOLLOW_UP_FOR.repro,
+      nextReview: isoDate(14, now),
+      status: 'Todo',
+    };
+  if (names.has('needs-split'))
+    return {
+      priority,
+      followUp: FOLLOW_UP_FOR.split,
+      nextReview: isoDate(14, now),
+      status: 'Todo',
+    };
+  if (names.has('docs-gap'))
+    return { priority, followUp: FOLLOW_UP_FOR.docs, nextReview: isoDate(7, now), status: 'Todo' };
+  return { priority, followUp: FOLLOW_UP_FOR.ready, nextReview: null, status: 'Todo' };
+}
+
+export function parseRepoFullName(repoFullName = DEFAULT_REPO_FULL_NAME) {
+  const [repoOwner, repoName, extra] = String(repoFullName).split('/');
+  if (!repoOwner || !repoName || extra) {
+    throw new Error(`Invalid GITHUB_REPOSITORY value "${repoFullName}". Expected OWNER/REPO.`);
+  }
+  return { repoOwner, repoName, repoFullName: `${repoOwner}/${repoName}` };
+}
+
+export function parseNextLink(linkHeader) {
+  if (!linkHeader) return null;
+  for (const segment of linkHeader.split(',')) {
+    const match = segment.match(/<([^>]+)>\s*;\s*rel="([^"]+)"/);
+    if (match?.[2] === 'next') return match[1];
+  }
+  return null;
+}
+
+function getHeader(headers, name) {
+  if (typeof headers?.get === 'function') return headers.get(name);
+  return headers?.[name] || headers?.[name.toLowerCase()] || null;
+}
+
+function buildCutoffTimestamp(now, days) {
+  const cutoff = new Date(now);
+  cutoff.setUTCDate(cutoff.getUTCDate() - days);
+  return cutoff.toISOString();
+}
+
+function isRecentlyClosed(issue, now, days) {
+  if (issue.state !== 'closed' || !issue.closed_at) return false;
+  return Date.parse(issue.closed_at) >= Date.parse(buildCutoffTimestamp(now, days));
+}
+
+export function validateProjectFields(fields) {
+  const missing = REQUIRED_PROJECT_FIELDS.filter((name) => !fields.has(name));
+  if (missing.length > 0) {
+    throw new Error(
+      `Missing required project field${missing.length > 1 ? 's' : ''}: ${missing.map((name) => `"${name}"`).join(', ')}`
+    );
+  }
+  return {
+    statusField: fields.get('Status'),
+    priorityField: fields.get('Priority'),
+    followUpField: fields.get('Follow-up'),
+    nextReviewField: fields.get('Next review'),
+  };
+}
+
+export async function listGithubCollection(initialPath, githubRequest) {
+  const items = [];
+  let nextPath = initialPath;
+  while (nextPath) {
+    const { body, headers } = await githubRequest(nextPath);
+    if (!Array.isArray(body)) throw new Error(`Expected array response for ${nextPath}`);
+    items.push(...body);
+    nextPath = parseNextLink(getHeader(headers, 'link'));
+  }
+  return items;
+}
+
+export async function getProjectContext({ owner, projectNumber, repoFullName, graphqlRequest }) {
+  const fields = new Map();
+  const itemsByNumber = new Map();
+  let projectId = null;
+  let itemCursor = null;
+
+  do {
+    const data = await graphqlRequest(PROJECT_QUERY, { owner, number: projectNumber, itemCursor });
+    const project = data.user?.projectV2;
+    if (!project) throw new Error(`Project ${owner}/${projectNumber} not found`);
+    projectId = projectId || project.id;
+
+    if (fields.size === 0) {
+      for (const node of project.fields.nodes) {
+        if (!node?.name) continue;
+        fields.set(node.name, {
+          id: node.id,
+          options: new Map((node.options || []).map((opt) => [opt.name, opt.id])),
+        });
+      }
+    }
+
+    for (const node of project.items.nodes) {
+      if (
+        node?.content?.__typename === 'Issue' &&
+        node.content.repository.nameWithOwner === repoFullName
+      ) {
+        itemsByNumber.set(node.content.number, node.id);
+      }
+    }
+
+    itemCursor = project.items.pageInfo.hasNextPage ? project.items.pageInfo.endCursor : null;
+  } while (itemCursor);
+
+  return { projectId, itemsByNumber, ...validateProjectFields(fields) };
+}
+
+export async function listIssuesForSync({
+  repoOwner,
+  repoName,
+  githubRequest,
+  eventPath,
+  now = new Date(),
+  closedLookbackDays = DEFAULT_CLOSED_LOOKBACK_DAYS,
+}) {
+  if (eventPath) {
+    const event = JSON.parse(
+      await import('node:fs/promises').then((fs) => fs.readFile(eventPath, 'utf8'))
+    );
+    if (event.issue && !event.issue.pull_request) return [event.issue];
+  }
+
+  const openIssues = await listGithubCollection(
+    `/repos/${repoOwner}/${repoName}/issues?state=open&per_page=100`,
+    githubRequest
+  );
+  const recentlyClosedIssues = await listGithubCollection(
+    `/repos/${repoOwner}/${repoName}/issues?state=closed&per_page=100&since=${encodeURIComponent(buildCutoffTimestamp(now, closedLookbackDays))}`,
+    githubRequest
+  );
+
+  const byNumber = new Map();
+  for (const issue of openIssues) {
+    if (!issue.pull_request) byNumber.set(issue.number, issue);
+  }
+  for (const issue of recentlyClosedIssues) {
+    if (!issue.pull_request && isRecentlyClosed(issue, now, closedLookbackDays))
+      byNumber.set(issue.number, issue);
+  }
+  return [...byNumber.values()];
+}
+
+async function ensureProjectItem(projectId, itemsByNumber, issue, graphqlRequest) {
+  const existing = itemsByNumber.get(issue.number);
+  if (existing) return existing;
+  if (!issue.node_id) throw new Error(`Issue #${issue.number} is missing node_id`);
+  const data = await graphqlRequest(ADD_ITEM_MUTATION, { projectId, contentId: issue.node_id });
+  const itemId = data.addProjectV2ItemById.item.id;
+  itemsByNumber.set(issue.number, itemId);
+  return itemId;
+}
+
+async function setSingleSelect(projectId, itemId, field, optionName, graphqlRequest) {
+  const optionId = field.options.get(optionName);
+  if (!optionId) throw new Error(`Missing option "${optionName}" on field ${field.id}`);
+  await graphqlRequest(SET_SINGLE_SELECT_MUTATION, {
+    projectId,
+    itemId,
+    fieldId: field.id,
+    optionId,
+  });
+}
+
+async function setDate(projectId, itemId, fieldId, date, graphqlRequest) {
+  if (!date) {
+    await graphqlRequest(CLEAR_FIELD_MUTATION, { projectId, itemId, fieldId });
+    return;
+  }
+  await graphqlRequest(SET_DATE_MUTATION, { projectId, itemId, fieldId, date });
+}
+
+export async function syncIssues({
+  issues,
+  context,
+  graphqlRequest,
+  logger = console,
+  now = new Date(),
+}) {
+  const failures = [];
+  for (const issue of issues) {
+    try {
+      if (issue.state === 'closed' && !context.itemsByNumber.has(issue.number)) {
+        logger.log(
+          `skipped #${issue.number}: closed issue is not currently tracked in the project`
+        );
+        continue;
+      }
+      const itemId = await ensureProjectItem(
+        context.projectId,
+        context.itemsByNumber,
+        issue,
+        graphqlRequest
+      );
+      const plan = classify(issue.labels || [], issue.state, now);
+      await setSingleSelect(
+        context.projectId,
+        itemId,
+        context.statusField,
+        plan.status,
+        graphqlRequest
+      );
+      await setSingleSelect(
+        context.projectId,
+        itemId,
+        context.priorityField,
+        plan.priority,
+        graphqlRequest
+      );
+      await setSingleSelect(
+        context.projectId,
+        itemId,
+        context.followUpField,
+        plan.followUp,
+        graphqlRequest
+      );
+      await setDate(
+        context.projectId,
+        itemId,
+        context.nextReviewField.id,
+        plan.nextReview,
+        graphqlRequest
+      );
+      logger.log(
+        `synced #${issue.number}: ${plan.status} / ${plan.priority} / ${plan.followUp}${plan.nextReview ? ` / ${plan.nextReview}` : ''}`
+      );
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error);
+      failures.push(`#${issue.number} (${detail})`);
+      logger.error(`[X] Failed to sync #${issue.number}: ${detail}`);
+    }
+  }
+  if (failures.length > 0)
+    throw new Error(`Failed to sync ${failures.length} issue(s): ${failures.join(', ')}`);
+}
+
+function formatGraphqlError(errors) {
+  const raw = JSON.stringify(errors);
+  if (/resource not accessible|insufficient|forbidden|project/i.test(raw)) {
+    return `GitHub Project access failed. Ensure GH_TOKEN or GITHUB_TOKEN has project scope and access to the target project. Raw: ${raw}`;
+  }
+  return `GitHub GraphQL failed: ${raw}`;
+}
+
+function buildRuntimeConfig(env = process.env) {
+  const token = env.GH_TOKEN || env.GITHUB_TOKEN;
+  if (!token) throw new Error('Missing GH_TOKEN or GITHUB_TOKEN');
+  const projectNumber = Number(env.CCS_PROJECT_NUMBER || '3');
+  if (!Number.isInteger(projectNumber) || projectNumber <= 0)
+    throw new Error('CCS_PROJECT_NUMBER must be a positive integer');
+  return {
+    token,
+    owner: env.CCS_PROJECT_OWNER || 'kaitranntt',
+    projectNumber,
+    eventPath: env.GITHUB_EVENT_PATH,
+    closedLookbackDays: Number(
+      env.CCS_PROJECT_RECENTLY_CLOSED_DAYS || String(DEFAULT_CLOSED_LOOKBACK_DAYS)
+    ),
+    ...parseRepoFullName(env.GITHUB_REPOSITORY || DEFAULT_REPO_FULL_NAME),
+  };
+}
+
+export async function runSync({ env = process.env, logger = console, fetchImpl = fetch } = {}) {
+  const config = buildRuntimeConfig(env);
+  const githubRequest = async (path, init = {}) => {
+    const response = await fetchImpl(
+      path.startsWith('http') ? path : `https://api.github.com${path}`,
+      {
+        ...init,
+        headers: {
+          Accept: 'application/vnd.github+json',
+          Authorization: `Bearer ${config.token}`,
+          'X-GitHub-Api-Version': '2022-11-28',
+          ...(init.headers || {}),
+        },
+      }
+    );
+    const body = await response.json();
+    if (!response.ok) throw new Error(`GitHub REST ${response.status}: ${JSON.stringify(body)}`);
+    return { body, headers: response.headers };
+  };
+  const graphqlRequest = async (query, variables = {}) => {
+    const response = await fetchImpl('https://api.github.com/graphql', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${config.token}` },
+      body: JSON.stringify({ query, variables }),
+    });
+    const body = await response.json();
+    if (!response.ok || body.errors) throw new Error(formatGraphqlError(body.errors || body));
+    return body.data;
+  };
+
+  const issues = await listIssuesForSync({
+    repoOwner: config.repoOwner,
+    repoName: config.repoName,
+    githubRequest,
+    eventPath: config.eventPath,
+    now: new Date(),
+    closedLookbackDays: config.closedLookbackDays,
+  });
+  const context = await getProjectContext({
+    owner: config.owner,
+    projectNumber: config.projectNumber,
+    repoFullName: config.repoFullName,
+    graphqlRequest,
+  });
+  await syncIssues({ issues, context, graphqlRequest, logger, now: new Date() });
+}

package/scripts/github/ccs-backlog-sync.mjs

@@ -0,0 +1,6 @@
+import { runSync } from './ccs-backlog-sync-lib.mjs';
+
+runSync().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

package/docker/Dockerfile

@@ -1,85 +0,0 @@
-# syntax=docker/dockerfile:1
-
-# =============================================================================
-# Build stage: compile TypeScript and build UI
-# =============================================================================
-FROM node:20-bookworm-slim AS build
-
-SHELL ["/bin/bash", "-lc"]
-
-# Pin bun version for reproducible builds
-ARG BUN_VERSION=1.2.21
-ENV BUN_INSTALL=/usr/local/bun
-ENV PATH="$BUN_INSTALL/bin:$PATH"
-
-RUN apt-get update \
-  && apt-get install -y --no-install-recommends curl ca-certificates unzip \
-  && rm -rf /var/lib/apt/lists/*
-
-# Install specific bun version
-RUN curl -fsSL https://bun.sh/install | bash -s "bun-v${BUN_VERSION}"
-
-WORKDIR /app
-
-# Dependency install layer (avoid running install scripts inside the image build)
-COPY package.json bun.lock bunfig.toml ./
-COPY ui/package.json ui/bun.lock ./ui/
-
-RUN bun install --frozen-lockfile --ignore-scripts \
-  && (cd ui && bun install --frozen-lockfile --ignore-scripts)
-
-COPY . .
-
-RUN bun run build:all
-
-# Validate build artifacts exist
-RUN test -d dist && test -d lib && echo "[OK] Build artifacts validated"
-
-# =============================================================================
-# Runtime stage: minimal production image
-# =============================================================================
-FROM node:20-bookworm-slim AS runtime
-
-SHELL ["/bin/bash", "-lc"]
-
-# Pin bun version for reproducible builds
-ARG BUN_VERSION=1.2.21
-ENV BUN_INSTALL=/usr/local/bun
-ENV PATH="$BUN_INSTALL/bin:/home/node/.opencode/bin:$PATH"
-
-RUN apt-get update \
-  && apt-get install -y --no-install-recommends curl ca-certificates unzip \
-  && rm -rf /var/lib/apt/lists/*
-
-# Install specific bun version
-RUN curl -fsSL https://bun.sh/install | bash -s "bun-v${BUN_VERSION}"
-
-WORKDIR /app
-
-COPY package.json bun.lock ./
-RUN bun install --frozen-lockfile --production --ignore-scripts
-
-COPY docker/entrypoint.sh /usr/local/bin/ccs-entrypoint
-RUN chmod +x /usr/local/bin/ccs-entrypoint
-
-COPY --from=build /app/dist ./dist
-COPY --from=build /app/lib ./lib
-COPY --from=build /app/config ./config
-COPY --from=build /app/scripts ./scripts
-COPY --from=build /app/README.md ./README.md
-COPY --from=build /app/LICENSE ./LICENSE
-
-# Install AI CLI tools (using latest - pin versions in production if needed)
-# These are optional tools for docker exec usage
-RUN npm install -g @google/gemini-cli @vibe-kit/grok-cli @anthropic-ai/claude-code \
-  && npm install -g @kaitranntt/ccs --force \
-  && npm cache clean --force \
-  && su -s /bin/bash node -c 'curl -fsSL https://opencode.ai/install | bash -s -- --no-modify-path' \
-  && ln -sf /app/dist/ccs.js /usr/local/bin/ccs
-
-ENV CCS_PORT=3000
-EXPOSE 3000 8317
-
-ENTRYPOINT ["/usr/local/bin/ccs-entrypoint"]
-
-CMD ["bash", "-c", "node dist/ccs.js config --port ${CCS_PORT}"]

package/docker/Dockerfile.integrated

@@ -1,23 +0,0 @@
-FROM eceasy/cli-proxy-api:latest
-
-ARG CCS_NPM_VERSION=latest
-
-RUN apk add --no-cache \
-    curl \
-    jq \
-    nodejs \
-    npm \
-    supervisor
-
-RUN npm install -g @kaitranntt/ccs@${CCS_NPM_VERSION} \
-  && ln -sf /usr/local/lib/node_modules/@kaitranntt/ccs/dist/docker/docker-bootstrap.js /usr/local/bin/ccs-docker-bootstrap
-
-COPY supervisord.conf /etc/supervisord.conf
-COPY entrypoint-integrated.sh /entrypoint-integrated.sh
-
-RUN chmod +x /entrypoint-integrated.sh \
-  && mkdir -p /var/log/ccs
-
-EXPOSE 3000 8085 8317
-
-ENTRYPOINT ["/entrypoint-integrated.sh"]

package/docker/README.md

@@ -1,260 +0,0 @@
-<div align="center">
-
-# CCS Docker Deployment
-
-![CCS Logo](../assets/ccs-logo-medium.png)
-
-### Run CCS in Docker, locally or over SSH.
-Persistent config, restart on reboot.
-
-**[Back to README](../README.md)**
-
-</div>
-
-<br>
-
-## Preferred: `ccs docker`
-
-The CLI now ships a first-class Docker command suite for the integrated CCS + CLIProxy stack:
-
-```bash
-ccs docker up
-ccs docker status
-ccs docker logs --follow
-ccs docker config
-ccs docker update
-ccs docker down
-```
-
-Remote deployment stages the bundled Docker assets to `~/.ccs/docker` on the target host:
-
-```bash
-ccs docker up --host my-server
-ccs docker --host my-server status
-ccs docker status --host my-server
-ccs docker logs --host my-server --service ccs --follow
-ccs docker config --host my-server
-```
-
-Use a single SSH target or SSH config alias for `--host`. If you need custom SSH flags such as a port override, configure them in `~/.ssh/config` and reference the alias from `ccs docker`.
-
-The `ccs docker` flow uses the integrated assets in this directory:
-
-- `docker/Dockerfile.integrated`
-- `docker/docker-compose.integrated.yml`
-- `docker/supervisord.conf`
-- `docker/entrypoint-integrated.sh`
-
-## Prebuilt Image Quick Start
-
-This existing image still runs the CCS dashboard and its locally managed CLIProxy inside one
-container. It does not provide the remote staging and in-container self-update flow exposed by
-`ccs docker`.
-
-Pull the latest stable release image from GitHub Container Registry:
-
-```bash
-docker run -d \
-  --name ccs-dashboard \
-  --restart unless-stopped \
-  -p 3000:3000 \
-  -p 8317:8317 \
-  -e CCS_PORT=3000 \
-  -v ccs_home:/home/node/.ccs \
-  ghcr.io/kaitranntt/ccs-dashboard:latest
-```
-
-Release-tag images are also published as `ghcr.io/kaitranntt/ccs-dashboard:<version>`.
-
-## Prebuilt Image Build Locally
-
-```bash
-docker build -f docker/Dockerfile -t ccs-dashboard:latest .
-docker run -d \
-  --name ccs-dashboard \
-  --restart unless-stopped \
-  -p 3000:3000 \
-  -p 8317:8317 \
-  -e CCS_PORT=3000 \
-  -v ccs_home:/home/node/.ccs \
-  ccs-dashboard:latest
-```
-
-Open `http://localhost:3000` (Dashboard).
-
-CCS also starts CLIProxy on `http://localhost:8317` (used by Dashboard features and OAuth providers).
-
-## Environment Variables
-
-Common CCS environment variables (from the docs):
-
-- Docs: [Environment variables](https://docs.ccs.kaitran.ca/getting-started/configuration#environment-variables)
-
-- `CCS_CONFIG`: override config file path
-- `CCS_UNIFIED_CONFIG=1`: force unified YAML config loader
-- `CCS_MIGRATE=1`: trigger config migration
-- `CCS_SKIP_MIGRATION=1`: skip migrations
-- `CCS_DEBUG=1`: enable verbose logs
-- `NO_COLOR=1`: disable ANSI colors
-- `CCS_SKIP_PREFLIGHT=1`: skip API key validation checks
-- `CCS_WEBSEARCH_SKIP=1`: skip WebSearch hook integration
-- Proxy: `CCS_PROXY_HOST`, `CCS_PROXY_PORT`, `CCS_PROXY_PROTOCOL`, `CCS_PROXY_AUTH_TOKEN`, `CCS_PROXY_TIMEOUT`, `CCS_PROXY_FALLBACK_ENABLED`, `CCS_ALLOW_SELF_SIGNED`
-
-Example (passing env vars to the running container):
-
-```bash
-docker run -d \
-  --name ccs-dashboard \
-  --restart unless-stopped \
-  -p 3000:3000 \
-  -p 8317:8317 \
-  -e CCS_PORT=3000 \
-  -e CCS_DEBUG=1 \
-  -e NO_COLOR=1 \
-  -e CCS_PROXY_HOST="proxy.example.com" \
-  -e CCS_PROXY_PORT=443 \
-  -e CCS_PROXY_PROTOCOL="https" \
-  -v ccs_home:/home/node/.ccs \
-  ghcr.io/kaitranntt/ccs-dashboard:latest
-```
-
-## Useful Commands
-
-```bash
-docker logs -f ccs-dashboard
-docker stop ccs-dashboard
-docker start ccs-dashboard
-docker rm -f ccs-dashboard
-```
-
-## Prebuilt Image Docker Compose (Optional)
-
-Using the included `docker/docker-compose.yml`:
-
-```bash
-docker-compose -f docker/docker-compose.yml up --build -d
-docker-compose -f docker/docker-compose.yml logs -f
-```
-
-Stop:
-
-```bash
-docker-compose -f docker/docker-compose.yml down
-```
-
-For the integrated CCS + CLIProxy stack managed by the CLI, use `ccs docker up` instead.
-
-## Persistence
-
-- CCS stores data in `/home/node/.ccs` inside the container.
-- The examples use a named volume (`ccs_home`) to persist that data.
-- Compose also persists `/home/node/.claude`, `/home/node/.opencode`, and `/home/node/.grok-cli` via named volumes.
-
-## Resource Limits
-
-For production deployments, limit container resources:
-
-```bash
-docker run -d \
-  --name ccs-dashboard \
-  --restart unless-stopped \
-  --memory=1g \
-  --cpus=2 \
-  -p 3000:3000 \
-  -p 8317:8317 \
-  -v ccs_home:/home/node/.ccs \
-  ghcr.io/kaitranntt/ccs-dashboard:latest
-```
-
-Docker Compose includes default limits (1GB RAM, 2 CPUs). Adjust in `docker-compose.yml` under `deploy.resources`.
-
-## Graceful Shutdown
-
-CCS handles `SIGTERM` gracefully. When stopping the container:
-
-```bash
-docker stop ccs-dashboard        # Sends SIGTERM, waits 10s, then SIGKILL
-docker stop -t 30 ccs-dashboard  # Wait 30s for graceful shutdown
-```
-
-The `init: true` in docker-compose.yml ensures proper signal forwarding.
-
-## Troubleshooting
-
-### Permission Errors (EACCES)
-
-If you see permission errors on startup:
-
-```bash
-# Check volume permissions
-docker exec ccs-dashboard ls -la /home/node/.ccs
-
-# Fix by recreating volumes
-docker-compose down -v
-docker-compose up -d
-```
-
-### Port Already in Use
-
-```bash
-# Check what's using the port
-lsof -i :3000
-lsof -i :8317
-
-# Use different ports
-docker run -p 4000:3000 -p 9317:8317 ...
-
-# Or with compose
-CCS_DASHBOARD_PORT=4000 CCS_CLIPROXY_PORT=9317 docker-compose up -d
-```
-
-### Container Keeps Restarting
-
-```bash
-# Check logs for errors
-docker logs ccs-dashboard --tail 50
-
-# Check container health
-docker inspect ccs-dashboard --format='{{.State.Health.Status}}'
-```
-
-### Debug Mode
-
-Enable verbose logging:
-
-```bash
-docker run -e CCS_DEBUG=1 ...
-```
-
-## Examples: Claude + Gemini inside Docker
-
-Open a shell inside the running container:
-
-```bash
-docker exec -it ccs-dashboard bash
-```
-
-Claude (non-interactive / print mode):
-
-```bash
-docker exec -it ccs-dashboard claude -p "Hello from Docker"
-```
-
-Gemini (one-shot prompt):
-
-```bash
-docker exec -it ccs-dashboard gemini "Hello from Docker"
-```
-
-If you need to configure credentials, do it according to each CLI's docs:
-
-```bash
-docker exec -it ccs-dashboard claude --help
-docker exec -it ccs-dashboard gemini --help
-```
-
-## Security Notes
-
-- **Secrets**: For sensitive values like `CCS_PROXY_AUTH_TOKEN`, consider using Docker secrets or a `.env` file (not committed to git).
-- **Network**: The container exposes ports 3000 and 8317. In production, use a reverse proxy (nginx, traefik) with TLS.
-- **Updates**: Regularly rebuild the image to get security patches: `docker-compose build --pull`

package/docker/docker-compose.integrated.yml

@@ -1,32 +0,0 @@
-services:
-  ccs-cliproxy:
-    build:
-      context: .
-      dockerfile: Dockerfile.integrated
-      args:
-        CCS_NPM_VERSION: "${CCS_NPM_VERSION:-latest}"
-    image: ccs-cliproxy:latest
-    container_name: ccs-cliproxy
-    restart: unless-stopped
-    init: true
-    ports:
-      - "${CCS_DASHBOARD_PORT:-3000}:3000"
-      - "${CCS_CLIPROXY_PORT:-8317}:8317"
-    environment:
-      CCS_PORT: 3000
-      NODE_ENV: production
-      NO_COLOR: "${NO_COLOR:-}"
-      CCS_DEBUG: "${CCS_DEBUG:-}"
-    volumes:
-      - ccs_home:/root/.ccs
-      - ccs_logs:/var/log/ccs
-    healthcheck:
-      test: ["CMD-SHELL", "curl -fsS --max-time 2 http://localhost:3000/ >/dev/null && curl -fsS --max-time 2 http://127.0.0.1:8317/ >/dev/null"]
-      interval: 10s
-      timeout: 3s
-      retries: 12
-      start_period: 30s
-
-volumes:
-  ccs_home:
-  ccs_logs:

package/docker/docker-compose.yml

@@ -1,53 +0,0 @@
-# CCS Dashboard Docker Compose
-# See docker/README.md for documentation
-services:
-  ccs-dashboard:
-    image: ccs-dashboard:latest
-    build:
-      context: ..
-      dockerfile: docker/Dockerfile
-    restart: unless-stopped
-    init: true
-    ports:
-      - "${CCS_DASHBOARD_PORT:-3000}:3000"
-      - "${CCS_CLIPROXY_PORT:-8317}:8317"
-    environment:
-      CCS_PORT: 3000
-      CCS_DEBUG: "${CCS_DEBUG:-}"
-      NO_COLOR: "${NO_COLOR:-}"
-      CCS_SKIP_PREFLIGHT: "${CCS_SKIP_PREFLIGHT:-}"
-      CCS_WEBSEARCH_SKIP: "${CCS_WEBSEARCH_SKIP:-}"
-      CCS_PROXY_HOST: "${CCS_PROXY_HOST:-}"
-      CCS_PROXY_PORT: "${CCS_PROXY_PORT:-}"
-      CCS_PROXY_PROTOCOL: "${CCS_PROXY_PROTOCOL:-}"
-      CCS_PROXY_AUTH_TOKEN: "${CCS_PROXY_AUTH_TOKEN:-}"
-      CCS_PROXY_TIMEOUT: "${CCS_PROXY_TIMEOUT:-}"
-      CCS_PROXY_FALLBACK_ENABLED: "${CCS_PROXY_FALLBACK_ENABLED:-}"
-      CCS_ALLOW_SELF_SIGNED: "${CCS_ALLOW_SELF_SIGNED:-}"
-    volumes:
-      - ccs_home:/home/node/.ccs
-      - claude_home:/home/node/.claude
-      - opencode_home:/home/node/.opencode
-      - grok_home:/home/node/.grok-cli
-    # Healthcheck uses internal ports (3000/8317) which are fixed
-    healthcheck:
-      test: ["CMD-SHELL", "curl -fsS --max-time 2 http://localhost:3000/ >/dev/null && curl -sS --max-time 2 http://127.0.0.1:8317/ >/dev/null"]
-      interval: 10s
-      timeout: 3s
-      retries: 12
-      start_period: 30s
-    # Resource limits (adjust based on workload)
-    deploy:
-      resources:
-        limits:
-          memory: 1G
-          cpus: '2'
-        reservations:
-          memory: 256M
-          cpus: '0.5'
-
-volumes:
-  ccs_home:
-  claude_home:
-  opencode_home:
-  grok_home:

package/docker/entrypoint-integrated.sh

@@ -1,9 +0,0 @@
-#!/bin/sh
-set -eu
-
-LOG_DIR="/var/log/ccs"
-
-mkdir -p /root/.ccs /root/.ccs/cliproxy "$LOG_DIR"
-touch "$LOG_DIR/ccs-dashboard.log" "$LOG_DIR/cliproxy.log"
-
-exec /usr/bin/supervisord -c /etc/supervisord.conf

package/docker/entrypoint.sh

@@ -1,34 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-ccs_home_dir="${CCS_HOME_DIR:-/home/node/.ccs}"
-
-mkdir -p "$ccs_home_dir"
-
-# Fix volume permissions if running as root
-if [ "$(id -u)" = "0" ]; then
-  if ! chown -R node:node "$ccs_home_dir" 2>/dev/null; then
-    echo "[!] Warning: Could not change ownership of $ccs_home_dir (read-only volume?)" >&2
-  fi
-fi
-
-# Show usage if no command provided
-if [ "$#" -eq 0 ]; then
-  echo "[X] No command provided" >&2
-  echo "" >&2
-  echo "Usage: docker run ccs-dashboard <command>" >&2
-  echo "" >&2
-  echo "Examples:" >&2
-  echo "  docker run ccs-dashboard node dist/ccs.js config" >&2
-  echo "  docker run ccs-dashboard ccs --help" >&2
-  echo "" >&2
-  exit 1
-fi
-
-# Drop privileges from root to node user
-if [ "$(id -u)" = "0" ]; then
-  cmd="$(printf '%q ' "$@")"
-  exec su -s /bin/bash node -c "exec ${cmd}"
-fi
-
-exec "$@"

package/docker/supervisord.conf

@@ -1,43 +0,0 @@
-[unix_http_server]
-file=/var/run/supervisor.sock
-chmod=0700
-
-[supervisord]
-nodaemon=true
-user=root
-logfile=/var/log/supervisord.log
-pidfile=/var/run/supervisord.pid
-loglevel=info
-
-[rpcinterface:supervisor]
-supervisor.rpcinterface_factory=supervisor.rpcinterface:make_main_rpcinterface
-
-[supervisorctl]
-serverurl=unix:///var/run/supervisor.sock
-
-[program:cliproxy]
-command=node /usr/local/bin/ccs-docker-bootstrap run-cliproxy
-directory=/root
-autostart=true
-autorestart=true
-startsecs=5
-startretries=3
-stderr_logfile=/var/log/ccs/cliproxy.log
-stderr_logfile_maxbytes=0
-stdout_logfile=/var/log/ccs/cliproxy.log
-stdout_logfile_maxbytes=0
-priority=10
-
-[program:ccs-dashboard]
-command=ccs config --host 0.0.0.0 --port 3000
-directory=/root
-autostart=true
-autorestart=true
-startsecs=10
-startretries=3
-stderr_logfile=/var/log/ccs/ccs-dashboard.log
-stderr_logfile_maxbytes=0
-stdout_logfile=/var/log/ccs/ccs-dashboard.log
-stdout_logfile_maxbytes=0
-priority=20
-environment=HOME="/root",NODE_ENV="production"