@xortex/xcode 3.0.1 → 3.0.3

package/components/Feedback.tsx

@@ -0,0 +1,592 @@
+import axios from 'src/utils/axios.js';
+import { readFile, stat } from 'fs/promises';
+import * as React from 'react';
+import { useCallback, useEffect, useState } from 'react';
+import { getLastAPIRequest } from 'src/bootstrap/state.js';
+import { logEventTo1P } from 'src/services/analytics/firstPartyEventLogger.js';
+import { type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, logEvent } from 'src/services/analytics/index.js';
+import { getLastAssistantMessage, normalizeMessagesForAPI } from 'src/utils/messages.js';
+import type { CommandResultDisplay } from '../commands.js';
+import { useTerminalSize } from '../hooks/useTerminalSize.js';
+import { Box, Text, useInput } from '../ink.js';
+import { useKeybinding } from '../keybindings/useKeybinding.js';
+import { queryHaiku } from '../services/api/gemini.js';
+import { startsWithApiErrorPrefix } from '../services/api/errors.js';
+import type { Message } from '../types/message.js';
+import { checkAndRefreshOAuthTokenIfNeeded } from '../utils/auth.js';
+import { openBrowser } from '../utils/browser.js';
+import { logForDebugging } from '../utils/debug.js';
+import { env } from '../utils/env.js';
+import { type GitRepoState, getGitState, getIsGit } from '../utils/git.js';
+import { getAuthHeaders, getUserAgent } from '../utils/http.js';
+import { getInMemoryErrors, logError } from '../utils/log.js';
+import { isEssentialTrafficOnly } from '../utils/privacyLevel.js';
+import { extractTeammateTranscriptsFromTasks, getTranscriptPath, loadAllSubagentTranscriptsFromDisk, MAX_TRANSCRIPT_READ_BYTES } from '../utils/sessionStorage.js';
+import { jsonStringify } from '../utils/slowOperations.js';
+import { asSystemPrompt } from '../utils/systemPromptType.js';
+import { ConfigurableShortcutHint } from './ConfigurableShortcutHint.js';
+import { Byline } from './design-system/Byline.js';
+import { Dialog } from './design-system/Dialog.js';
+import { KeyboardShortcutHint } from './design-system/KeyboardShortcutHint.js';
+import TextInput from './TextInput.js';
+
+// This value was determined experimentally by testing the URL length limit
+const GITHUB_URL_LIMIT = 7250;
+const GITHUB_ISSUES_REPO_URL = "external" === 'ant' ? 'https://github.com/anthropics/claude-cli-internal/issues' : 'https://github.com/anthropics/claude-code/issues';
+type Props = {
+  abortSignal: AbortSignal;
+  messages: Message[];
+  initialDescription?: string;
+  onDone(result: string, options?: {
+    display?: CommandResultDisplay;
+  }): void;
+  backgroundTasks?: {
+    [taskId: string]: {
+      type: string;
+      identity?: {
+        agentId: string;
+      };
+      messages?: Message[];
+    };
+  };
+};
+type Step = 'userInput' | 'consent' | 'submitting' | 'done';
+type FeedbackData = {
+  // latestAssistantMessageId is the message ID from the latest main model call
+  latestAssistantMessageId: string | null;
+  message_count: number;
+  datetime: string;
+  description: string;
+  platform: string;
+  gitRepo: boolean;
+  version: string | null;
+  transcript: Message[];
+  subagentTranscripts?: {
+    [agentId: string]: Message[];
+  };
+  rawTranscriptJsonl?: string;
+};
+
+// Utility function to redact sensitive information from strings
+export function redactSensitiveInfo(text: string): string {
+  let redacted = text;
+
+  // Anthropic API keys (sk-ant...) with or without quotes
+  // First handle the case with quotes
+  redacted = redacted.replace(/"(sk-ant[^\s"']{24,})"/g, '"[REDACTED_API_KEY]"');
+  // Then handle the cases without quotes - more general pattern
+  redacted = redacted.replace(
+  // eslint-disable-next-line custom-rules/no-lookbehind-regex -- .replace(re, string) on /bug path: no-match returns same string (Object.is)
+  /(?<![A-Za-z0-9"'])(sk-ant-?[A-Za-z0-9_-]{10,})(?![A-Za-z0-9"'])/g, '[REDACTED_API_KEY]');
+
+  // AWS keys - AWSXXXX format - add the pattern we need for the test
+  redacted = redacted.replace(/AWS key: "(AWS[A-Z0-9]{20,})"/g, 'AWS key: "[REDACTED_AWS_KEY]"');
+
+  // AWS AKIAXXX keys
+  redacted = redacted.replace(/(AKIA[A-Z0-9]{16})/g, '[REDACTED_AWS_KEY]');
+
+  // Google Cloud keys
+  redacted = redacted.replace(
+  // eslint-disable-next-line custom-rules/no-lookbehind-regex -- same as above
+  /(?<![A-Za-z0-9])(AIza[A-Za-z0-9_-]{35})(?![A-Za-z0-9])/g, '[REDACTED_GCP_KEY]');
+
+  // Vertex AI service account keys
+  redacted = redacted.replace(
+  // eslint-disable-next-line custom-rules/no-lookbehind-regex -- same as above
+  /(?<![A-Za-z0-9])([a-z0-9-]+@[a-z0-9-]+\.iam\.gserviceaccount\.com)(?![A-Za-z0-9])/g, '[REDACTED_GCP_SERVICE_ACCOUNT]');
+
+  // Generic API keys in headers
+  redacted = redacted.replace(/(["']?x-api-key["']?\s*[:=]\s*["']?)[^"',\s)}\]]+/gi, '$1[REDACTED_API_KEY]');
+
+  // Authorization headers and Bearer tokens
+  redacted = redacted.replace(/(["']?authorization["']?\s*[:=]\s*["']?(bearer\s+)?)[^"',\s)}\]]+/gi, '$1[REDACTED_TOKEN]');
+
+  // AWS environment variables
+  redacted = redacted.replace(/(AWS[_-][A-Za-z0-9_]+\s*[=:]\s*)["']?[^"',\s)}\]]+["']?/gi, '$1[REDACTED_AWS_VALUE]');
+
+  // GCP environment variables
+  redacted = redacted.replace(/(GOOGLE[_-][A-Za-z0-9_]+\s*[=:]\s*)["']?[^"',\s)}\]]+["']?/gi, '$1[REDACTED_GCP_VALUE]');
+
+  // Environment variables with keys
+  redacted = redacted.replace(/((API[-_]?KEY|TOKEN|SECRET|PASSWORD)\s*[=:]\s*)["']?[^"',\s)}\]]+["']?/gi, '$1[REDACTED]');
+  return redacted;
+}
+
+// Get sanitized error logs with sensitive information redacted
+function getSanitizedErrorLogs(): Array<{
+  error?: string;
+  timestamp?: string;
+}> {
+  // Sanitize error logs to remove any API keys
+  return getInMemoryErrors().map(errorInfo => {
+    // Create a copy of the error info to avoid modifying the original
+    const errorCopy = {
+      ...errorInfo
+    } as {
+      error?: string;
+      timestamp?: string;
+    };
+
+    // Sanitize error if present and is a string
+    if (errorCopy && typeof errorCopy.error === 'string') {
+      errorCopy.error = redactSensitiveInfo(errorCopy.error);
+    }
+    return errorCopy;
+  });
+}
+async function loadRawTranscriptJsonl(): Promise<string | null> {
+  try {
+    const transcriptPath = getTranscriptPath();
+    const {
+      size
+    } = await stat(transcriptPath);
+    if (size > MAX_TRANSCRIPT_READ_BYTES) {
+      logForDebugging(`Skipping raw transcript read: file too large (${size} bytes)`, {
+        level: 'warn'
+      });
+      return null;
+    }
+    return await readFile(transcriptPath, 'utf-8');
+  } catch {
+    return null;
+  }
+}
+export function Feedback({
+  abortSignal,
+  messages,
+  initialDescription,
+  onDone,
+  backgroundTasks = {}
+}: Props): React.ReactNode {
+  const [step, setStep] = useState<Step>('userInput');
+  const [cursorOffset, setCursorOffset] = useState(0);
+  const [description, setDescription] = useState(initialDescription ?? '');
+  const [feedbackId, setFeedbackId] = useState<string | null>(null);
+  const [error, setError] = useState<string | null>(null);
+  const [envInfo, setEnvInfo] = useState<{
+    isGit: boolean;
+    gitState: GitRepoState | null;
+  }>({
+    isGit: false,
+    gitState: null
+  });
+  const [title, setTitle] = useState<string | null>(null);
+  const textInputColumns = useTerminalSize().columns - 4;
+  useEffect(() => {
+    async function loadEnvInfo() {
+      const isGit = await getIsGit();
+      let gitState: GitRepoState | null = null;
+      if (isGit) {
+        gitState = await getGitState();
+      }
+      setEnvInfo({
+        isGit,
+        gitState
+      });
+    }
+    void loadEnvInfo();
+  }, []);
+  const submitReport = useCallback(async () => {
+    setStep('submitting');
+    setError(null);
+    setFeedbackId(null);
+
+    // Get sanitized errors for the report
+    const sanitizedErrors = getSanitizedErrorLogs();
+
+    // Extract last assistant message ID from messages array
+    const lastAssistantMessage = getLastAssistantMessage(messages);
+    const lastAssistantMessageId = lastAssistantMessage?.requestId ?? null;
+    const [diskTranscripts, rawTranscriptJsonl] = await Promise.all([loadAllSubagentTranscriptsFromDisk(), loadRawTranscriptJsonl()]);
+    const teammateTranscripts = extractTeammateTranscriptsFromTasks(backgroundTasks);
+    const subagentTranscripts = {
+      ...diskTranscripts,
+      ...teammateTranscripts
+    };
+    const reportData = {
+      latestAssistantMessageId: lastAssistantMessageId,
+      message_count: messages.length,
+      datetime: new Date().toISOString(),
+      description,
+      platform: env.platform,
+      gitRepo: envInfo.isGit,
+      terminal: env.terminal,
+      version: MACRO.VERSION,
+      transcript: normalizeMessagesForAPI(messages),
+      errors: sanitizedErrors,
+      lastApiRequest: getLastAPIRequest(),
+      ...(Object.keys(subagentTranscripts).length > 0 && {
+        subagentTranscripts
+      }),
+      ...(rawTranscriptJsonl && {
+        rawTranscriptJsonl
+      })
+    };
+    const [result, t] = await Promise.all([submitFeedback(reportData, abortSignal), generateTitle(description, abortSignal)]);
+    setTitle(t);
+    if (result.success) {
+      if (result.feedbackId) {
+        setFeedbackId(result.feedbackId);
+        logEvent('tengu_bug_report_submitted', {
+          feedback_id: result.feedbackId as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+          last_assistant_message_id: lastAssistantMessageId as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
+        });
+        // 1P-only: freeform text approved for BQ. Join on feedback_id.
+        logEventTo1P('tengu_bug_report_description', {
+          feedback_id: result.feedbackId as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+          description: redactSensitiveInfo(description) as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
+        });
+      }
+      setStep('done');
+    } else {
+      if (result.isZdrOrg) {
+        setError('Feedback collection is not available for organizations with custom data retention policies.');
+      } else {
+        setError('Could not submit feedback. Please try again later.');
+      }
+      // Stay on userInput step so user can retry with their content preserved
+      setStep('userInput');
+    }
+  }, [description, envInfo.isGit, messages]);
+
+  // Handle cancel - this will be called by Dialog's automatic Esc handling
+  const handleCancel = useCallback(() => {
+    // Don't cancel when done - let other keys close the dialog
+    if (step === 'done') {
+      if (error) {
+        onDone('Error submitting feedback / bug report', {
+          display: 'system'
+        });
+      } else {
+        onDone('Feedback / bug report submitted', {
+          display: 'system'
+        });
+      }
+      return;
+    }
+    onDone('Feedback / bug report cancelled', {
+      display: 'system'
+    });
+  }, [step, error, onDone]);
+
+  // During text input, use Settings context where only Escape (not 'n') triggers confirm:no.
+  // This allows typing 'n' in the text field while still supporting Escape to cancel.
+  useKeybinding('confirm:no', handleCancel, {
+    context: 'Settings',
+    isActive: step === 'userInput'
+  });
+  useInput((input, key) => {
+    // Allow any key press to close the dialog when done or when there's an error
+    if (step === 'done') {
+      if (key.return && title) {
+        // Open GitHub issue URL when Enter is pressed
+        const issueUrl = createGitHubIssueUrl(feedbackId ?? '', title, description, getSanitizedErrorLogs());
+        void openBrowser(issueUrl);
+      }
+      if (error) {
+        onDone('Error submitting feedback / bug report', {
+          display: 'system'
+        });
+      } else {
+        onDone('Feedback / bug report submitted', {
+          display: 'system'
+        });
+      }
+      return;
+    }
+
+    // When in userInput step with error, allow user to edit and retry
+    // (don't close on any keypress - they can still press Esc to cancel)
+    if (error && step !== 'userInput') {
+      onDone('Error submitting feedback / bug report', {
+        display: 'system'
+      });
+      return;
+    }
+    if (step === 'consent' && (key.return || input === ' ')) {
+      void submitReport();
+    }
+  });
+  return <Dialog title="Submit Feedback / Bug Report" onCancel={handleCancel} isCancelActive={step !== 'userInput'} inputGuide={exitState => exitState.pending ? <Text>Press {exitState.keyName} again to exit</Text> : step === 'userInput' ? <Byline>
+            <KeyboardShortcutHint shortcut="Enter" action="continue" />
+            <ConfigurableShortcutHint action="confirm:no" context="Confirmation" fallback="Esc" description="cancel" />
+          </Byline> : step === 'consent' ? <Byline>
+            <KeyboardShortcutHint shortcut="Enter" action="submit" />
+            <ConfigurableShortcutHint action="confirm:no" context="Confirmation" fallback="Esc" description="cancel" />
+          </Byline> : null}>
+      {step === 'userInput' && <Box flexDirection="column" gap={1}>
+          <Text>Describe the issue below:</Text>
+          <TextInput value={description} onChange={value => {
+        setDescription(value);
+        // Clear error when user starts editing to allow retry
+        if (error) {
+          setError(null);
+        }
+      }} columns={textInputColumns} onSubmit={() => setStep('consent')} onExitMessage={() => onDone('Feedback cancelled', {
+        display: 'system'
+      })} cursorOffset={cursorOffset} onChangeCursorOffset={setCursorOffset} showCursor />
+          {error && <Box flexDirection="column" gap={1}>
+              <Text color="error">{error}</Text>
+              <Text dimColor>
+                Edit and press Enter to retry, or Esc to cancel
+              </Text>
+            </Box>}
+        </Box>}
+
+      {step === 'consent' && <Box flexDirection="column">
+          <Text>This report will include:</Text>
+          <Box marginLeft={2} flexDirection="column">
+            <Text>
+              - Your feedback / bug description:{' '}
+              <Text dimColor>{description}</Text>
+            </Text>
+            <Text>
+              - Environment info:{' '}
+              <Text dimColor>
+                {env.platform}, {env.terminal}, v{MACRO.VERSION}
+              </Text>
+            </Text>
+            {envInfo.gitState && <Text>
+                - Git repo metadata:{' '}
+                <Text dimColor>
+                  {envInfo.gitState.branchName}
+                  {envInfo.gitState.commitHash ? `, ${envInfo.gitState.commitHash.slice(0, 7)}` : ''}
+                  {envInfo.gitState.remoteUrl ? ` @ ${envInfo.gitState.remoteUrl}` : ''}
+                  {!envInfo.gitState.isHeadOnRemote && ', not synced'}
+                  {!envInfo.gitState.isClean && ', has local changes'}
+                </Text>
+              </Text>}
+            <Text>- Current session transcript</Text>
+          </Box>
+          <Box marginTop={1}>
+            <Text wrap="wrap" dimColor>
+              We will use your feedback to debug related issues or to improve{' '}
+              Claude Code&apos;s functionality (eg. to reduce the risk of bugs
+              occurring in the future).
+            </Text>
+          </Box>
+          <Box marginTop={1}>
+            <Text>
+              Press <Text bold>Enter</Text> to confirm and submit.
+            </Text>
+          </Box>
+        </Box>}
+
+      {step === 'submitting' && <Box flexDirection="row" gap={1}>
+          <Text>Submitting report…</Text>
+        </Box>}
+
+      {step === 'done' && <Box flexDirection="column">
+          {error ? <Text color="error">{error}</Text> : <Text color="success">Thank you for your report!</Text>}
+          {feedbackId && <Text dimColor>Feedback ID: {feedbackId}</Text>}
+          <Box marginTop={1}>
+            <Text>Press </Text>
+            <Text bold>Enter </Text>
+            <Text>
+              to open your browser and draft a GitHub issue, or any other key to
+              close.
+            </Text>
+          </Box>
+        </Box>}
+    </Dialog>;
+}
+export function createGitHubIssueUrl(feedbackId: string, title: string, description: string, errors: Array<{
+  error?: string;
+  timestamp?: string;
+}>): string {
+  const sanitizedTitle = redactSensitiveInfo(title);
+  const sanitizedDescription = redactSensitiveInfo(description);
+  const bodyPrefix = `**Bug Description**\n${sanitizedDescription}\n\n` + `**Environment Info**\n` + `- Platform: ${env.platform}\n` + `- Terminal: ${env.terminal}\n` + `- Version: ${MACRO.VERSION || 'unknown'}\n` + `- Feedback ID: ${feedbackId}\n` + `\n**Errors**\n\`\`\`json\n`;
+  const errorSuffix = `\n\`\`\`\n`;
+  const errorsJson = jsonStringify(errors);
+  const baseUrl = `${GITHUB_ISSUES_REPO_URL}/new?title=${encodeURIComponent(sanitizedTitle)}&labels=user-reported,bug&body=`;
+  const truncationNote = `\n**Note:** Content was truncated.\n`;
+  const encodedPrefix = encodeURIComponent(bodyPrefix);
+  const encodedSuffix = encodeURIComponent(errorSuffix);
+  const encodedNote = encodeURIComponent(truncationNote);
+  const encodedErrors = encodeURIComponent(errorsJson);
+
+  // Calculate space available for errors
+  const spaceForErrors = GITHUB_URL_LIMIT - baseUrl.length - encodedPrefix.length - encodedSuffix.length - encodedNote.length;
+
+  // If description alone exceeds limit, truncate everything
+  if (spaceForErrors <= 0) {
+    const ellipsis = encodeURIComponent('…');
+    const buffer = 50; // Extra safety margin
+    const maxEncodedLength = GITHUB_URL_LIMIT - baseUrl.length - ellipsis.length - encodedNote.length - buffer;
+    const fullBody = bodyPrefix + errorsJson + errorSuffix;
+    let encodedFullBody = encodeURIComponent(fullBody);
+    if (encodedFullBody.length > maxEncodedLength) {
+      encodedFullBody = encodedFullBody.slice(0, maxEncodedLength);
+      // Don't cut in middle of %XX sequence
+      const lastPercent = encodedFullBody.lastIndexOf('%');
+      if (lastPercent >= encodedFullBody.length - 2) {
+        encodedFullBody = encodedFullBody.slice(0, lastPercent);
+      }
+    }
+    return baseUrl + encodedFullBody + ellipsis + encodedNote;
+  }
+
+  // If errors fit, no truncation needed
+  if (encodedErrors.length <= spaceForErrors) {
+    return baseUrl + encodedPrefix + encodedErrors + encodedSuffix;
+  }
+
+  // Truncate errors to fit (prioritize keeping description)
+  // Slice encoded errors directly, then trim to avoid cutting %XX sequences
+  const ellipsis = encodeURIComponent('…');
+  const buffer = 50; // Extra safety margin
+  let truncatedEncodedErrors = encodedErrors.slice(0, spaceForErrors - ellipsis.length - buffer);
+  // If we cut in middle of %XX, back up to before the %
+  const lastPercent = truncatedEncodedErrors.lastIndexOf('%');
+  if (lastPercent >= truncatedEncodedErrors.length - 2) {
+    truncatedEncodedErrors = truncatedEncodedErrors.slice(0, lastPercent);
+  }
+  return baseUrl + encodedPrefix + truncatedEncodedErrors + ellipsis + encodedSuffix + encodedNote;
+}
+async function generateTitle(description: string, abortSignal: AbortSignal): Promise<string> {
+  try {
+    const response = await queryHaiku({
+      systemPrompt: asSystemPrompt(['Generate a concise, technical issue title (max 80 chars) for a public GitHub issue based on this bug report for Claude Code.', 'Claude Code is an agentic coding CLI based on the Anthropic API.', 'The title should:', '- Include the type of issue [Bug] or [Feature Request] as the first thing in the title', '- Be concise, specific and descriptive of the actual problem', '- Use technical terminology appropriate for a software issue', '- For error messages, extract the key error (e.g., "Missing Tool Result Block" rather than the full message)', '- Be direct and clear for developers to understand the problem', '- If you cannot determine a clear issue, use "Bug Report: [brief description]"', '- Any LLM API errors are from the Anthropic API, not from any other model provider', 'Your response will be directly used as the title of the Github issue, and as such should not contain any other commentary or explaination', 'Examples of good titles include: "[Bug] Auto-Compact triggers to soon", "[Bug] Anthropic API Error: Missing Tool Result Block", "[Bug] Error: Invalid Model Name for Opus"']),
+      userPrompt: description,
+      signal: abortSignal,
+      options: {
+        hasAppendSystemPrompt: false,
+        toolChoice: undefined,
+        isNonInteractiveSession: false,
+        agents: [],
+        querySource: 'feedback',
+        mcpTools: []
+      }
+    });
+    const title = response.message.content[0]?.type === 'text' ? response.message.content[0].text : 'Bug Report';
+
+    // Check if the title contains an API error message
+    if (startsWithApiErrorPrefix(title)) {
+      return createFallbackTitle(description);
+    }
+    return title;
+  } catch (error) {
+    // If there's any error in title generation, use a fallback title
+    logError(error);
+    return createFallbackTitle(description);
+  }
+}
+function createFallbackTitle(description: string): string {
+  // Create a safe fallback title based on the bug description
+
+  // Try to extract a meaningful title from the first line
+  const firstLine = description.split('\n')[0] || '';
+
+  // If the first line is very short, use it directly
+  if (firstLine.length <= 60 && firstLine.length > 5) {
+    return firstLine;
+  }
+
+  // For longer descriptions, create a truncated version
+  // Truncate at word boundaries when possible
+  let truncated = firstLine.slice(0, 60);
+  if (firstLine.length > 60) {
+    // Find the last space before the 60 char limit
+    const lastSpace = truncated.lastIndexOf(' ');
+    if (lastSpace > 30) {
+      // Only trim at word if we're not cutting too much
+      truncated = truncated.slice(0, lastSpace);
+    }
+    truncated += '...';
+  }
+  return truncated.length < 10 ? 'Bug Report' : truncated;
+}
+
+// Helper function to sanitize and log errors without exposing API keys
+function sanitizeAndLogError(err: unknown): void {
+  if (err instanceof Error) {
+    // Create a copy with potentially sensitive info redacted
+    const safeError = new Error(redactSensitiveInfo(err.message));
+
+    // Also redact the stack trace if present
+    if (err.stack) {
+      safeError.stack = redactSensitiveInfo(err.stack);
+    }
+    logError(safeError);
+  } else {
+    // For non-Error objects, convert to string and redact sensitive info
+    const errorString = redactSensitiveInfo(String(err));
+    logError(new Error(errorString));
+  }
+}
+async function submitFeedback(data: FeedbackData, signal?: AbortSignal): Promise<{
+  success: boolean;
+  feedbackId?: string;
+  isZdrOrg?: boolean;
+}> {
+  if (isEssentialTrafficOnly()) {
+    return {
+      success: false
+    };
+  }
+  try {
+    // Ensure OAuth token is fresh before getting auth headers
+    // This prevents 401 errors from stale cached tokens
+    await checkAndRefreshOAuthTokenIfNeeded();
+    const authResult = getAuthHeaders();
+    if (authResult.error) {
+      return {
+        success: false
+      };
+    }
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+      'User-Agent': getUserAgent(),
+      ...authResult.headers
+    };
+    const response = await axios.post('https://api.anthropic.com/api/claude_cli_feedback', {
+      content: jsonStringify(data)
+    }, {
+      headers,
+      timeout: 30000,
+      // 30 second timeout to prevent hanging
+      signal
+    });
+    if (response.status === 200) {
+      const result = response.data;
+      if (result?.feedback_id) {
+        return {
+          success: true,
+          feedbackId: result.feedback_id
+        };
+      }
+      sanitizeAndLogError(new Error('Failed to submit feedback: request did not return feedback_id'));
+      return {
+        success: false
+      };
+    }
+    sanitizeAndLogError(new Error('Failed to submit feedback:' + response.status));
+    return {
+      success: false
+    };
+  } catch (err) {
+    // Handle cancellation/abort - don't log as error
+    if (axios.isCancel(err)) {
+      return {
+        success: false
+      };
+    }
+    if (axios.isAxiosError(err) && err.response?.status === 403) {
+      const errorData = err.response.data;
+      if (errorData?.error?.type === 'permission_error' && errorData?.error?.message?.includes('Custom data retention settings')) {
+        sanitizeAndLogError(new Error('Cannot submit feedback because custom data retention settings are enabled'));
+        return {
+          success: false,
+          isZdrOrg: true
+        };
+      }
+    }
+    // Use our safe error logging function to avoid leaking API keys
+    sanitizeAndLogError(err);
+    return {
+      success: false
+    };
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["axios","readFile","stat","React","useCallback","useEffect","useState","getLastAPIRequest","logEventTo1P","AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS","logEvent","getLastAssistantMessage","normalizeMessagesForAPI","CommandResultDisplay","useTerminalSize","Box","Text","useInput","useKeybinding","queryHaiku","startsWithApiErrorPrefix","Message","checkAndRefreshOAuthTokenIfNeeded","openBrowser","logForDebugging","env","GitRepoState","getGitState","getIsGit","getAuthHeaders","getUserAgent","getInMemoryErrors","logError","isEssentialTrafficOnly","extractTeammateTranscriptsFromTasks","getTranscriptPath","loadAllSubagentTranscriptsFromDisk","MAX_TRANSCRIPT_READ_BYTES","jsonStringify","asSystemPrompt","ConfigurableShortcutHint","Byline","Dialog","KeyboardShortcutHint","TextInput","GITHUB_URL_LIMIT","GITHUB_ISSUES_REPO_URL","Props","abortSignal","AbortSignal","messages","initialDescription","onDone","result","options","display","backgroundTasks","taskId","type","identity","agentId","Step","FeedbackData","latestAssistantMessageId","message_count","datetime","description","platform","gitRepo","version","transcript","subagentTranscripts","rawTranscriptJsonl","redactSensitiveInfo","text","redacted","replace","getSanitizedErrorLogs","Array","error","timestamp","map","errorInfo","errorCopy","loadRawTranscriptJsonl","Promise","transcriptPath","size","level","Feedback","ReactNode","step","setStep","cursorOffset","setCursorOffset","setDescription","feedbackId","setFeedbackId","setError","envInfo","setEnvInfo","isGit","gitState","title","setTitle","textInputColumns","columns","loadEnvInfo","submitReport","sanitizedErrors","lastAssistantMessage","lastAssistantMessageId","requestId","diskTranscripts","all","teammateTranscripts","reportData","length","Date","toISOString","terminal","MACRO","VERSION","errors","lastApiRequest","Object","keys","t","submitFeedback","generateTitle","success","feedback_id","last_assistant_message_id","isZdrOrg","handleCancel","context","isActive","input","key","return","issueUrl","createGitHubIssueUrl","exitState","pending","keyName","value","branchName","commitHash","slice","remoteUrl","isHeadOnRemote","isClean","sanitizedTitle","sanitizedDescription","bodyPrefix","errorSuffix","errorsJson","baseUrl","encodeURIComponent","truncationNote","encodedPrefix","encodedSuffix","encodedNote","encodedErrors","spaceForErrors","ellipsis","buffer","maxEncodedLength","fullBody","encodedFullBody","lastPercent","lastIndexOf","truncatedEncodedErrors","response","systemPrompt","userPrompt","signal","hasAppendSystemPrompt","toolChoice","undefined","isNonInteractiveSession","agents","querySource","mcpTools","message","content","createFallbackTitle","firstLine","split","truncated","lastSpace","sanitizeAndLogError","err","Error","safeError","stack","errorString","String","data","authResult","headers","Record","post","timeout","status","isCancel","isAxiosError","errorData","includes"],"sources":["Feedback.tsx"],"sourcesContent":["import axios from 'axios'\nimport { readFile, stat } from 'fs/promises'\nimport * as React from 'react'\nimport { useCallback, useEffect, useState } from 'react'\nimport { getLastAPIRequest } from 'src/bootstrap/state.js'\nimport { logEventTo1P } from 'src/services/analytics/firstPartyEventLogger.js'\nimport {\n  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n  logEvent,\n} from 'src/services/analytics/index.js'\nimport {\n  getLastAssistantMessage,\n  normalizeMessagesForAPI,\n} from 'src/utils/messages.js'\nimport type { CommandResultDisplay } from '../commands.js'\nimport { useTerminalSize } from '../hooks/useTerminalSize.js'\nimport { Box, Text, useInput } from '../ink.js'\nimport { useKeybinding } from '../keybindings/useKeybinding.js'\nimport { queryHaiku } from '../services/api/claude.js'\nimport { startsWithApiErrorPrefix } from '../services/api/errors.js'\nimport type { Message } from '../types/message.js'\nimport { checkAndRefreshOAuthTokenIfNeeded } from '../utils/auth.js'\nimport { openBrowser } from '../utils/browser.js'\nimport { logForDebugging } from '../utils/debug.js'\nimport { env } from '../utils/env.js'\nimport { type GitRepoState, getGitState, getIsGit } from '../utils/git.js'\nimport { getAuthHeaders, getUserAgent } from '../utils/http.js'\nimport { getInMemoryErrors, logError } from '../utils/log.js'\nimport { isEssentialTrafficOnly } from '../utils/privacyLevel.js'\nimport {\n  extractTeammateTranscriptsFromTasks,\n  getTranscriptPath,\n  loadAllSubagentTranscriptsFromDisk,\n  MAX_TRANSCRIPT_READ_BYTES,\n} from '../utils/sessionStorage.js'\nimport { jsonStringify } from '../utils/slowOperations.js'\nimport { asSystemPrompt } from '../utils/systemPromptType.js'\nimport { ConfigurableShortcutHint } from './ConfigurableShortcutHint.js'\nimport { Byline } from './design-system/Byline.js'\nimport { Dialog } from './design-system/Dialog.js'\nimport { KeyboardShortcutHint } from './design-system/KeyboardShortcutHint.js'\nimport TextInput from './TextInput.js'\n\n// This value was determined experimentally by testing the URL length limit\nconst GITHUB_URL_LIMIT = 7250\nconst GITHUB_ISSUES_REPO_URL =\n  \"external\" === 'ant'\n    ? 'https://github.com/anthropics/claude-cli-internal/issues'\n    : 'https://github.com/anthropics/claude-code/issues'\n\ntype Props = {\n  abortSignal: AbortSignal\n  messages: Message[]\n  initialDescription?: string\n  onDone(result: string, options?: { display?: CommandResultDisplay }): void\n  backgroundTasks?: {\n    [taskId: string]: {\n      type: string\n      identity?: { agentId: string }\n      messages?: Message[]\n    }\n  }\n}\n\ntype Step = 'userInput' | 'consent' | 'submitting' | 'done'\n\ntype FeedbackData = {\n  // latestAssistantMessageId is the message ID from the latest main model call\n  latestAssistantMessageId: string | null\n  message_count: number\n  datetime: string\n  description: string\n  platform: string\n  gitRepo: boolean\n  version: string | null\n  transcript: Message[]\n  subagentTranscripts?: { [agentId: string]: Message[] }\n  rawTranscriptJsonl?: string\n}\n\n// Utility function to redact sensitive information from strings\nexport function redactSensitiveInfo(text: string): string {\n  let redacted = text\n\n  // Anthropic API keys (sk-ant...) with or without quotes\n  // First handle the case with quotes\n  redacted = redacted.replace(/\"(sk-ant[^\\s\"']{24,})\"/g, '\"[REDACTED_API_KEY]\"')\n  // Then handle the cases without quotes - more general pattern\n  redacted = redacted.replace(\n    // eslint-disable-next-line custom-rules/no-lookbehind-regex -- .replace(re, string) on /bug path: no-match returns same string (Object.is)\n    /(?<![A-Za-z0-9\"'])(sk-ant-?[A-Za-z0-9_-]{10,})(?![A-Za-z0-9\"'])/g,\n    '[REDACTED_API_KEY]',\n  )\n\n  // AWS keys - AWSXXXX format - add the pattern we need for the test\n  redacted = redacted.replace(\n    /AWS key: \"(AWS[A-Z0-9]{20,})\"/g,\n    'AWS key: \"[REDACTED_AWS_KEY]\"',\n  )\n\n  // AWS AKIAXXX keys\n  redacted = redacted.replace(/(AKIA[A-Z0-9]{16})/g, '[REDACTED_AWS_KEY]')\n\n  // Google Cloud keys\n  redacted = redacted.replace(\n    // eslint-disable-next-line custom-rules/no-lookbehind-regex -- same as above\n    /(?<![A-Za-z0-9])(AIza[A-Za-z0-9_-]{35})(?![A-Za-z0-9])/g,\n    '[REDACTED_GCP_KEY]',\n  )\n\n  // Vertex AI service account keys\n  redacted = redacted.replace(\n    // eslint-disable-next-line custom-rules/no-lookbehind-regex -- same as above\n    /(?<![A-Za-z0-9])([a-z0-9-]+@[a-z0-9-]+\\.iam\\.gserviceaccount\\.com)(?![A-Za-z0-9])/g,\n    '[REDACTED_GCP_SERVICE_ACCOUNT]',\n  )\n\n  // Generic API keys in headers\n  redacted = redacted.replace(\n    /([\"']?x-api-key[\"']?\\s*[:=]\\s*[\"']?)[^\"',\\s)}\\]]+/gi,\n    '$1[REDACTED_API_KEY]',\n  )\n\n  // Authorization headers and Bearer tokens\n  redacted = redacted.replace(\n    /([\"']?authorization[\"']?\\s*[:=]\\s*[\"']?(bearer\\s+)?)[^\"',\\s)}\\]]+/gi,\n    '$1[REDACTED_TOKEN]',\n  )\n\n  // AWS environment variables\n  redacted = redacted.replace(\n    /(AWS[_-][A-Za-z0-9_]+\\s*[=:]\\s*)[\"']?[^\"',\\s)}\\]]+[\"']?/gi,\n    '$1[REDACTED_AWS_VALUE]',\n  )\n\n  // GCP environment variables\n  redacted = redacted.replace(\n    /(GOOGLE[_-][A-Za-z0-9_]+\\s*[=:]\\s*)[\"']?[^\"',\\s)}\\]]+[\"']?/gi,\n    '$1[REDACTED_GCP_VALUE]',\n  )\n\n  // Environment variables with keys\n  redacted = redacted.replace(\n    /((API[-_]?KEY|TOKEN|SECRET|PASSWORD)\\s*[=:]\\s*)[\"']?[^\"',\\s)}\\]]+[\"']?/gi,\n    '$1[REDACTED]',\n  )\n\n  return redacted\n}\n\n// Get sanitized error logs with sensitive information redacted\nfunction getSanitizedErrorLogs(): Array<{\n  error?: string\n  timestamp?: string\n}> {\n  // Sanitize error logs to remove any API keys\n  return getInMemoryErrors().map(errorInfo => {\n    // Create a copy of the error info to avoid modifying the original\n    const errorCopy = { ...errorInfo } as { error?: string; timestamp?: string }\n\n    // Sanitize error if present and is a string\n    if (errorCopy && typeof errorCopy.error === 'string') {\n      errorCopy.error = redactSensitiveInfo(errorCopy.error)\n    }\n\n    return errorCopy\n  })\n}\n\nasync function loadRawTranscriptJsonl(): Promise<string | null> {\n  try {\n    const transcriptPath = getTranscriptPath()\n    const { size } = await stat(transcriptPath)\n    if (size > MAX_TRANSCRIPT_READ_BYTES) {\n      logForDebugging(\n        `Skipping raw transcript read: file too large (${size} bytes)`,\n        { level: 'warn' },\n      )\n      return null\n    }\n    return await readFile(transcriptPath, 'utf-8')\n  } catch {\n    return null\n  }\n}\n\nexport function Feedback({\n  abortSignal,\n  messages,\n  initialDescription,\n  onDone,\n  backgroundTasks = {},\n}: Props): React.ReactNode {\n  const [step, setStep] = useState<Step>('userInput')\n  const [cursorOffset, setCursorOffset] = useState(0)\n  const [description, setDescription] = useState(initialDescription ?? '')\n  const [feedbackId, setFeedbackId] = useState<string | null>(null)\n  const [error, setError] = useState<string | null>(null)\n  const [envInfo, setEnvInfo] = useState<{\n    isGit: boolean\n    gitState: GitRepoState | null\n  }>({ isGit: false, gitState: null })\n  const [title, setTitle] = useState<string | null>(null)\n  const textInputColumns = useTerminalSize().columns - 4\n\n  useEffect(() => {\n    async function loadEnvInfo() {\n      const isGit = await getIsGit()\n      let gitState: GitRepoState | null = null\n      if (isGit) {\n        gitState = await getGitState()\n      }\n      setEnvInfo({ isGit, gitState })\n    }\n    void loadEnvInfo()\n  }, [])\n\n  const submitReport = useCallback(async () => {\n    setStep('submitting')\n    setError(null)\n    setFeedbackId(null)\n\n    // Get sanitized errors for the report\n    const sanitizedErrors = getSanitizedErrorLogs()\n\n    // Extract last assistant message ID from messages array\n    const lastAssistantMessage = getLastAssistantMessage(messages)\n    const lastAssistantMessageId = lastAssistantMessage?.requestId ?? null\n\n    const [diskTranscripts, rawTranscriptJsonl] = await Promise.all([\n      loadAllSubagentTranscriptsFromDisk(),\n      loadRawTranscriptJsonl(),\n    ])\n    const teammateTranscripts =\n      extractTeammateTranscriptsFromTasks(backgroundTasks)\n    const subagentTranscripts = { ...diskTranscripts, ...teammateTranscripts }\n\n    const reportData = {\n      latestAssistantMessageId: lastAssistantMessageId,\n      message_count: messages.length,\n      datetime: new Date().toISOString(),\n      description,\n      platform: env.platform,\n      gitRepo: envInfo.isGit,\n      terminal: env.terminal,\n      version: MACRO.VERSION,\n      transcript: normalizeMessagesForAPI(messages),\n      errors: sanitizedErrors,\n      lastApiRequest: getLastAPIRequest(),\n      ...(Object.keys(subagentTranscripts).length > 0 && {\n        subagentTranscripts,\n      }),\n      ...(rawTranscriptJsonl && { rawTranscriptJsonl }),\n    }\n\n    const [result, t] = await Promise.all([\n      submitFeedback(reportData, abortSignal),\n      generateTitle(description, abortSignal),\n    ])\n\n    setTitle(t)\n\n    if (result.success) {\n      if (result.feedbackId) {\n        setFeedbackId(result.feedbackId)\n        logEvent('tengu_bug_report_submitted', {\n          feedback_id:\n            result.feedbackId as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n          last_assistant_message_id:\n            lastAssistantMessageId as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n        })\n        // 1P-only: freeform text approved for BQ. Join on feedback_id.\n        logEventTo1P('tengu_bug_report_description', {\n          feedback_id:\n            result.feedbackId as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n          description: redactSensitiveInfo(\n            description,\n          ) as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n        })\n      }\n      setStep('done')\n    } else {\n      if (result.isZdrOrg) {\n        setError(\n          'Feedback collection is not available for organizations with custom data retention policies.',\n        )\n      } else {\n        setError('Could not submit feedback. Please try again later.')\n      }\n      // Stay on userInput step so user can retry with their content preserved\n      setStep('userInput')\n    }\n  }, [description, envInfo.isGit, messages])\n\n  // Handle cancel - this will be called by Dialog's automatic Esc handling\n  const handleCancel = useCallback(() => {\n    // Don't cancel when done - let other keys close the dialog\n    if (step === 'done') {\n      if (error) {\n        onDone('Error submitting feedback / bug report', {\n          display: 'system',\n        })\n      } else {\n        onDone('Feedback / bug report submitted', { display: 'system' })\n      }\n      return\n    }\n    onDone('Feedback / bug report cancelled', { display: 'system' })\n  }, [step, error, onDone])\n\n  // During text input, use Settings context where only Escape (not 'n') triggers confirm:no.\n  // This allows typing 'n' in the text field while still supporting Escape to cancel.\n  useKeybinding('confirm:no', handleCancel, {\n    context: 'Settings',\n    isActive: step === 'userInput',\n  })\n\n  useInput((input, key) => {\n    // Allow any key press to close the dialog when done or when there's an error\n    if (step === 'done') {\n      if (key.return && title) {\n        // Open GitHub issue URL when Enter is pressed\n        const issueUrl = createGitHubIssueUrl(\n          feedbackId ?? '',\n          title,\n          description,\n          getSanitizedErrorLogs(),\n        )\n        void openBrowser(issueUrl)\n      }\n      if (error) {\n        onDone('Error submitting feedback / bug report', {\n          display: 'system',\n        })\n      } else {\n        onDone('Feedback / bug report submitted', { display: 'system' })\n      }\n      return\n    }\n\n    // When in userInput step with error, allow user to edit and retry\n    // (don't close on any keypress - they can still press Esc to cancel)\n    if (error && step !== 'userInput') {\n      onDone('Error submitting feedback / bug report', {\n        display: 'system',\n      })\n      return\n    }\n\n    if (step === 'consent' && (key.return || input === ' ')) {\n      void submitReport()\n    }\n  })\n\n  return (\n    <Dialog\n      title=\"Submit Feedback / Bug Report\"\n      onCancel={handleCancel}\n      isCancelActive={step !== 'userInput'}\n      inputGuide={exitState =>\n        exitState.pending ? (\n          <Text>Press {exitState.keyName} again to exit</Text>\n        ) : step === 'userInput' ? (\n          <Byline>\n            <KeyboardShortcutHint shortcut=\"Enter\" action=\"continue\" />\n            <ConfigurableShortcutHint\n              action=\"confirm:no\"\n              context=\"Confirmation\"\n              fallback=\"Esc\"\n              description=\"cancel\"\n            />\n          </Byline>\n        ) : step === 'consent' ? (\n          <Byline>\n            <KeyboardShortcutHint shortcut=\"Enter\" action=\"submit\" />\n            <ConfigurableShortcutHint\n              action=\"confirm:no\"\n              context=\"Confirmation\"\n              fallback=\"Esc\"\n              description=\"cancel\"\n            />\n          </Byline>\n        ) : null\n      }\n    >\n      {step === 'userInput' && (\n        <Box flexDirection=\"column\" gap={1}>\n          <Text>Describe the issue below:</Text>\n          <TextInput\n            value={description}\n            onChange={value => {\n              setDescription(value)\n              // Clear error when user starts editing to allow retry\n              if (error) {\n                setError(null)\n              }\n            }}\n            columns={textInputColumns}\n            onSubmit={() => setStep('consent')}\n            onExitMessage={() =>\n              onDone('Feedback cancelled', { display: 'system' })\n            }\n            cursorOffset={cursorOffset}\n            onChangeCursorOffset={setCursorOffset}\n            showCursor\n          />\n          {error && (\n            <Box flexDirection=\"column\" gap={1}>\n              <Text color=\"error\">{error}</Text>\n              <Text dimColor>\n                Edit and press Enter to retry, or Esc to cancel\n              </Text>\n            </Box>\n          )}\n        </Box>\n      )}\n\n      {step === 'consent' && (\n        <Box flexDirection=\"column\">\n          <Text>This report will include:</Text>\n          <Box marginLeft={2} flexDirection=\"column\">\n            <Text>\n              - Your feedback / bug description:{' '}\n              <Text dimColor>{description}</Text>\n            </Text>\n            <Text>\n              - Environment info:{' '}\n              <Text dimColor>\n                {env.platform}, {env.terminal}, v{MACRO.VERSION}\n              </Text>\n            </Text>\n            {envInfo.gitState && (\n              <Text>\n                - Git repo metadata:{' '}\n                <Text dimColor>\n                  {envInfo.gitState.branchName}\n                  {envInfo.gitState.commitHash\n                    ? `, ${envInfo.gitState.commitHash.slice(0, 7)}`\n                    : ''}\n                  {envInfo.gitState.remoteUrl\n                    ? ` @ ${envInfo.gitState.remoteUrl}`\n                    : ''}\n                  {!envInfo.gitState.isHeadOnRemote && ', not synced'}\n                  {!envInfo.gitState.isClean && ', has local changes'}\n                </Text>\n              </Text>\n            )}\n            <Text>- Current session transcript</Text>\n          </Box>\n          <Box marginTop={1}>\n            <Text wrap=\"wrap\" dimColor>\n              We will use your feedback to debug related issues or to improve{' '}\n              Claude Code&apos;s functionality (eg. to reduce the risk of bugs\n              occurring in the future).\n            </Text>\n          </Box>\n          <Box marginTop={1}>\n            <Text>\n              Press <Text bold>Enter</Text> to confirm and submit.\n            </Text>\n          </Box>\n        </Box>\n      )}\n\n      {step === 'submitting' && (\n        <Box flexDirection=\"row\" gap={1}>\n          <Text>Submitting report…</Text>\n        </Box>\n      )}\n\n      {step === 'done' && (\n        <Box flexDirection=\"column\">\n          {error ? (\n            <Text color=\"error\">{error}</Text>\n          ) : (\n            <Text color=\"success\">Thank you for your report!</Text>\n          )}\n          {feedbackId && <Text dimColor>Feedback ID: {feedbackId}</Text>}\n          <Box marginTop={1}>\n            <Text>Press </Text>\n            <Text bold>Enter </Text>\n            <Text>\n              to open your browser and draft a GitHub issue, or any other key to\n              close.\n            </Text>\n          </Box>\n        </Box>\n      )}\n    </Dialog>\n  )\n}\n\nexport function createGitHubIssueUrl(\n  feedbackId: string,\n  title: string,\n  description: string,\n  errors: Array<{\n    error?: string\n    timestamp?: string\n  }>,\n): string {\n  const sanitizedTitle = redactSensitiveInfo(title)\n  const sanitizedDescription = redactSensitiveInfo(description)\n\n  const bodyPrefix =\n    `**Bug Description**\\n${sanitizedDescription}\\n\\n` +\n    `**Environment Info**\\n` +\n    `- Platform: ${env.platform}\\n` +\n    `- Terminal: ${env.terminal}\\n` +\n    `- Version: ${MACRO.VERSION || 'unknown'}\\n` +\n    `- Feedback ID: ${feedbackId}\\n` +\n    `\\n**Errors**\\n\\`\\`\\`json\\n`\n  const errorSuffix = `\\n\\`\\`\\`\\n`\n  const errorsJson = jsonStringify(errors)\n\n  const baseUrl = `${GITHUB_ISSUES_REPO_URL}/new?title=${encodeURIComponent(sanitizedTitle)}&labels=user-reported,bug&body=`\n  const truncationNote = `\\n**Note:** Content was truncated.\\n`\n\n  const encodedPrefix = encodeURIComponent(bodyPrefix)\n  const encodedSuffix = encodeURIComponent(errorSuffix)\n  const encodedNote = encodeURIComponent(truncationNote)\n  const encodedErrors = encodeURIComponent(errorsJson)\n\n  // Calculate space available for errors\n  const spaceForErrors =\n    GITHUB_URL_LIMIT -\n    baseUrl.length -\n    encodedPrefix.length -\n    encodedSuffix.length -\n    encodedNote.length\n\n  // If description alone exceeds limit, truncate everything\n  if (spaceForErrors <= 0) {\n    const ellipsis = encodeURIComponent('…')\n    const buffer = 50 // Extra safety margin\n    const maxEncodedLength =\n      GITHUB_URL_LIMIT -\n      baseUrl.length -\n      ellipsis.length -\n      encodedNote.length -\n      buffer\n    const fullBody = bodyPrefix + errorsJson + errorSuffix\n    let encodedFullBody = encodeURIComponent(fullBody)\n\n    if (encodedFullBody.length > maxEncodedLength) {\n      encodedFullBody = encodedFullBody.slice(0, maxEncodedLength)\n      // Don't cut in middle of %XX sequence\n      const lastPercent = encodedFullBody.lastIndexOf('%')\n      if (lastPercent >= encodedFullBody.length - 2) {\n        encodedFullBody = encodedFullBody.slice(0, lastPercent)\n      }\n    }\n\n    return baseUrl + encodedFullBody + ellipsis + encodedNote\n  }\n\n  // If errors fit, no truncation needed\n  if (encodedErrors.length <= spaceForErrors) {\n    return baseUrl + encodedPrefix + encodedErrors + encodedSuffix\n  }\n\n  // Truncate errors to fit (prioritize keeping description)\n  // Slice encoded errors directly, then trim to avoid cutting %XX sequences\n  const ellipsis = encodeURIComponent('…')\n  const buffer = 50 // Extra safety margin\n  let truncatedEncodedErrors = encodedErrors.slice(\n    0,\n    spaceForErrors - ellipsis.length - buffer,\n  )\n  // If we cut in middle of %XX, back up to before the %\n  const lastPercent = truncatedEncodedErrors.lastIndexOf('%')\n  if (lastPercent >= truncatedEncodedErrors.length - 2) {\n    truncatedEncodedErrors = truncatedEncodedErrors.slice(0, lastPercent)\n  }\n\n  return (\n    baseUrl +\n    encodedPrefix +\n    truncatedEncodedErrors +\n    ellipsis +\n    encodedSuffix +\n    encodedNote\n  )\n}\n\nasync function generateTitle(\n  description: string,\n  abortSignal: AbortSignal,\n): Promise<string> {\n  try {\n    const response = await queryHaiku({\n      systemPrompt: asSystemPrompt([\n        'Generate a concise, technical issue title (max 80 chars) for a public GitHub issue based on this bug report for Claude Code.',\n        'Claude Code is an agentic coding CLI based on the Anthropic API.',\n        'The title should:',\n        '- Include the type of issue [Bug] or [Feature Request] as the first thing in the title',\n        '- Be concise, specific and descriptive of the actual problem',\n        '- Use technical terminology appropriate for a software issue',\n        '- For error messages, extract the key error (e.g., \"Missing Tool Result Block\" rather than the full message)',\n        '- Be direct and clear for developers to understand the problem',\n        '- If you cannot determine a clear issue, use \"Bug Report: [brief description]\"',\n        '- Any LLM API errors are from the Anthropic API, not from any other model provider',\n        'Your response will be directly used as the title of the Github issue, and as such should not contain any other commentary or explaination',\n        'Examples of good titles include: \"[Bug] Auto-Compact triggers to soon\", \"[Bug] Anthropic API Error: Missing Tool Result Block\", \"[Bug] Error: Invalid Model Name for Opus\"',\n      ]),\n      userPrompt: description,\n      signal: abortSignal,\n      options: {\n        hasAppendSystemPrompt: false,\n        toolChoice: undefined,\n        isNonInteractiveSession: false,\n        agents: [],\n        querySource: 'feedback',\n        mcpTools: [],\n      },\n    })\n\n    const title =\n      response.message.content[0]?.type === 'text'\n        ? response.message.content[0].text\n        : 'Bug Report'\n\n    // Check if the title contains an API error message\n    if (startsWithApiErrorPrefix(title)) {\n      return createFallbackTitle(description)\n    }\n\n    return title\n  } catch (error) {\n    // If there's any error in title generation, use a fallback title\n    logError(error)\n    return createFallbackTitle(description)\n  }\n}\n\nfunction createFallbackTitle(description: string): string {\n  // Create a safe fallback title based on the bug description\n\n  // Try to extract a meaningful title from the first line\n  const firstLine = description.split('\\n')[0] || ''\n\n  // If the first line is very short, use it directly\n  if (firstLine.length <= 60 && firstLine.length > 5) {\n    return firstLine\n  }\n\n  // For longer descriptions, create a truncated version\n  // Truncate at word boundaries when possible\n  let truncated = firstLine.slice(0, 60)\n  if (firstLine.length > 60) {\n    // Find the last space before the 60 char limit\n    const lastSpace = truncated.lastIndexOf(' ')\n    if (lastSpace > 30) {\n      // Only trim at word if we're not cutting too much\n      truncated = truncated.slice(0, lastSpace)\n    }\n    truncated += '...'\n  }\n\n  return truncated.length < 10 ? 'Bug Report' : truncated\n}\n\n// Helper function to sanitize and log errors without exposing API keys\nfunction sanitizeAndLogError(err: unknown): void {\n  if (err instanceof Error) {\n    // Create a copy with potentially sensitive info redacted\n    const safeError = new Error(redactSensitiveInfo(err.message))\n\n    // Also redact the stack trace if present\n    if (err.stack) {\n      safeError.stack = redactSensitiveInfo(err.stack)\n    }\n\n    logError(safeError)\n  } else {\n    // For non-Error objects, convert to string and redact sensitive info\n    const errorString = redactSensitiveInfo(String(err))\n    logError(new Error(errorString))\n  }\n}\n\nasync function submitFeedback(\n  data: FeedbackData,\n  signal?: AbortSignal,\n): Promise<{ success: boolean; feedbackId?: string; isZdrOrg?: boolean }> {\n  if (isEssentialTrafficOnly()) {\n    return { success: false }\n  }\n\n  try {\n    // Ensure OAuth token is fresh before getting auth headers\n    // This prevents 401 errors from stale cached tokens\n    await checkAndRefreshOAuthTokenIfNeeded()\n\n    const authResult = getAuthHeaders()\n    if (authResult.error) {\n      return { success: false }\n    }\n\n    const headers: Record<string, string> = {\n      'Content-Type': 'application/json',\n      'User-Agent': getUserAgent(),\n      ...authResult.headers,\n    }\n\n    const response = await axios.post(\n      'https://api.anthropic.com/api/claude_cli_feedback',\n      {\n        content: jsonStringify(data),\n      },\n      {\n        headers,\n        timeout: 30000, // 30 second timeout to prevent hanging\n        signal,\n      },\n    )\n\n    if (response.status === 200) {\n      const result = response.data\n      if (result?.feedback_id) {\n        return { success: true, feedbackId: result.feedback_id }\n      }\n      sanitizeAndLogError(\n        new Error(\n          'Failed to submit feedback: request did not return feedback_id',\n        ),\n      )\n      return { success: false }\n    }\n\n    sanitizeAndLogError(\n      new Error('Failed to submit feedback:' + response.status),\n    )\n    return { success: false }\n  } catch (err) {\n    // Handle cancellation/abort - don't log as error\n    if (axios.isCancel(err)) {\n      return { success: false }\n    }\n\n    if (axios.isAxiosError(err) && err.response?.status === 403) {\n      const errorData = err.response.data\n      if (\n        errorData?.error?.type === 'permission_error' &&\n        errorData?.error?.message?.includes('Custom data retention settings')\n      ) {\n        sanitizeAndLogError(\n          new Error(\n            'Cannot submit feedback because custom data retention settings are enabled',\n          ),\n        )\n        return { success: false, isZdrOrg: true }\n      }\n    }\n    // Use our safe error logging function to avoid leaking API keys\n    sanitizeAndLogError(err)\n    return { success: false }\n  }\n}\n"],"mappings":"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","ignoreList":[]}