copilot-tracer 1.0.5 → 1.0.7

package/README.md

@@ -1,6 +1,6 @@
 # copilot-tracer
 
-Real-time tracing and prompt-refinement companion for **GitHub Copilot CLI** and **VS Code Copilot extension**.
+Real-time tracing and prompt-refinement companion for **GitHub Copilot CLI**, **Claude Code**, and **VS Code Copilot extension**.
 
 Captures every prompt, response, token usage, AI credits, tool calls, and duration — all in one place. Runs as a background daemon that collects data from all your projects automatically. Includes a web dashboard with project overview and per-project live tracing.
 
@@ -11,7 +11,7 @@ Captures every prompt, response, token usage, AI credits, tool calls, and durati
 - **Daemon mode** — install once, run forever. Collects traces from all projects automatically
 - **Auto project detection** — detects project from `github.copilot.git.repository` in OTLP spans
 - **Zero-intrusion capture** — uses Copilot's built-in OTel support. Set env vars, done.
-- **Works everywhere** — captures both Copilot CLI and VS Code Copilot Chat
+- **Works everywhere** — captures GitHub Copilot CLI, Claude Code, and VS Code Copilot Chat
 - **Dashboard** — overview of all projects with token usage, credits, and session counts
 - **Live tracer** — real-time trace table per project with detail panel
 - **Prompt refinement** — rewrites prompts with stronger instructions and less noise
@@ -31,7 +31,8 @@ This will:
 1. Detect your Copilot CLI and VS Code installation
 2. Patch `~/.zshrc` with OTEL env vars
 3. Patch VS Code `settings.json` with terminal env vars
-4. Start the daemon on port 4747
+4. Enable Claude Code OTLP logs/events and enhanced beta traces
+5. Start the daemon on port 4747
 
 Then apply env vars in your current shell:
 
@@ -39,7 +40,9 @@ Then apply env vars in your current shell:
 source ~/.zshrc
 ```
 
-Restart VS Code once. After that, the daemon collects traces from all your Copilot sessions automatically.
+Restart VS Code once. After that, the daemon collects traces from all your Copilot
+and Claude Code sessions automatically. Claude Code content flags are enabled by
+setup so prompts and responses can be displayed in the local dashboard.
 
 Open **http://localhost:4747** to see the dashboard.
 
@@ -51,20 +54,20 @@ Open **http://localhost:4747** to see the dashboard.
 ┌─────────────────────────────────────────────────────────┐
 │  copilot-tracer --daemon (runs once, stays running)      │
 │                                                          │
-│  OTLP Receiver ← Copilot CLI + VS Code                   │
+│  OTLP Receiver ← Copilot CLI + Claude Code + VS Code                   │
 │  (auto-detects project from github.copilot.git.repository)│
 │                                                          │
 │  SQLite DB → Dashboard + Live Tracer (Socket.io)         │
 └─────────────────────────────────────────────────────────┘
 
-Copilot CLI / VS Code Copilot Chat
+Copilot CLI / Claude Code / VS Code Copilot Chat
          │
          │  OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4747
          ↓
-   POST /v1/traces (OpenTelemetry OTLP JSON)
+   POST /v1/traces and /v1/logs (OpenTelemetry OTLP JSON)
          │
          ↓
-   copilot-tracer parses spans → tokens, credits, tool calls
+   copilot-tracer parses spans and events → tokens, credits, tool calls
          │
          ↓
    SQLite DB (~/.copilot-tracer/traces.db)
@@ -121,6 +124,7 @@ Open http://localhost:4747 after starting the daemon.
 - **Summary cards** — total projects, sessions, tokens, credits
 - **Project cards** — each project shows path, session count, tokens, credits, last active
 - **Click a project** → opens live tracer filtered to that project
+<img width="737" height="410" alt="image" src="https://github.com/user-attachments/assets/dc20653b-8774-46b3-9a42-6e7bb934aded" />
 
 ---
 
@@ -138,6 +142,10 @@ Real-time trace table for a specific project.
 - Click Skills / Agents / MCPs → filtered call list
 - Real-time updates via Socket.io
 
+<img width="1504" height="742" alt="image" src="https://github.com/user-attachments/assets/f334108f-c587-4228-8120-7dac2f85f90b" />
+
+<img width="1061" height="696" alt="image" src="https://github.com/user-attachments/assets/1555d5a2-dbca-4f1d-b102-3d2865dcee68" />
+
 ---
 
 ## Prompt Refinement
@@ -173,8 +181,21 @@ Add to `~/.zshrc`:
 export OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4747
 export OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT=true
 export COPILOT_OTEL_ENABLED=true
+
+# Claude Code telemetry
+export CLAUDE_CODE_ENABLE_TELEMETRY=1
+export CLAUDE_CODE_ENHANCED_TELEMETRY_BETA=1
+export OTEL_LOGS_EXPORTER=otlp
+export OTEL_TRACES_EXPORTER=otlp
+export OTEL_EXPORTER_OTLP_PROTOCOL=http/json
+export OTEL_LOG_USER_PROMPTS=1
+export OTEL_LOG_ASSISTANT_RESPONSES=1
 ```
 
+Claude Code exports standard OTLP logs/events and optional beta traces. See
+[Anthropic's monitoring documentation](https://code.claude.com/docs/en/monitoring-usage)
+for protocol and content controls.
+
 For VS Code, add to `~/Library/Application Support/Code/User/settings.json`:
 
 ```json

package/dist/consoleUi.js

@@ -10,7 +10,7 @@ function fmtDuration(ms) {
     return `${(ms / 1000).toFixed(1)}s`;
 }
 function fmtCredits(c) {
-    return `${c.toFixed(2)} cr | $${(c * 0.01).toFixed(4)}`;
+    return `$${(c * 0.01).toFixed(4)}`;
 }
 function statusColor(status, text) {
     if (status === 'running')
@@ -25,7 +25,7 @@ export function renderConsoleTable(entries, summary) {
         head: [
             chalk.cyan('Date / Time'),
             chalk.cyan('Prompt'),
-            chalk.cyan('AI Credits'),
+            chalk.cyan('Est Cost'),
             chalk.cyan('Duration'),
             chalk.cyan('Tokens\nCached|Written|Reason'),
             chalk.cyan('Skills'),

package/dist/otlpReceiver.js

@@ -14,6 +14,7 @@
  *   chat <model> span attrs: same as above
  *   User message event: github.copilot.user.message
  */
+import { randomUUID } from 'crypto';
 import { upsertTrace, createSession, deleteTrace, ensureProject, ensureProjectByRepo } from './db.js';
 import { traceEvents } from './proxy.js';
 // ── Helpers ───────────────────────────────────────────────────────────────────
@@ -36,7 +37,53 @@ function nanoToMs(nano) {
 function nanoToIso(nano) {
     return new Date(nanoToMs(nano)).toISOString();
 }
+function getStringAttr(attrs, ...keys) {
+    for (const key of keys) {
+        const value = getAttr(attrs, key);
+        if (value !== undefined && String(value).trim())
+            return String(value);
+    }
+    return undefined;
+}
+function getBodyText(body) {
+    if (!body)
+        return undefined;
+    if (body.stringValue !== undefined)
+        return body.stringValue;
+    if (body.intValue !== undefined)
+        return String(body.intValue);
+    if (body.doubleValue !== undefined)
+        return String(body.doubleValue);
+    if (body.boolValue !== undefined)
+        return String(body.boolValue);
+    return undefined;
+}
 const inFlight = new Map(); // traceId → InFlight
+// Anthropic API pricing per 1K tokens (USD), converted to GitHub "AI credit" units
+// (1 credit = $0.01) so aiCredits stays one unit across Copilot and Claude entries.
+// Rates are Anthropic's current published per-model prices; a model id that doesn't
+// match a specific entry falls back to its tier's (opus/sonnet/haiku) latest rate.
+const ANTHROPIC_USD_PER_1K = {
+    'claude-fable-5': { input: 0.010, output: 0.050 },
+    'claude-mythos-5': { input: 0.010, output: 0.050 },
+    'claude-opus-5': { input: 0.005, output: 0.025 },
+    'claude-opus-4-8': { input: 0.005, output: 0.025 },
+    'claude-opus-4-7': { input: 0.005, output: 0.025 },
+    'claude-opus-4-6': { input: 0.005, output: 0.025 },
+    'claude-sonnet-5': { input: 0.002, output: 0.010 },
+    'claude-sonnet-4-6': { input: 0.003, output: 0.015 },
+    'claude-haiku-4-5': { input: 0.001, output: 0.005 },
+    'opus': { input: 0.005, output: 0.025 },
+    'sonnet': { input: 0.003, output: 0.015 },
+    'haiku': { input: 0.001, output: 0.005 },
+    'default': { input: 0.003, output: 0.015 },
+};
+export function calcClaudeCredits(tokens, model) {
+    const key = Object.keys(ANTHROPIC_USD_PER_1K).find(k => (model ?? '').toLowerCase().includes(k)) ?? 'default';
+    const rate = ANTHROPIC_USD_PER_1K[key];
+    const usd = (tokens.input / 1000) * rate.input + (tokens.output / 1000) * rate.output;
+    return usd * 100; // USD → credits (1 credit = $0.01)
+}
 // Sessions are created lazily. Always upsert so project_id gets backfilled
 // when the session was created earlier without a project.
 function ensureSession(sessionId, projectId) {
@@ -53,7 +100,7 @@ function resolveProjectId(repoUrl, workingDir, defaultProjectId) {
     return defaultProjectId;
 }
 function detectWorkingDir(attrs) {
-    for (const key of ['process.working_directory', 'github.copilot.working_dir']) {
+    for (const key of ['process.working_directory', 'github.copilot.working_dir', 'claude_code.working_dir']) {
         const v = getAttr(attrs, key);
         if (v && String(v).trim())
             return String(v).trim();
@@ -65,6 +112,120 @@ function detectWorkingDir(attrs) {
 const pendingChatIds = new Map(); // `chat:${traceId}` → list of entryIds
 // Buffer tool calls that arrive before invoke_agent
 const pendingToolCalls = new Map(); // traceId → tool calls
+const claudePromptEntries = new Map(); // prompt.id → trace entry
+const claudeInteractionEntries = new Map(); // traceId → interaction entry
+// Real Claude Code telemetry sends the child claude_code.llm_request span before its
+// parent claude_code.interaction span within the same batch, so buffer llm_request's
+// token/cost delta here until the interaction entry shows up to receive it.
+const pendingClaudeLlmDeltas = new Map();
+const CLAUDE_STATE_LIMIT = 1000;
+function rememberClaudeEntry(map, key, entry) {
+    map.set(key, entry);
+    if (map.size > CLAUDE_STATE_LIMIT) {
+        const oldest = map.keys().next().value;
+        if (oldest)
+            map.delete(oldest);
+    }
+}
+function claudeEventId(record, attrs, eventName) {
+    const messageId = getStringAttr(attrs, 'message.uuid', 'tool_use_id');
+    const promptId = getStringAttr(attrs, 'prompt.id');
+    return `claude:${messageId ?? promptId ?? record.traceId ?? randomUUID()}:${eventName}`;
+}
+function processClaudeLogRecord(record, resourceAttrs, sessionId, projectId, workingDir) {
+    const attrs = record.attributes ?? [];
+    const eventName = getStringAttr(attrs, 'event.name') ?? getBodyText(record.body);
+    if (!eventName || !eventName.startsWith('claude_code.'))
+        return;
+    const eventTime = getStringAttr(attrs, 'event.timestamp');
+    const dateTime = eventTime ?? (record.timeUnixNano ? nanoToIso(record.timeUnixNano) : new Date().toISOString());
+    const promptId = getStringAttr(attrs, 'prompt.id');
+    const resolvedProjectId = resolveProjectId(getStringAttr(resourceAttrs, 'github.copilot.git.repository', 'vcs.repository.url'), getStringAttr(attrs, 'process.working_directory', 'github.copilot.working_dir', 'claude_code.working_dir') ?? workingDir, projectId);
+    const eventSessionId = getStringAttr(attrs, 'session.id') ?? sessionId;
+    if (eventName === 'claude_code.user_prompt') {
+        const entry = {
+            id: claudeEventId(record, attrs, 'prompt'),
+            sessionId: eventSessionId,
+            dateTime,
+            prompt: getStringAttr(attrs, 'prompt') ?? '[Claude Code prompt]',
+            tokens: { input: 0, output: 0, cached: 0, reasoning: 0, written: 0, total: 0 },
+            aiCredits: 0,
+            durationMs: 0,
+            toolCalls: [],
+            skillCount: 0,
+            agentCount: 0,
+            mcpCount: 0,
+            status: 'running',
+        };
+        if (promptId)
+            rememberClaudeEntry(claudePromptEntries, promptId, entry);
+        ensureSession(eventSessionId, resolvedProjectId);
+        upsertTrace(entry);
+        traceEvents.emit('trace:update', entry);
+        return;
+    }
+    if (eventName === 'claude_code.assistant_response') {
+        const existingEntry = promptId ? claudePromptEntries.get(promptId) : undefined;
+        const entry = existingEntry ?? {
+            id: claudeEventId(record, attrs, 'response'),
+            sessionId: eventSessionId,
+            dateTime,
+            prompt: '[Claude Code response]',
+            tokens: { input: 0, output: 0, cached: 0, reasoning: 0, written: 0, total: 0 },
+            aiCredits: 0,
+            durationMs: 0,
+            toolCalls: [],
+            skillCount: 0,
+            agentCount: 0,
+            mcpCount: 0,
+            status: 'running',
+        };
+        entry.response = getStringAttr(attrs, 'response');
+        entry.status = 'done';
+        entry.durationMs = Number(getStringAttr(attrs, 'duration_ms') ?? 0);
+        ensureSession(eventSessionId, resolvedProjectId);
+        upsertTrace(entry);
+        traceEvents.emit('trace:update', entry);
+        traceEvents.emit('trace:done', entry);
+        return;
+    }
+    if (eventName === 'claude_code.tool_result') {
+        const entry = promptId ? claudePromptEntries.get(promptId) : undefined;
+        if (!entry)
+            return;
+        const toolName = getStringAttr(attrs, 'tool_name') ?? 'Claude Code tool';
+        const toolId = getStringAttr(attrs, 'tool_use_id') ?? randomUUID();
+        if (entry.toolCalls.some(call => call.id === toolId))
+            return;
+        entry.toolCalls.push({
+            id: toolId,
+            name: toolName,
+            type: detectToolType(toolName),
+            input: {},
+            startedAt: Date.parse(dateTime),
+            endedAt: Date.parse(dateTime),
+            durationMs: Number(getStringAttr(attrs, 'duration_ms') ?? 0),
+            error: getStringAttr(attrs, 'error'),
+        });
+        upsertTrace(entry);
+        traceEvents.emit('trace:update', entry);
+    }
+}
+function processClaudeLogs(payload, defaultSessionId, projectId) {
+    if (!payload || !Array.isArray(payload.resourceLogs)) {
+        throw new Error('OTLP logs payload must contain resourceLogs');
+    }
+    for (const resourceLogs of payload.resourceLogs ?? []) {
+        const resourceAttrs = resourceLogs.resource?.attributes ?? [];
+        const sessionId = getStringAttr(resourceAttrs, 'session.id') ?? defaultSessionId;
+        const workingDir = detectWorkingDir(resourceAttrs);
+        for (const scopeLogs of resourceLogs.scopeLogs ?? []) {
+            for (const record of scopeLogs.logRecords ?? []) {
+                processClaudeLogRecord(record, resourceAttrs, sessionId, projectId, workingDir);
+            }
+        }
+    }
+}
 function processSpans(spans, sessionId, projectId, workingDir) {
     for (const span of spans) {
         // DEBUG — log raw span to stderr when COPILOT_TRACER_DEBUG=1
@@ -75,6 +236,78 @@ function processSpans(spans, sessionId, projectId, workingDir) {
         const spanName = span.name;
         const traceId = span.traceId;
         const spanId = span.spanId;
+        if (spanName === 'claude_code.interaction') {
+            const attrs = span.attributes ?? [];
+            const inputTokens = Number(getAttr(attrs, 'input_tokens') ?? 0);
+            const outputTokens = Number(getAttr(attrs, 'output_tokens') ?? 0);
+            const model = getStringAttr(attrs, 'model', 'gen_ai.request.model');
+            const entry = {
+                id: spanId,
+                sessionId: getStringAttr(attrs, 'session.id') ?? sessionId,
+                dateTime: nanoToIso(span.startTimeUnixNano),
+                prompt: getStringAttr(attrs, 'user_prompt') ?? '[Claude Code interaction]',
+                tokens: { input: inputTokens, output: outputTokens, cached: Number(getAttr(attrs, 'cache_read_tokens') ?? 0), reasoning: 0, written: outputTokens, total: inputTokens + outputTokens },
+                aiCredits: calcClaudeCredits({ input: inputTokens, output: outputTokens }, model),
+                durationMs: Number(getAttr(attrs, 'interaction.duration_ms')
+                    ?? (nanoToMs(span.endTimeUnixNano) - nanoToMs(span.startTimeUnixNano))),
+                toolCalls: [],
+                skillCount: 0,
+                agentCount: 0,
+                mcpCount: 0,
+                status: (span.status?.code ?? 0) === 2 ? 'error' : 'done',
+                error: span.status?.message,
+            };
+            // Apply any llm_request delta that arrived before this interaction span.
+            const pendingDelta = pendingClaudeLlmDeltas.get(traceId);
+            if (pendingDelta) {
+                entry.tokens = {
+                    input: entry.tokens.input + pendingDelta.input,
+                    output: entry.tokens.output + pendingDelta.output,
+                    cached: entry.tokens.cached + pendingDelta.cached,
+                    reasoning: 0,
+                    written: entry.tokens.written + pendingDelta.output,
+                    total: entry.tokens.total + pendingDelta.input + pendingDelta.output,
+                };
+                entry.aiCredits += pendingDelta.credits;
+                pendingClaudeLlmDeltas.delete(traceId);
+            }
+            ensureSession(entry.sessionId, resolveProjectId(getAttr(attrs, 'vcs.repository.url'), detectWorkingDir(attrs) ?? workingDir, projectId));
+            upsertTrace(entry);
+            rememberClaudeEntry(claudeInteractionEntries, traceId, entry);
+            traceEvents.emit('trace:update', entry);
+            traceEvents.emit('trace:done', entry);
+            continue;
+        }
+        if (spanName === 'claude_code.llm_request') {
+            const inputTokens = Number(getAttr(attrs, 'input_tokens') ?? 0);
+            const outputTokens = Number(getAttr(attrs, 'output_tokens') ?? 0);
+            const cachedTokens = Number(getAttr(attrs, 'cache_read_tokens') ?? 0);
+            const model = getStringAttr(attrs, 'model', 'gen_ai.request.model');
+            const entry = claudeInteractionEntries.get(traceId);
+            if (entry) {
+                entry.tokens = {
+                    input: entry.tokens.input + inputTokens,
+                    output: entry.tokens.output + outputTokens,
+                    cached: entry.tokens.cached + cachedTokens,
+                    reasoning: 0,
+                    written: entry.tokens.written + outputTokens,
+                    total: entry.tokens.total + inputTokens + outputTokens,
+                };
+                entry.aiCredits += calcClaudeCredits({ input: inputTokens, output: outputTokens }, model);
+                upsertTrace(entry);
+                traceEvents.emit('trace:update', entry);
+            }
+            else {
+                // Parent claude_code.interaction span hasn't arrived yet — buffer the delta.
+                const pending = pendingClaudeLlmDeltas.get(traceId) ?? { input: 0, output: 0, cached: 0, credits: 0 };
+                pending.input += inputTokens;
+                pending.output += outputTokens;
+                pending.cached += cachedTokens;
+                pending.credits += calcClaudeCredits({ input: inputTokens, output: outputTokens }, model);
+                rememberClaudeEntry(pendingClaudeLlmDeltas, traceId, pending);
+            }
+            continue;
+        }
         // ── invoke_agent span = top-level agent turn ──────────────────────────
         if (spanName === 'invoke_agent') {
             const startMs = nanoToMs(span.startTimeUnixNano);
@@ -426,8 +659,17 @@ export function registerOtlpRoutes(app, defaultSessionId, projectId) {
             res.status(400).json({ error: 'invalid payload' });
         }
     });
-    // Metrics + logs — accept and ignore
+    app.post('/v1/logs', (req, res) => {
+        try {
+            processClaudeLogs(req.body, defaultSessionId, projectId);
+            res.status(200).json({ partialSuccess: {} });
+        }
+        catch (e) {
+            console.error('[OTLP] log parse error:', e);
+            res.status(400).json({ error: 'invalid payload' });
+        }
+    });
+    // Metrics remain accepted for Claude Code dashboards but are not trace entries.
     app.post('/v1/metrics', (_req, res) => res.status(200).json({ partialSuccess: {} }));
-    app.post('/v1/logs', (_req, res) => res.status(200).json({ partialSuccess: {} }));
-    console.log('  📡 OTLP receiver ready on /v1/traces');
+    console.log('  📡 OTLP receiver ready on /v1/traces and /v1/logs');
 }

package/dist/setup.js

@@ -1,5 +1,5 @@
 /**
- * copilot-tracer setup — auto-detect copilot CLI + VS Code and inject OTLP env config
+ * copilot-tracer setup — auto-detect Copilot/VS Code and inject OTLP env config
  *
  * What it does:
  *  1. Detect copilot CLI (which copilot)
@@ -16,12 +16,26 @@ import os from 'os';
 const OTEL_ENDPOINT_KEY = 'OTEL_EXPORTER_OTLP_ENDPOINT';
 const OTEL_CONTENT_KEY = 'OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT';
 const OTEL_ENABLED_KEY = 'COPILOT_OTEL_ENABLED';
+const CLAUDE_TELEMETRY_KEY = 'CLAUDE_CODE_ENABLE_TELEMETRY';
+const CLAUDE_TRACES_KEY = 'CLAUDE_CODE_ENHANCED_TELEMETRY_BETA';
+const OTEL_LOGS_EXPORTER_KEY = 'OTEL_LOGS_EXPORTER';
+const OTEL_TRACES_EXPORTER_KEY = 'OTEL_TRACES_EXPORTER';
+const OTEL_PROTOCOL_KEY = 'OTEL_EXPORTER_OTLP_PROTOCOL';
+const OTEL_LOG_PROMPTS_KEY = 'OTEL_LOG_USER_PROMPTS';
+const OTEL_LOG_RESPONSES_KEY = 'OTEL_LOG_ASSISTANT_RESPONSES';
 function otelEnvBlock(port) {
     return [
         `# >>> copilot-tracer OTLP config (auto-added) >>>`,
         `export ${OTEL_ENDPOINT_KEY}=http://localhost:${port}`,
         `export ${OTEL_CONTENT_KEY}=true`,
         `export ${OTEL_ENABLED_KEY}=true`,
+        `export ${CLAUDE_TELEMETRY_KEY}=1`,
+        `export ${CLAUDE_TRACES_KEY}=1`,
+        `export ${OTEL_LOGS_EXPORTER_KEY}=otlp`,
+        `export ${OTEL_TRACES_EXPORTER_KEY}=otlp`,
+        `export ${OTEL_PROTOCOL_KEY}=http/json`,
+        `export ${OTEL_LOG_PROMPTS_KEY}=1`,
+        `export ${OTEL_LOG_RESPONSES_KEY}=1`,
         ``,
         `# Tag every copilot prompt with the terminal folder it ran from, so the`,
         `# tracer can attribute it to the right project. OTLP carries no working-dir,`,
@@ -42,6 +56,22 @@ function otelEnvBlock(port) {
         `  export OTEL_RESOURCE_ATTRIBUTES`,
         `  command copilot "\$@"`,
         `}`,
+        ``,
+        `claude() {`,
+        `  local _wd`,
+        `  if command -v python3 >/dev/null 2>&1; then`,
+        `    _wd="$(pwd | python3 -c 'import sys,urllib.parse;print(urllib.parse.quote(sys.stdin.read().strip(), safe="/"))')"`,
+        `  else`,
+        `    _wd="$(pwd)"`,
+        `  fi`,
+        `  if [ -n "\${OTEL_RESOURCE_ATTRIBUTES:-}" ]; then`,
+        `    OTEL_RESOURCE_ATTRIBUTES="\${OTEL_RESOURCE_ATTRIBUTES},claude_code.working_dir=\${_wd}"`,
+        `  else`,
+        `    OTEL_RESOURCE_ATTRIBUTES="claude_code.working_dir=\${_wd}"`,
+        `  fi`,
+        `  export OTEL_RESOURCE_ATTRIBUTES`,
+        `  command claude "\$@"`,
+        `}`,
         `# <<< copilot-tracer <<<`,
     ].join('\n');
 }
@@ -50,6 +80,13 @@ function vscodeEnvBlock(port) {
         [OTEL_ENDPOINT_KEY]: `http://localhost:${port}`,
         [OTEL_CONTENT_KEY]: 'true',
         [OTEL_ENABLED_KEY]: 'true',
+        [CLAUDE_TELEMETRY_KEY]: '1',
+        [CLAUDE_TRACES_KEY]: '1',
+        [OTEL_LOGS_EXPORTER_KEY]: 'otlp',
+        [OTEL_TRACES_EXPORTER_KEY]: 'otlp',
+        [OTEL_PROTOCOL_KEY]: 'http/json',
+        [OTEL_LOG_PROMPTS_KEY]: '1',
+        [OTEL_LOG_RESPONSES_KEY]: '1',
     };
 }
 // ── Detection helpers ─────────────────────────────────────────────────────────
@@ -110,11 +147,13 @@ function patchShellProfile(profilePath, port) {
     const block = otelEnvBlock(port);
     // Already has our block?
     if (content.includes('copilot-tracer OTLP config')) {
-        // Check if port matches
-        if (content.includes(`http://localhost:${port}`)) {
+        // Only skip if the embedded block is byte-identical to what we'd generate now —
+        // a marker + matching port isn't enough, since the block's env vars can gain new
+        // keys (e.g. Claude Code support) between tracer versions without the port changing.
+        if (content.includes(block)) {
             return { action: 'already_set' };
         }
-        // Port changed — update
+        // Block is stale (port changed, or vars were added/changed) — replace it in place
         const updated = content.replace(/# >>> copilot-tracer OTLP config[\s\S]*?# <<< copilot-tracer <<</, block);
         fs.writeFileSync(profilePath, updated, 'utf8');
         return { action: 'updated' };
@@ -138,10 +177,9 @@ function patchVSCodeSettings(settingsPath, port) {
     const envKey = 'terminal.integrated.env.osx';
     const existing = (settings[envKey] ?? {});
     const newEnv = vscodeEnvBlock(port);
-    // Check if already set correctly
-    if (existing[OTEL_ENDPOINT_KEY] === `http://localhost:${port}` &&
-        existing[OTEL_CONTENT_KEY] === 'true' &&
-        existing[OTEL_ENABLED_KEY] === 'true') {
+    // Already set correctly only if every current key/value is present — checking a
+    // hardcoded subset let newer keys (e.g. Claude Code support) silently go unset.
+    if (Object.entries(newEnv).every(([k, v]) => existing[k] === v)) {
         return { action: 'already_set' };
     }
     const wasSet = !!existing[OTEL_ENDPOINT_KEY];
@@ -193,13 +231,13 @@ export function runSetup(port, silent = false) {
         const label = path.basename(profilePath);
         if (result.action === 'added') {
             console.log(`\n${CHECK} Shell profile patched: ${label}`);
-            console.log(`   ${ARROW} Added OTEL env vars (endpoint, content capture)`);
+            console.log(`   ${ARROW} Added Copilot + Claude Code OTLP env vars`);
             console.log(`   ${ARROW} Added copilot() wrapper — tags each prompt with the terminal folder`);
             console.log(`   ${ARROW} Run: source ${profilePath}`);
         }
         else if (result.action === 'updated') {
             console.log(`\n${CHECK} Shell profile updated: ${label}`);
-            console.log(`   ${ARROW} Updated port to ${port} + copilot() wrapper`);
+            console.log(`   ${ARROW} Updated port to ${port} + Claude Code/Copilot OTLP config`);
             console.log(`   ${ARROW} Run: source ${profilePath}`);
         }
         else {
@@ -231,6 +269,13 @@ export function runSetup(port, silent = false) {
     process.env[OTEL_ENDPOINT_KEY] = `http://localhost:${port}`;
     process.env[OTEL_CONTENT_KEY] = 'true';
     process.env[OTEL_ENABLED_KEY] = 'true';
+    process.env[CLAUDE_TELEMETRY_KEY] = '1';
+    process.env[CLAUDE_TRACES_KEY] = '1';
+    process.env[OTEL_LOGS_EXPORTER_KEY] = 'otlp';
+    process.env[OTEL_TRACES_EXPORTER_KEY] = 'otlp';
+    process.env[OTEL_PROTOCOL_KEY] = 'http/json';
+    process.env[OTEL_LOG_PROMPTS_KEY] = '1';
+    process.env[OTEL_LOG_RESPONSES_KEY] = '1';
     // 6. Summary
     if (!silent) {
         const profileBase = profilePath ? path.basename(profilePath) : '.zshrc';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "copilot-tracer",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "Real-time tracing and prompt-refinement companion for GitHub Copilot CLI and VS Code Copilot — tracks tokens, AI credits, tool calls, and refined prompts with console and web UI",
   "keywords": [
     "copilot",
@@ -14,7 +14,7 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/chuongnd/copilot-tracer.git"
+    "url": "https://github.com/chuongxl/copilot-tracer.git"
   },
   "engines": {
     "node": ">=18"

package/web/index.html

@@ -321,7 +321,7 @@ Reply with ONLY the rewritten prompt. No explanation, no preamble.`;
 
     <div class="stats-bar">
       <div class="stat"><span class="stat-label">Total Prompts</span><span class="stat-value" id="s-prompts">0</span></div>
-      <div class="stat"><span class="stat-label">AI Credits</span><span class="stat-value credits" id="s-credits">0.00 cr | $0.0000</span></div>
+      <div class="stat"><span class="stat-label">Est Cost</span><span class="stat-value credits" id="s-credits">$0.0000</span></div>
       <div class="stat"><span class="stat-label">Total Tokens</span><span class="stat-value tokens" id="s-tokens">0</span></div>
       <div class="stat"><span class="stat-label">Cached</span><span class="stat-value tokens" id="s-cached">0</span></div>
       <div class="stat"><span class="stat-label">Reasoning</span><span class="stat-value" style="color:#d2a8ff" id="s-reasoning">0</span></div>
@@ -338,7 +338,7 @@ Reply with ONLY the rewritten prompt. No explanation, no preamble.`;
             <tr>
               <th>Date / Time</th>
               <th>Prompt</th>
-              <th>AI Credits</th>
+              <th>Est Cost</th>
               <th>Duration</th>
               <th>Cached Tokens</th>
               <th>Written Tokens</th>
@@ -488,7 +488,7 @@ Reply with ONLY the rewritten prompt. No explanation, no preamble.`;
         <div class="dash-total-value tokens">${data.totals.tokens.toLocaleString()}</div>
       </div>
       <div class="dash-total-card">
-        <div class="dash-total-label">Total AI Credits</div>
+        <div class="dash-total-label">Total Est Cost</div>
         <div class="dash-total-value credits">${fmtCredits(data.totals.credits)}</div>
       </div>
     `;
@@ -525,7 +525,7 @@ Reply with ONLY the rewritten prompt. No explanation, no preamble.`;
               <span class="dash-project-stat-value tokens">${p.totalTokens.toLocaleString()}</span>
             </div>
             <div class="dash-project-stat">
-              <span class="dash-project-stat-label">AI Credits</span>
+              <span class="dash-project-stat-label">Est Cost</span>
               <span class="dash-project-stat-value credits">${fmtCredits(p.totalCredits)}</span>
             </div>
           </div>
@@ -559,7 +559,7 @@ Reply with ONLY the rewritten prompt. No explanation, no preamble.`;
     return ms < 1000 ? ms + 'ms' : (ms/1000).toFixed(1) + 's';
   }
 
-  function fmtCredits(c) { return (c||0).toFixed(2) + ' cr | $' + ((c||0)*0.01).toFixed(4); }
+  function fmtCredits(c) { return '$' + ((c||0)*0.01).toFixed(4); }
 
   function fmtDateTime(dt) {
     if (!dt) return '—';
@@ -650,7 +650,7 @@ Written:   ${(t.tokens?.written||0).toLocaleString()}
 Reasoning: ${(t.tokens?.reasoning||0).toLocaleString()}
 Output:    ${(t.tokens?.output||0).toLocaleString()}
 Total:     ${(t.tokens?.total||0).toLocaleString()}
-AI Credits: ${fmtCredits(t.aiCredits)}
+Est Cost:  ${fmtCredits(t.aiCredits)}
         </div>
       </div>
       ${t.toolCalls?.length ? `
@@ -725,14 +725,14 @@ AI Credits: ${fmtCredits(t.aiCredits)}
   function showCreditDetail(id) {
     const t = traces[id];
     if (!t) return;
-    document.getElementById('modal-title').textContent = `AI Credits: ${fmtCredits(t.aiCredits)}`;
+    document.getElementById('modal-title').textContent = `Est Cost: ${fmtCredits(t.aiCredits)}`;
     document.getElementById('modal-body').innerHTML = `
       <div class="detail-box" style="line-height:2">
 Input tokens:     ${(t.tokens?.input||0).toLocaleString()} × $0.003/1k = $${((t.tokens?.input||0)/1000*0.003).toFixed(5)}
 Written tokens:   ${(t.tokens?.written||0).toLocaleString()} × $0.006/1k = $${((t.tokens?.written||0)/1000*0.006).toFixed(5)}
 Reasoning tokens: ${(t.tokens?.reasoning||0).toLocaleString()} × $0.009/1k = $${((t.tokens?.reasoning||0)/1000*0.009).toFixed(5)}
 ─────────────────────────────────────────
-Total AI Credits: ${fmtCredits(t.aiCredits)}
+Total Est Cost:   ${fmtCredits(t.aiCredits)}
 Duration:         ${fmtDuration(t.durationMs)}
       </div>
     `;