feat: Add structured telemetry metrics, strict MCP config mode, and PermissionDecision types

Raymo · Raymo · commit 42681ebc5a80 · 2026-07-26T17:23:12.000+08:00
- feat(telemetry): Add PermissionDecisionMetrics and ToolUsageMetrics types
- feat(telemetry): Implement in-memory metrics store (per-session, non-persistent)
- feat(telemetry): Export recordPermissionDecision, recordToolUsage, getSessionMetrics
- feat(mcp-manager): Add strict MCP config mode with command allowlist validation
- feat(mcp-manager): Support setStrictMode() for upstream --strict-mcp-config
- feat(session): Wire strictMcpConfig from settings to McpManager
- feat(settings): Add strictMcpConfig option to DeepcodingSettings schema
- refactor: Re-export new telemetry types from core/index.ts

Upstream reference: Claude Code --strict-mcp-config flag
diff --git a/packages/core/src/common/telemetry.ts b/packages/core/src/common/telemetry.ts
@@ -1,3 +1,6 @@
+// Upstream reference: claude_code_formatted.js L1867-L1884
+// OpenTelemetry-style structured metrics for observability
+
 const DEFAULT_NEW_PROMPT_API_URL = "https://deepcode.vegamo.cn/api/plugin/new";
 const DEFAULT_REPORT_TIMEOUT_MS = 3000;
 
@@ -7,6 +10,26 @@ export type NewPromptReportOptions = {
   timeoutMs?: number;
 };
 
+export type PermissionDecisionMetrics = {
+  /** Tool type: "Edit" | "Write" | "Read" | "Bash" | "NotebookEdit" */
+  toolType: string;
+  /** Decision: "accept" | "reject" */
+  decision: "accept" | "reject";
+};
+
+export type ToolUsageMetrics = {
+  /** Total cost in USD for the session */
+  totalCostUSD: number;
+  /** Total API duration in ms */
+  totalAPIDuration: number;
+  /** Lines of code added */
+  totalLinesAdded: number;
+  /** Lines of code removed */
+  totalLinesRemoved: number;
+  /** Number of tool calls made */
+  totalToolCalls: number;
+};
+
 /**
  * Fire-and-forget report of a new prompt session.
  * Respects the `enabled` toggle: when disabled, the call is a no-op.
@@ -32,3 +55,67 @@ export function reportNewPrompt(options: NewPromptReportOptions): void {
     .catch(() => {})
     .finally(() => clearTimeout(timeout));
 }
+
+// In-memory metrics store (non-persistent, per-session)
+let sessionPermissionDecisions: { accept: number; reject: number } = { accept: 0, reject: 0 };
+let sessionToolUsage: ToolUsageMetrics = {
+  totalCostUSD: 0,
+  totalAPIDuration: 0,
+  totalLinesAdded: 0,
+  totalLinesRemoved: 0,
+  totalToolCalls: 0,
+};
+
+/**
+ * Record a permission decision (accept/reject for a tool).
+ * Upstream reference: code_edit_tool.decision counter
+ */
+export function recordPermissionDecision(decision: PermissionDecisionMetrics): void {
+  if (decision.decision === "accept") {
+    sessionPermissionDecisions.accept++;
+  } else {
+    sessionPermissionDecisions.reject++;
+  }
+}
+
+/**
+ * Record tool usage metrics.
+ * Upstream reference: totalToolDuration, totalCostUSD, totalLinesAdded/Removed
+ */
+export function recordToolUsage(metrics: Partial<ToolUsageMetrics>): void {
+  if (metrics.totalCostUSD !== undefined) {
+    sessionToolUsage.totalCostUSD += metrics.totalCostUSD;
+  }
+  if (metrics.totalAPIDuration !== undefined) {
+    sessionToolUsage.totalAPIDuration += metrics.totalAPIDuration;
+  }
+  if (metrics.totalLinesAdded !== undefined) {
+    sessionToolUsage.totalLinesAdded += metrics.totalLinesAdded;
+  }
+  if (metrics.totalLinesRemoved !== undefined) {
+    sessionToolUsage.totalLinesRemoved += metrics.totalLinesRemoved;
+  }
+  if (metrics.totalToolCalls !== undefined) {
+    sessionToolUsage.totalToolCalls += metrics.totalToolCalls;
+  }
+}
+
+export function getSessionPermissionDecisions(): { accept: number; reject: number } {
+  return { ...sessionPermissionDecisions };
+}
+
+export function getSessionToolUsage(): ToolUsageMetrics {
+  return { ...sessionToolUsage };
+}
+
+/** Reset all metrics (for testing or session restart) */
+export function resetSessionMetrics(): void {
+  sessionPermissionDecisions = { accept: 0, reject: 0 };
+  sessionToolUsage = {
+    totalCostUSD: 0,
+    totalAPIDuration: 0,
+    totalLinesAdded: 0,
+    totalLinesRemoved: 0,
+    totalToolCalls: 0,
+  };
+}
diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts
@@ -100,7 +100,16 @@ export { normalizeFilePath, getSnippet, clearSessionState, recordFileState, getF
 export { GitFileHistory } from "./common/file-history";
 export { killProcessTree } from "./common/process-tree";
 export { launchNotifyScript } from "./common/notify";
-export { reportNewPrompt } from "./common/telemetry";
+export {
+  reportNewPrompt,
+  recordPermissionDecision,
+  recordToolUsage,
+  getSessionPermissionDecisions,
+  getSessionToolUsage,
+  resetSessionMetrics,
+  type PermissionDecisionMetrics,
+  type ToolUsageMetrics,
+} from "./common/telemetry";
 export { DEEPSEEK_V4_MODELS, supportsMultimodal, defaultsToThinkingMode } from "./common/model-capabilities";
 export { findGitBashPath, resolveShellPath, setShellIfWindows } from "./common/shell-utils";
 export { logApiError } from "./common/error-logger";
diff --git a/packages/core/src/mcp/mcp-manager.ts b/packages/core/src/mcp/mcp-manager.ts
@@ -9,6 +9,13 @@ const MCP_CALL_TOOL_TIMEOUT_MS = 60_000;
 const API_TOOL_NAME_PATTERN = /^[a-zA-Z0-9_-]+$/;
 const API_TOOL_NAME_MAX_LENGTH = 64;
 
+// Upstream reference: --strict-mcp-config
+// When strict mode is enabled, only these commands are allowed for MCP servers.
+const MCP_STRICT_ALLOWLIST_COMMANDS = new Set([
+  "npx", "node", "python3", "python", "uvx", "uv",
+  "bun", "deno", "go", "java",
+]);
+
 type McpToolEntry = {
   serverName: string;
   originalName: string;
@@ -78,6 +85,12 @@ export class McpManager {
   private onToolsListChanged: (() => void) | null = null;
   private onStatusChanged: (() => void) | null = null;
   private serverConfigs: Record<string, McpServerConfig> = {};
+  /** Upstream reference: --strict-mcp-config flag */
+  private strictMode: boolean = false;
+
+  setStrictMode(enabled: boolean): void {
+    this.strictMode = enabled;
+  }
 
   prepare(servers?: Record<string, McpServerConfig>): void {
     if (!servers || Object.keys(servers).length === 0) return;
@@ -146,6 +159,22 @@ export class McpManager {
   private async connectServer(name: string, config: McpServerConfig): Promise<void> {
     if (this.disposed) return;
 
+    // Strict mode: validate command against allowlist
+    if (this.strictMode) {
+      const commandName = config.command.split(/[\\/]/).pop() ?? config.command;
+      if (!MCP_STRICT_ALLOWLIST_COMMANDS.has(commandName)) {
+        const msg = `Strict MCP config: command "${config.command}" is not in the allowlist. ` +
+          `Allowed commands: ${[...MCP_STRICT_ALLOWLIST_COMMANDS].join(", ")}. ` +
+          `Disable strictMcpConfig in settings.json to bypass.`;
+        this.setStatus({
+          name, status: "failed", connected: false, error: msg,
+          toolCount: 0, tools: [], promptCount: 0, prompts: [],
+          resourceCount: 0, resources: [],
+        });
+        return;
+      }
+    }
+
     // Clean up stale entries from previous connection attempts
     this.clients = this.clients.filter((c) => c.isConnected());
     this.tools = this.tools.filter((t) => t.serverName !== name);
diff --git a/packages/core/src/session.ts b/packages/core/src/session.ts
@@ -304,6 +304,7 @@ type SessionManagerOptions = {
     compressThreshold?: number;
     hooks?: HooksConfig;
     mcpServers?: Record<string, McpServerConfig>;
+    strictMcpConfig: boolean;
     permissions?: Required<PermissionSettings>;
     enabledSkills?: Record<string, boolean>;
   };
@@ -333,6 +334,7 @@ export class SessionManager {
     compressThreshold?: number;
     hooks?: HooksConfig;
     mcpServers?: Record<string, McpServerConfig>;
+    strictMcpConfig: boolean;
     permissions?: Required<PermissionSettings>;
     enabledSkills?: Record<string, boolean>;
   };
@@ -395,6 +397,7 @@ export class SessionManager {
     this.onProcessStdout = options.onProcessStdout;
     this.toolExecutor = new ToolExecutor(this.projectRoot, this.createOpenAIClient, this.mcpManager);
     this.mcpManager.prepare(this.getResolvedSettings().mcpServers);
+    this.mcpManager.setStrictMode(this.getResolvedSettings().strictMcpConfig);
     this.messageConverter = new OpenAIMessageConverter({
       renderInitPrompt: () => this.renderInitCommandPrompt(),
     });
diff --git a/packages/core/src/settings.ts b/packages/core/src/settings.ts
@@ -104,6 +104,7 @@ export type DeepcodingSettings = {
   rulesDir?: string;
   compressThreshold?: number;
   mcpServers?: Record<string, McpServerConfig>;
+  strictMcpConfig?: boolean;
   permissions?: PermissionSettings;
   enabledSkills?: EnabledSkillsSettings;
   statusline?: StatusLineSettings;
@@ -123,6 +124,7 @@ export type ResolvedDeepcodingSettings = {
   webSearchTool?: string;
   compressThreshold: number;
   mcpServers?: Record<string, McpServerConfig>;
+  strictMcpConfig: boolean;
   permissions: Required<PermissionSettings>;
   enabledSkills: EnabledSkillsSettings;
   statusline: ResolvedStatusLineSettings;
@@ -572,6 +574,7 @@ export function resolveSettingsSources(
     webSearchTool: webSearchTool || undefined,
     compressThreshold,
     mcpServers: mergeMcpServers(userSettings, projectSettings, userEnv, projectEnv, systemEnv),
+    strictMcpConfig: projectSettings?.strictMcpConfig ?? userSettings?.strictMcpConfig ?? false,
     permissions: mergePermissions(userSettings, projectSettings),
     enabledSkills: mergeEnabledSkills(userSettings, projectSettings),
     statusline: mergeStatusLine(userSettings, projectSettings),
