@kaitranntt/ccs 7.79.1 → 8.0.0-dev.1

package/lib/hooks/websearch-transformer.cjs

@@ -874,7 +874,10 @@ function runGeminiCommand(args, timeoutMs) {
     timeout: timeoutMs,
     maxBuffer: 1024 * 1024 * 2,
     stdio: ['pipe', 'pipe', 'pipe'],
-    shell: isWindows,
+    // Never route query-derived prompts through a shell. Node concatenates
+    // arguments for shell-backed Windows spawns, which lets shell metacharacters
+    // in WebSearch queries escape the intended CLI invocation.
+    shell: false,
   });
 
   if (result.error) {
@@ -929,7 +932,10 @@ function tryOpenCodeSearch(query, timeoutSec = DEFAULT_TIMEOUT_SEC) {
         timeout: timeoutSec * 1000,
         maxBuffer: 1024 * 1024 * 2,
         stdio: ['pipe', 'pipe', 'pipe'],
-        shell: isWindows,
+        // Never route query-derived prompts through a shell. Node concatenates
+        // arguments for shell-backed Windows spawns, which lets shell metacharacters
+        // in WebSearch queries escape the intended CLI invocation.
+        shell: false,
       }
     );
 
@@ -965,7 +971,10 @@ function tryGrokSearch(query, timeoutSec = DEFAULT_TIMEOUT_SEC) {
       timeout: timeoutSec * 1000,
       maxBuffer: 1024 * 1024 * 2,
       stdio: ['pipe', 'pipe', 'pipe'],
-      shell: isWindows,
+      // Never route query-derived prompts through a shell. Node concatenates
+      // arguments for shell-backed Windows spawns, which lets shell metacharacters
+      // in WebSearch queries escape the intended CLI invocation.
+      shell: false,
     });
 
     if (result.error) {

package/lib/mcp/ccs-browser-server.cjs

@@ -83,6 +83,16 @@ const TOOL_HOVER = 'browser_hover';
 const TOOL_QUERY = 'browser_query';
 const TOOL_TAKE_ELEMENT_SCREENSHOT = 'browser_take_element_screenshot';
 const TOOL_WAIT_FOR_EVENT = 'browser_wait_for_event';
+const SENSITIVE_INTERCEPT_HEADER_NAMES = new Set([
+  'authorization',
+  'cookie',
+  'cookie2',
+  'proxy-authorization',
+  'x-api-key',
+  'x-api-token',
+  'x-auth-token',
+]);
+
 const TOOL_NAMES = [
   TOOL_SESSION_INFO,
   TOOL_URL_TITLE,
@@ -612,10 +622,15 @@ function getTools() {
           urlRegex: { type: 'string' },
           headerMatchers: {
             type: 'array',
+            description:
+              'Match non-sensitive request headers. Cookie, Authorization, and token headers are not allowed.',
             items: {
               type: 'object',
               properties: {
-                name: { type: 'string' },
+                name: {
+                  type: 'string',
+                  description: 'Non-sensitive request header name to match.',
+                },
                 valueIncludes: { type: 'string' },
                 valueRegex: { type: 'string' },
               },
@@ -624,7 +639,7 @@ function getTools() {
             },
           },
           priority: { type: 'integer' },
-          action: { type: 'string', enum: ['continue', 'fail', 'fulfill'] },
+          action: { type: 'string', enum: getInterceptActionEnum() },
           statusCode: { type: 'integer', minimum: 100, maximum: 599 },
           responseHeaders: {
             type: 'array',
@@ -1194,7 +1209,18 @@ function getTools() {
           },
           event: {
             type: 'object',
-            description: 'Required event selector.',
+            description:
+              'Required event selector. request events require urlIncludes; download events require urlIncludes or suggestedFilenameIncludes. URLs in returned details are redacted.',
+            properties: {
+              kind: { type: 'string', enum: ['dialog', 'navigation', 'request', 'download'] },
+              dialogType: { type: 'string' },
+              messageIncludes: { type: 'string' },
+              urlIncludes: { type: 'string' },
+              method: { type: 'string' },
+              suggestedFilenameIncludes: { type: 'string' },
+            },
+            required: ['kind'],
+            additionalProperties: false,
           },
         },
         required: ['event'],
@@ -1277,9 +1303,30 @@ function parseOptionalPageId(toolArgs) {
     : '';
 }
 
+function getBrowserInterceptFulfillMode() {
+  return String(process.env.CCS_BROWSER_INTERCEPT_FULFILL_MODE || 'disabled').trim() === 'enabled'
+    ? 'enabled'
+    : 'disabled';
+}
+
+function isBrowserInterceptFulfillEnabled() {
+  return getBrowserInterceptFulfillMode() === 'enabled';
+}
+
+function getInterceptActionEnum() {
+  return isBrowserInterceptFulfillEnabled()
+    ? ['continue', 'fail', 'fulfill']
+    : ['continue', 'fail'];
+}
+
 function parseInterceptAction(value) {
+  if (value === 'fulfill' && !isBrowserInterceptFulfillEnabled()) {
+    throw new Error(
+      'action fulfill is disabled by CCS_BROWSER_INTERCEPT_FULFILL_MODE=disabled; set it to enabled only for trusted local testing'
+    );
+  }
   if (value !== 'continue' && value !== 'fail' && value !== 'fulfill') {
-    throw new Error('action must be one of: continue, fail, fulfill');
+    throw new Error(`action must be one of: ${getInterceptActionEnum().join(', ')}`);
   }
   return value;
 }
@@ -1379,6 +1426,10 @@ function parseOptionalPriority(value) {
   return value;
 }
 
+function isSensitiveInterceptHeaderName(name) {
+  return SENSITIVE_INTERCEPT_HEADER_NAMES.has(name.toLowerCase());
+}
+
 function parseOptionalHeaderMatchers(value) {
   if (value === undefined) {
     return [];
@@ -1391,6 +1442,9 @@ function parseOptionalHeaderMatchers(value) {
       throw new Error('headerMatchers entries must be objects');
     }
     const name = requireNonEmptyString(entry.name, 'headerMatchers.name');
+    if (isSensitiveInterceptHeaderName(name)) {
+      throw new Error(`headerMatchers.name cannot target sensitive request header: ${name}`);
+    }
     const valueIncludes =
       entry.valueIncludes === undefined
         ? ''
@@ -3305,24 +3359,80 @@ function parseEventCondition(value) {
     };
   }
   if (value.kind === 'request') {
+    const urlIncludes = value.urlIncludes ? String(value.urlIncludes) : undefined;
+    if (!urlIncludes) {
+      throw new Error('request events require urlIncludes to limit network metadata exposure');
+    }
     return {
       kind: 'request',
-      urlIncludes: value.urlIncludes ? String(value.urlIncludes) : undefined,
+      urlIncludes,
       method: value.method ? String(value.method) : undefined,
     };
   }
   if (value.kind === 'download') {
+    const urlIncludes = value.urlIncludes ? String(value.urlIncludes) : undefined;
+    const suggestedFilenameIncludes = value.suggestedFilenameIncludes
+      ? String(value.suggestedFilenameIncludes)
+      : undefined;
+    if (!urlIncludes && !suggestedFilenameIncludes) {
+      throw new Error(
+        'download events require urlIncludes or suggestedFilenameIncludes to limit metadata exposure'
+      );
+    }
     return {
       kind: 'download',
-      urlIncludes: value.urlIncludes ? String(value.urlIncludes) : undefined,
-      suggestedFilenameIncludes: value.suggestedFilenameIncludes
-        ? String(value.suggestedFilenameIncludes)
-        : undefined,
+      urlIncludes,
+      suggestedFilenameIncludes,
     };
   }
   throw new Error(`unknown event kind: ${String(value.kind || '')}`);
 }
 
+function redactUrlForModel(value, options = {}) {
+  const rawUrl = String(value || '');
+  if (!rawUrl) {
+    return '';
+  }
+  try {
+    const url = new URL(rawUrl);
+    if (options.originOnly) {
+      return url.origin;
+    }
+    url.username = '';
+    url.password = '';
+    url.search = '';
+    url.hash = '';
+    return url.toString();
+  } catch {
+    return '[redacted-url]';
+  }
+}
+
+function redactObservedEvent(event, observed) {
+  if (!observed || typeof observed !== 'object') {
+    return observed;
+  }
+  if (event.kind === 'request') {
+    return {
+      url: redactUrlForModel(observed.url, { originOnly: true }),
+      method: observed.method || '',
+    };
+  }
+  if (event.kind === 'download') {
+    return {
+      url: redactUrlForModel(observed.url, { originOnly: true }),
+      suggestedFilename: observed.suggestedFilename || '',
+    };
+  }
+  if (event.kind === 'navigation' && Object.prototype.hasOwnProperty.call(observed, 'url')) {
+    return {
+      ...observed,
+      url: redactUrlForModel(observed.url, { originOnly: true }),
+    };
+  }
+  return observed;
+}
+
 function matchesObservedEvent(event, observed) {
   if (event.kind === 'dialog') {
     return (
@@ -4776,7 +4886,8 @@ async function handleWaitForEvent(toolArgs) {
   );
   const event = parseEventCondition(toolArgs.event);
   const observed = await waitForMatchingEvent({ page, pageIndex, timeoutMs, event });
-  return `pageIndex: ${pageIndex}\nevent: ${event.kind}\nstatus: observed\ndetail: ${JSON.stringify(observed)}`;
+  const safeObserved = redactObservedEvent(event, observed);
+  return `pageIndex: ${pageIndex}\nevent: ${event.kind}\nstatus: observed\ndetail: ${JSON.stringify(safeObserved)}`;
 }
 
 function findInterceptRuleIndex(ruleId) {
@@ -5381,7 +5492,10 @@ function buildRecordingInstallExpression(recordingPayload) {
     const recordingPayload = JSON.parse(${JSON.stringify(JSON.stringify(recordingPayload))});
     const existing = globalThis.__CCS_BROWSER_RECORDING_RECORDER__;
     if (existing && existing.installed === true) {
-      return { installed: true };
+      if (typeof existing.teardown === 'function') {
+        existing.teardown();
+      }
+      delete globalThis.__CCS_BROWSER_RECORDING_RECORDER__;
     }
 
     const events = Array.isArray(recordingPayload.events) ? [...recordingPayload.events] : [];
@@ -5413,8 +5527,42 @@ function buildRecordingInstallExpression(recordingPayload) {
         timestamp: Date.now(),
       });
     };
+    const sensitiveInputTypes = new Set(['password', 'hidden']);
+    const sensitiveAttributePattern = /(?:pass(?:word|code|phrase)?|pwd|secret|token|api[-_ ]?key|access[-_ ]?key|private[-_ ]?key|credential|otp|one[-_ ]?time[-_ ]?(?:code|password)|verif(?:ication)?[-_ ]?code|security[-_ ]?code|pin|auth(?:orization)?[-_ ]?(?:code|token)|mfa|2fa)/i;
+    const sensitiveAutocompleteValues = new Set([
+      'current-password',
+      'new-password',
+      'one-time-code',
+      'cc-number',
+      'cc-csc',
+    ]);
+    const isSensitiveTextTarget = (target) => {
+      if (!target || !(target instanceof Element)) {
+        return false;
+      }
+      if (target instanceof HTMLInputElement) {
+        const inputType = String(target.type || '').toLowerCase();
+        if (sensitiveInputTypes.has(inputType)) {
+          return true;
+        }
+      }
+      const autocompleteTokens = String(target.getAttribute('autocomplete') || '')
+        .toLowerCase()
+        .split(/\s+/)
+        .filter(Boolean);
+      if (autocompleteTokens.some((token) => sensitiveAutocompleteValues.has(token))) {
+        return true;
+      }
+      const attributesToInspect = ['id', 'name', 'placeholder', 'aria-label', 'data-testid'];
+      return attributesToInspect.some((attributeName) =>
+        sensitiveAttributePattern.test(String(target.getAttribute(attributeName) || ''))
+      );
+    };
     const onInput = (event) => {
       const target = event.target;
+      if (isSensitiveTextTarget(target)) {
+        return;
+      }
       let text = '';
       if (target instanceof HTMLInputElement || target instanceof HTMLTextAreaElement) {
         text = target.value;
@@ -5425,7 +5573,19 @@ function buildRecordingInstallExpression(recordingPayload) {
       }
       pushEvent({ kind: 'type', selector: getSelector(target), text, timestamp: Date.now() });
     };
+    const isRecordableKey = (event) => {
+      if (isSensitiveTextTarget(event.target)) {
+        return false;
+      }
+      if (typeof event.key !== 'string' || event.key.length !== 1) {
+        return true;
+      }
+      return event.altKey === true || event.ctrlKey === true || event.metaKey === true;
+    };
     const onKeyDown = (event) => {
+      if (!isRecordableKey(event)) {
+        return;
+      }
       const modifiers = [];
       if (event.altKey) modifiers.push('Alt');
       if (event.ctrlKey) modifiers.push('Control');
@@ -5493,7 +5653,19 @@ async function finalizeRecordingCapture(session) {
   };
 
   const response = await sendCdpCommand(page, 'Runtime.evaluate', {
-    expression: `(() => globalThis.__CCS_BROWSER_RECORDING_RECORDER__ || { events: [], warnings: [] })()`,
+    expression: `(() => {
+      const recorder = globalThis.__CCS_BROWSER_RECORDING_RECORDER__;
+      if (!recorder) {
+        return { events: [], warnings: [] };
+      }
+      const events = Array.isArray(recorder.events) ? [...recorder.events] : [];
+      const warnings = Array.isArray(recorder.warnings) ? [...recorder.warnings] : [];
+      if (typeof recorder.teardown === 'function') {
+        recorder.teardown();
+      }
+      delete globalThis.__CCS_BROWSER_RECORDING_RECORDER__;
+      return { events, warnings };
+    })()`,
     returnByValue: true,
     awaitPromise: true,
   });
@@ -5513,6 +5685,28 @@ async function finalizeRecordingCapture(session) {
   session.warnings = warnings.map((warning) => String(warning.message || warning));
 }
 
+async function teardownRecordingCapture(session) {
+  if (!session || !session.pageWebSocketDebuggerUrl) {
+    return;
+  }
+  const page = {
+    id: session.pageId,
+    webSocketDebuggerUrl: session.pageWebSocketDebuggerUrl,
+  };
+  await sendCdpCommand(page, 'Runtime.evaluate', {
+    expression: `(() => {
+      const recorder = globalThis.__CCS_BROWSER_RECORDING_RECORDER__;
+      if (recorder && typeof recorder.teardown === 'function') {
+        recorder.teardown();
+      }
+      delete globalThis.__CCS_BROWSER_RECORDING_RECORDER__;
+      return { installed: false };
+    })()`,
+    returnByValue: true,
+    awaitPromise: true,
+  });
+}
+
 async function handleStartRecording(toolArgs) {
   if (activeRecordingSession) {
     throw new Error('recording already active');
@@ -5563,6 +5757,11 @@ async function handleStopRecording() {
   } catch (error) {
     finalizeError = error instanceof Error ? error : new Error(String(error));
     session.warnings.push(`recording capture finalization failed: ${finalizeError.message}`);
+    try {
+      await teardownRecordingCapture(session);
+    } catch {
+      // Preserve the original finalization failure for the caller.
+    }
   }
   session.status = 'stopped';
   session.stoppedAt = new Date().toISOString();
@@ -5583,6 +5782,12 @@ async function handleClearRecording() {
   if (!latestRecordingSession && !activeRecordingSession) {
     throw new Error('no recording available');
   }
+  const session = activeRecordingSession || latestRecordingSession;
+  try {
+    await teardownRecordingCapture(session);
+  } catch {
+    // Clearing session-local recording state should still succeed if the page is already gone.
+  }
   activeRecordingSession = null;
   latestRecordingSession = null;
   return 'status: cleared';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kaitranntt/ccs",
-  "version": "7.79.1",
+  "version": "8.0.0-dev.1",
   "description": "Claude Code Switch - Instant profile switching between Claude, GLM, Kimi, and more",
   "keywords": [
     "cli",

package/scripts/docker-dashboard-sunset-guard.js

@@ -0,0 +1,171 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('node:fs');
+const { execFileSync } = require('node:child_process');
+
+function parseStableVersion(value) {
+  const match = String(value || '').match(/^v?([0-9]+)\.([0-9]+)\.([0-9]+)$/);
+  if (!match) {
+    return null;
+  }
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+    raw: `v${Number(match[1])}.${Number(match[2])}.${Number(match[3])}`,
+  };
+}
+
+function compareVersions(left, right) {
+  for (const key of ['major', 'minor', 'patch']) {
+    if (left[key] !== right[key]) {
+      return left[key] - right[key];
+    }
+  }
+  return 0;
+}
+
+function stableVersionKey(version) {
+  return `${version.major}.${version.minor}.${version.patch}`;
+}
+
+function parseArgs(argv) {
+  const args = {};
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (!arg.startsWith('--')) {
+      throw new Error(`Unexpected argument: ${arg}`);
+    }
+    const key = arg.slice(2);
+    if (key === 'tags-stdin') {
+      args.tagsStdin = true;
+      continue;
+    }
+    const value = argv[i + 1];
+    if (!value || value.startsWith('--')) {
+      throw new Error(`Missing value for --${key}`);
+    }
+    args[key] = value;
+    i += 1;
+  }
+  return args;
+}
+
+function readStableTagsFromGit() {
+  const output = execFileSync('git', ['tag', '--list', 'v*'], {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+  return output.split(/\r?\n/).filter(Boolean);
+}
+
+function parseStableTags(tags) {
+  const byKey = new Map();
+  for (const tag of tags) {
+    const version = parseStableVersion(tag.trim());
+    if (version) {
+      byKey.set(stableVersionKey(version), version);
+    }
+  }
+  return Array.from(byKey.values()).sort(compareVersions);
+}
+
+function evaluateDashboardSunset({ targetTag, baselineVersion, releaseWindow, stableTags }) {
+  const target = parseStableVersion(targetTag);
+  if (!target) {
+    throw new Error(`Target tag must be stable semver like v1.2.3, got: ${targetTag}`);
+  }
+
+  const baseline = parseStableVersion(baselineVersion);
+  if (!baseline) {
+    throw new Error(`DEPRECATION_BASELINE_VERSION must be stable semver, got: ${baselineVersion}`);
+  }
+
+  if (!Number.isInteger(releaseWindow) || releaseWindow < 1) {
+    throw new Error(`STABLE_RELEASE_WINDOW must be a positive integer, got: ${releaseWindow}`);
+  }
+
+  if (compareVersions(target, baseline) < 0) {
+    return {
+      publish: true,
+      elapsed: 0,
+      reason: `${target.raw} is before dashboard deprecation baseline ${baseline.raw}`,
+    };
+  }
+
+  const versions = parseStableTags(stableTags);
+  const hasBaseline = versions.some((version) => compareVersions(version, baseline) === 0);
+  if (compareVersions(target, baseline) > 0 && !hasBaseline) {
+    throw new Error(
+      `Cannot count dashboard sunset releases: baseline tag ${baseline.raw} is missing from git tags`,
+    );
+  }
+
+  if (!versions.some((version) => compareVersions(version, target) === 0)) {
+    versions.push(target);
+    versions.sort(compareVersions);
+  }
+
+  const elapsed = versions.filter(
+    (version) => compareVersions(version, baseline) > 0 && compareVersions(version, target) <= 0,
+  ).length;
+  const publish = elapsed < releaseWindow;
+  const reason = publish
+    ? `legacy dashboard publish is still inside sunset window (${elapsed}/${releaseWindow} stable releases elapsed since ${baseline.raw})`
+    : `legacy dashboard sunset reached (${elapsed}/${releaseWindow} stable releases elapsed since ${baseline.raw})`;
+
+  return { publish, elapsed, reason };
+}
+
+function appendGithubOutput(values) {
+  if (!process.env.GITHUB_OUTPUT) {
+    return;
+  }
+  const lines = Object.entries(values).map(([key, value]) => `${key}=${String(value)}`);
+  fs.appendFileSync(process.env.GITHUB_OUTPUT, `${lines.join('\n')}\n`);
+}
+
+function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const targetTag = args.target || process.env.TARGET_TAG;
+  const baselineVersion = args.baseline || process.env.DEPRECATION_BASELINE_VERSION;
+  const windowValue = args.window || process.env.STABLE_RELEASE_WINDOW || '2';
+  const releaseWindow = Number(windowValue);
+  const stableTags = args.tagsStdin
+    ? fs.readFileSync(0, 'utf8').split(/\r?\n/).filter(Boolean)
+    : readStableTagsFromGit();
+
+  const result = evaluateDashboardSunset({
+    targetTag,
+    baselineVersion,
+    releaseWindow,
+    stableTags,
+  });
+
+  appendGithubOutput({
+    publish: result.publish ? 'true' : 'false',
+    elapsed: result.elapsed,
+    reason: result.reason,
+  });
+
+  const status = result.publish ? '[OK]' : '[i]';
+  console.log(`${status} ${result.reason}`);
+  if (!result.publish) {
+    console.log('[i] Skipping ghcr.io/kaitranntt/ccs-dashboard publish; use ghcr.io/kaitranntt/ccs.');
+  }
+}
+
+if (require.main === module) {
+  try {
+    main();
+  } catch (error) {
+    console.error(`[X] ${error.message}`);
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  evaluateDashboardSunset,
+  parseStableVersion,
+};

package/scripts/run-test-bucket.js

@@ -22,6 +22,7 @@ const slowTests = [
   'tests/integration/cursor-daemon-lifecycle.test.ts',
   'tests/integration/logging-request-context.test.ts',
   'tests/integration/proxy/daemon-lifecycle.test.ts',
+  'tests/integration/web-server/codex-profiles-endpoint.test.ts',
   'tests/unit/commands/persist-command-handler.test.ts',
   'tests/unit/hooks/browser-mcp-advanced-interactions.test.ts',
   'tests/unit/hooks/browser-mcp-downloads-and-files.test.ts',

package/scripts/verify-bundle.js

@@ -16,7 +16,10 @@ const path = require('path');
 const zlib = require('zlib');
 
 const UI_DIR = path.join(__dirname, '../dist/ui');
-const MAX_SIZE = 1.5 * 1024 * 1024; // 1.5MB - reasonable for full-featured React dashboard
+// 1.75MB - bumped from 1.5MB when the code editor moved from
+// react-simple-code-editor + prism-react-renderer (~18KB) to CodeMirror 6
+// (~80KB gzipped) to restore native selection/copy in the raw config viewers.
+const MAX_SIZE = 1.75 * 1024 * 1024;
 
 function getGzipSize(filePath) {
   const content = fs.readFileSync(filePath);