@georgedong32/ccs 7.66.0

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

@@ -0,0 +1,339 @@
+#!/usr/bin/env node
+
+const {
+  getActiveProviderIds,
+  getQueryFingerprint,
+  getSkipReason,
+  hasAnyActiveProviders,
+  runLocalWebSearch,
+  shouldSkipHook,
+  traceWebSearchEvent,
+} = require('../hooks/websearch-transformer.cjs');
+
+const PROTOCOL_VERSION = '2024-11-05';
+const SERVER_NAME = 'ccs-websearch';
+const SERVER_VERSION = '1.0.0';
+const TOOL_NAME = 'WebSearch';
+const TOOL_ALIASES = ['search'];
+const TOOL_DESCRIPTION =
+  'Third-party WebSearch replacement for CCS-managed Claude launches. Use this instead of Bash/curl/http fetches for web lookups. Provider order: Exa, Tavily, Brave Search, DuckDuckGo, then optional legacy CLI fallback.';
+
+function isSupportedToolName(name) {
+  return name === TOOL_NAME || TOOL_ALIASES.includes(name);
+}
+
+let inputBuffer = Buffer.alloc(0);
+const sessionState = {
+  initializeCount: 0,
+  toolsListCount: 0,
+  exposed: false,
+  toolCalls: 0,
+};
+let sessionSummaryWritten = false;
+
+function shouldExposeTools() {
+  return !shouldSkipHook() && hasAnyActiveProviders();
+}
+
+function getTools() {
+  if (!shouldExposeTools()) {
+    return [];
+  }
+
+  return [
+    {
+      name: TOOL_NAME,
+      description: TOOL_DESCRIPTION,
+      inputSchema: {
+        type: 'object',
+        properties: {
+          query: {
+            type: 'string',
+            description:
+              'Web query to resolve through CCS providers. Prefer this tool over ad hoc Bash/curl lookups when you need current web information.',
+          },
+        },
+        required: ['query'],
+        additionalProperties: false,
+      },
+    },
+  ];
+}
+
+function writeMessage(message) {
+  process.stdout.write(`${JSON.stringify(message)}\n`);
+}
+
+function writeResponse(id, result) {
+  writeMessage({
+    jsonrpc: '2.0',
+    id,
+    result,
+  });
+}
+
+function writeError(id, code, message) {
+  writeMessage({
+    jsonrpc: '2.0',
+    id,
+    error: {
+      code,
+      message,
+    },
+  });
+}
+
+async function handleToolCall(message) {
+  const id = message.id;
+  const params = message.params || {};
+  const toolArgs = params.arguments || {};
+  const toolName = params.name || '<missing>';
+  const query = typeof toolArgs.query === 'string' ? toolArgs.query.trim() : '';
+  const fingerprint = getQueryFingerprint(query);
+
+  if (!isSupportedToolName(toolName)) {
+    traceWebSearchEvent('mcp_tool_call_rejected', {
+      source: 'mcp',
+      reason: 'unknown_tool',
+      toolName,
+    });
+    writeError(id, -32602, `Unknown tool: ${toolName}`);
+    return;
+  }
+
+  sessionState.toolCalls += 1;
+  traceWebSearchEvent('mcp_tool_call_received', {
+    source: 'mcp',
+    toolName,
+    ...fingerprint,
+  });
+
+  if (!shouldExposeTools()) {
+    traceWebSearchEvent('mcp_tool_call_unavailable', {
+      source: 'mcp',
+      toolName,
+      exposed: false,
+      skipReason: getSkipReason(),
+      activeProviderIds: getActiveProviderIds(),
+      ...fingerprint,
+    });
+    writeResponse(id, {
+      content: [
+        {
+          type: 'text',
+          text: 'CCS WebSearch is unavailable for this profile or no providers are ready.',
+        },
+      ],
+      isError: true,
+    });
+    return;
+  }
+
+  if (!query) {
+    traceWebSearchEvent('mcp_tool_call_rejected', {
+      source: 'mcp',
+      reason: 'empty_query',
+      toolName,
+    });
+    writeError(id, -32602, `Tool "${TOOL_NAME}" requires a non-empty string query.`);
+    return;
+  }
+
+  const result = await runLocalWebSearch(query);
+  if (result.success) {
+    traceWebSearchEvent('mcp_tool_call_result', {
+      source: 'mcp',
+      toolName,
+      success: true,
+      providerId: result.providerId,
+      providerName: result.providerName,
+      ...fingerprint,
+    });
+    writeResponse(id, {
+      content: [{ type: 'text', text: result.content }],
+    });
+    return;
+  }
+
+  traceWebSearchEvent('mcp_tool_call_result', {
+    source: 'mcp',
+    toolName,
+    success: false,
+    noActiveProviders: Boolean(result.noActiveProviders),
+    errorCount: result.errors.length,
+    ...fingerprint,
+  });
+
+  const errorDetail =
+    result.noActiveProviders || result.errors.length === 0
+      ? 'No active WebSearch providers are ready.'
+      : result.errors.map((entry) => `${entry.provider}: ${entry.error}`).join(' | ');
+
+  writeResponse(id, {
+    content: [
+      {
+        type: 'text',
+        text: `CCS local WebSearch failed for "${query}". ${errorDetail}`,
+      },
+    ],
+    isError: true,
+  });
+}
+
+async function handleMessage(message) {
+  if (!message || message.jsonrpc !== '2.0' || typeof message.method !== 'string') {
+    return;
+  }
+
+  switch (message.method) {
+    case 'initialize':
+      sessionState.initializeCount += 1;
+      sessionState.exposed = sessionState.exposed || shouldExposeTools();
+      traceWebSearchEvent('mcp_initialize', {
+        source: 'mcp',
+        exposed: shouldExposeTools(),
+        skipReason: getSkipReason(),
+        activeProviderIds: getActiveProviderIds(),
+      });
+      writeResponse(message.id, {
+        protocolVersion: PROTOCOL_VERSION,
+        capabilities: {
+          tools: {},
+        },
+        serverInfo: {
+          name: SERVER_NAME,
+          version: SERVER_VERSION,
+        },
+      });
+      return;
+    case 'notifications/initialized':
+      return;
+    case 'ping':
+      writeResponse(message.id, {});
+      return;
+    case 'tools/list':
+      sessionState.toolsListCount += 1;
+      {
+        const tools = getTools();
+        const exposed = tools.length > 0;
+        sessionState.exposed = sessionState.exposed || exposed;
+        traceWebSearchEvent('mcp_tools_list', {
+          source: 'mcp',
+          exposed,
+          toolNames: tools.map((tool) => tool.name),
+          activeProviderIds: getActiveProviderIds(),
+          skipReason: getSkipReason(),
+        });
+        writeResponse(message.id, { tools });
+      }
+      return;
+    case 'tools/call':
+      await handleToolCall(message);
+      return;
+    default:
+      if (message.id !== undefined) {
+        writeError(message.id, -32601, `Method not found: ${message.method}`);
+      }
+  }
+}
+
+function writeSessionSummary(exitCodeOrSignal) {
+  if (sessionSummaryWritten) {
+    return;
+  }
+
+  sessionSummaryWritten = true;
+  traceWebSearchEvent('mcp_session_summary', {
+    source: 'mcp',
+    initializeCount: sessionState.initializeCount,
+    toolsListCount: sessionState.toolsListCount,
+    exposed: sessionState.exposed,
+    toolCalls: sessionState.toolCalls,
+    calledWebSearch: sessionState.toolCalls > 0,
+    likelyBypassed: sessionState.exposed && sessionState.toolCalls === 0 ? 'unknown' : false,
+    activeProviderIds: getActiveProviderIds(),
+    skipReason: getSkipReason(),
+    exitCode: typeof exitCodeOrSignal === 'number' ? exitCodeOrSignal : null,
+    exitSignal: typeof exitCodeOrSignal === 'string' ? exitCodeOrSignal : null,
+  });
+}
+
+function parseMessages() {
+  while (true) {
+    let body;
+    const startsWithLegacyHeaders = inputBuffer
+      .slice(0, Math.min(inputBuffer.length, 32))
+      .toString('utf8')
+      .toLowerCase()
+      .startsWith('content-length:');
+
+    if (startsWithLegacyHeaders) {
+      const headerEnd = inputBuffer.indexOf('\r\n\r\n');
+      if (headerEnd === -1) {
+        return;
+      }
+
+      const headerText = inputBuffer.slice(0, headerEnd).toString('utf8');
+      const contentLengthMatch = headerText.match(/content-length:\s*(\d+)/i);
+      if (!contentLengthMatch) {
+        inputBuffer = Buffer.alloc(0);
+        return;
+      }
+
+      const contentLength = Number.parseInt(contentLengthMatch[1], 10);
+      const messageEnd = headerEnd + 4 + contentLength;
+      if (inputBuffer.length < messageEnd) {
+        return;
+      }
+
+      body = inputBuffer.slice(headerEnd + 4, messageEnd).toString('utf8');
+      inputBuffer = inputBuffer.slice(messageEnd);
+    } else {
+      const newlineIndex = inputBuffer.indexOf('\n');
+      if (newlineIndex === -1) {
+        return;
+      }
+
+      body = inputBuffer.slice(0, newlineIndex).toString('utf8').replace(/\r$/, '').trim();
+      inputBuffer = inputBuffer.slice(newlineIndex + 1);
+      if (!body) {
+        continue;
+      }
+    }
+
+    let message;
+    try {
+      message = JSON.parse(body);
+    } catch {
+      continue;
+    }
+
+    Promise.resolve(handleMessage(message)).catch((error) => {
+      if (message && message.id !== undefined) {
+        writeError(message.id, -32603, (error && error.message) || 'Internal error');
+      }
+    });
+  }
+}
+
+process.stdin.on('data', (chunk) => {
+  inputBuffer = Buffer.concat([inputBuffer, chunk]);
+  parseMessages();
+});
+
+process.stdin.on('error', () => {
+  process.exit(0);
+});
+
+process.on('exit', (code) => {
+  writeSessionSummary(code);
+});
+
+['SIGINT', 'SIGTERM', 'SIGHUP'].forEach((signal) => {
+  process.on(signal, () => {
+    writeSessionSummary(signal);
+    process.exit(0);
+  });
+});
+
+process.stdin.resume();

package/lib/progress-indicator.ps1

@@ -0,0 +1,120 @@
+# CCS Progress Indicator (PowerShell 5.1+ compatible)
+# Simple spinner for long-running operations
+# NO external dependencies - ASCII-only for cross-platform compatibility
+
+$ErrorActionPreference = "Stop"
+
+# Show simple spinner (synchronous)
+function Show-Spinner {
+    param(
+        [string]$Message,
+        [scriptblock]$Task
+    )
+
+    # TTY detection: only animate if not redirected and not in CI
+    $IsTTY = -not [Console]::IsOutputRedirected -and -not $env:CI -and -not $env:NO_COLOR
+
+    $StartTime = Get-Date
+
+    if (-not $IsTTY) {
+        # Non-TTY: just print message and run task
+        Write-Host "[i] $Message..." -ForegroundColor Gray
+        $result = & $Task
+        Write-Host "[OK] $Message" -ForegroundColor Green
+        return $result
+    }
+
+    # ASCII-only frames for cross-platform compatibility
+    $Frames = @('|', '/', '-', '\')
+    $FrameIndex = 0
+
+    # Start task in background job
+    $Job = Start-Job -ScriptBlock $Task
+
+    try {
+        # Animate spinner while job is running
+        while ($Job.State -eq 'Running') {
+            $Frame = $Frames[$FrameIndex]
+            $Elapsed = [math]::Round(((Get-Date) - $StartTime).TotalSeconds, 1)
+            Write-Host "`r[$Frame] $Message... ($($Elapsed)s)" -NoNewline -ForegroundColor Cyan
+            $FrameIndex = ($FrameIndex + 1) % $Frames.Length
+            Start-Sleep -Milliseconds 100
+        }
+
+        # Clear spinner line
+        Write-Host "`r$(' ' * 80)`r" -NoNewline
+
+        # Check job result
+        $JobResult = Receive-Job -Job $Job -ErrorAction Stop
+        $Elapsed = [math]::Round(((Get-Date) - $StartTime).TotalSeconds, 1)
+        Write-Host "[OK] $Message ($($Elapsed)s)" -ForegroundColor Green
+
+        return $JobResult
+    }
+    catch {
+        # Clear spinner line
+        Write-Host "`r$(' ' * 80)`r" -NoNewline
+        Write-Host "[X] $Message" -ForegroundColor Red
+        throw
+    }
+    finally {
+        # Cleanup job
+        if ($Job) {
+            Remove-Job -Job $Job -Force -ErrorAction SilentlyContinue
+        }
+    }
+}
+
+# Show progress counter for multi-step operations
+function Show-ProgressStep {
+    param(
+        [int]$Current,
+        [int]$Total,
+        [string]$Message
+    )
+
+    # TTY detection
+    $IsTTY = -not [Console]::IsOutputRedirected -and -not $env:CI
+
+    if (-not $IsTTY) {
+        Write-Host "[$Current/$Total] $Message" -ForegroundColor Gray
+        return
+    }
+
+    # Show progress with carriage return (can be overwritten)
+    Write-Host "`r[$Current/$Total] $Message..." -NoNewline -ForegroundColor Cyan
+}
+
+# Clear progress line
+function Clear-Progress {
+    $IsTTY = -not [Console]::IsOutputRedirected -and -not $env:CI
+
+    if ($IsTTY) {
+        Write-Host "`r$(' ' * 80)`r" -NoNewline
+    }
+}
+
+# Simple status message (for operations that don't need spinners)
+function Write-Status {
+    param(
+        [string]$Message,
+        [ValidateSet('Info', 'Success', 'Warning', 'Error')]
+        [string]$Type = 'Info'
+    )
+
+    $Prefix = switch ($Type) {
+        'Info' { '[i]'; break }
+        'Success' { '[OK]'; break }
+        'Warning' { '[!]'; break }
+        'Error' { '[X]'; break }
+    }
+
+    $Color = switch ($Type) {
+        'Info' { 'Gray'; break }
+        'Success' { 'Green'; break }
+        'Warning' { 'Yellow'; break }
+        'Error' { 'Red'; break }
+    }
+
+    Write-Host "$Prefix $Message" -ForegroundColor $Color
+}

package/lib/progress-indicator.sh

@@ -0,0 +1,117 @@
+#!/usr/bin/env bash
+# CCS Progress Indicator (bash 3.2+ compatible)
+# Simple spinner for long-running operations
+# NO external dependencies - ASCII-only for cross-platform compatibility
+
+set -euo pipefail
+
+# Show spinner while a background process is running
+# Usage: show_spinner "message" $pid
+show_spinner() {
+  local message="$1"
+  local pid="$2"
+
+  # TTY detection: only animate if stderr is TTY and not in CI
+  if [[ ! -t 2 ]] || [[ -n "${CI:-}" ]] || [[ -n "${NO_COLOR:-}" ]]; then
+    # Non-TTY: just print message once
+    echo "[i] $message..." >&2
+    wait "$pid" 2>/dev/null || true
+    return
+  fi
+
+  # ASCII-only frames for cross-platform compatibility
+  local frames=('|' '/' '-' '\\')
+  local frame_idx=0
+  local start_time=$(date +%s)
+
+  # Animate spinner while process is running
+  while kill -0 "$pid" 2>/dev/null; do
+    local frame="${frames[$frame_idx]}"
+    local elapsed=$(($(date +%s) - start_time))
+    printf "\r[%s] %s... (%ds)" "$frame" "$message" "$elapsed" >&2
+    frame_idx=$(( (frame_idx + 1) % 4 ))
+    sleep 0.1
+  done
+
+  # Clear spinner line
+  printf "\r\033[K" >&2
+
+  # Wait for process to complete and capture exit code
+  wait "$pid" 2>/dev/null || true
+}
+
+# Show spinner with success/fail result
+# Usage: spinner_with_result "message" "command"
+spinner_with_result() {
+  local message="$1"
+  shift
+  local command=("$@")
+
+  local start_time=$(date +%s)
+
+  # TTY detection
+  if [[ ! -t 2 ]] || [[ -n "${CI:-}" ]] || [[ -n "${NO_COLOR:-}" ]]; then
+    # Non-TTY: just print message and run command
+    echo "[i] $message..." >&2
+    if "${command[@]}"; then
+      echo "[OK] $message" >&2
+      return 0
+    else
+      echo "[X] $message" >&2
+      return 1
+    fi
+  fi
+
+  # Run command in background
+  "${command[@]}" &>/dev/null &
+  local pid=$!
+
+  # Show spinner
+  local frames=('|' '/' '-' '\\')
+  local frame_idx=0
+
+  while kill -0 "$pid" 2>/dev/null; do
+    local frame="${frames[$frame_idx]}"
+    local elapsed=$(($(date +%s) - start_time))
+    printf "\r[%s] %s... (%ds)" "$frame" "$message" "$elapsed" >&2
+    frame_idx=$(( (frame_idx + 1) % 4 ))
+    sleep 0.1
+  done
+
+  # Clear spinner line
+  printf "\r\033[K" >&2
+
+  # Check result
+  if wait "$pid" 2>/dev/null; then
+    local elapsed=$(($(date +%s) - start_time))
+    echo "[OK] $message (${elapsed}s)" >&2
+    return 0
+  else
+    echo "[X] $message" >&2
+    return 1
+  fi
+}
+
+# Simple progress counter (for multi-step operations)
+# Usage: show_progress_step 3 10 "Checking configuration"
+show_progress_step() {
+  local current="$1"
+  local total="$2"
+  local message="$3"
+
+  # TTY detection
+  if [[ ! -t 2 ]] || [[ -n "${CI:-}" ]]; then
+    echo "[${current}/${total}] $message" >&2
+    return
+  fi
+
+  # Show progress with carriage return (can be overwritten)
+  printf "\r[%d/%d] %s..." "$current" "$total" "$message" >&2
+}
+
+# Clear progress line
+clear_progress() {
+  if [[ -t 2 ]] && [[ -z "${CI:-}" ]]; then
+    printf "\r\033[K" >&2
+  fi
+}

package/lib/prompt.ps1

@@ -0,0 +1,109 @@
+# CCS Interactive Prompt Utilities (PowerShell 5.1+ compatible)
+# NO external dependencies
+
+$ErrorActionPreference = "Stop"
+
+# Interactive confirmation prompt
+function Confirm-Action {
+    param(
+        [string]$Message,
+        [ValidateSet('Yes', 'No')]
+        [string]$Default = 'No'
+    )
+
+    # Check for --yes flag (automation)
+    if ($env:CCS_YES -eq '1' -or $global:RemainingArgs -contains '--yes' -or $global:RemainingArgs -contains '-y') {
+        return $Default -eq 'Yes'
+    }
+
+    # Check for --no-input flag (CI)
+    if ($env:CCS_NO_INPUT -eq '1' -or $global:RemainingArgs -contains '--no-input') {
+        Write-Host "[X] Interactive input required but --no-input specified" -ForegroundColor Red
+        exit 1
+    }
+
+    # Non-TTY: use default
+    if ([Console]::IsInputRedirected) {
+        return $Default -eq 'Yes'
+    }
+
+    # Interactive prompt
+    $PromptText = if ($Default -eq 'Yes') {
+        "$Message [Y/n]: "
+    } else {
+        "$Message [y/N]: "
+    }
+
+    while ($true) {
+        Write-Host $PromptText -NoNewline -ForegroundColor Cyan
+        $Response = Read-Host
+
+        $Normalized = $Response.Trim().ToLower()
+
+        # Empty answer: use default
+        if ($Normalized -eq '' -or $Normalized -eq ' ') {
+            return $Default -eq 'Yes'
+        }
+
+        # Valid answers
+        if ($Normalized -eq 'y' -or $Normalized -eq 'yes') {
+            return $true
+        }
+
+        if ($Normalized -eq 'n' -or $Normalized -eq 'no') {
+            return $false
+        }
+
+        # Invalid input: retry
+        Write-Host "[!] Please answer y or n" -ForegroundColor Yellow
+    }
+}
+
+# Interactive text input
+function Read-Input {
+    param(
+        [string]$Message,
+        [string]$Default = '',
+        [scriptblock]$Validate = $null
+    )
+
+    # Non-TTY: use default or error
+    if ([Console]::IsInputRedirected) {
+        if ($Default) {
+            return $Default
+        }
+        throw "Interactive input required but stdin is redirected"
+    }
+
+    # Interactive prompt
+    $PromptText = if ($Default) {
+        "${Message} [$Default]: "
+    } else {
+        "${Message}: "
+    }
+
+    while ($true) {
+        Write-Host $PromptText -NoNewline -ForegroundColor Cyan
+        $Response = Read-Host
+
+        $Value = if ($Response.Trim()) { $Response.Trim() } else { $Default }
+
+        # Validate input if validator provided
+        if ($Validate) {
+            $Error = & $Validate $Value
+            if ($Error) {
+                Write-Host "[!] $Error" -ForegroundColor Yellow
+                continue
+            }
+        }
+
+        return $Value
+    }
+}
+
+# Check if running in non-interactive mode
+function Test-NonInteractive {
+    return [Console]::IsInputRedirected -or
+           $env:CCS_YES -eq '1' -or
+           $env:CCS_NO_INPUT -eq '1'
+}