abortSignal: AbortSignal;

messages: Message[];

initialDescription?: string;

onDone(result: string, options?: {

display?: CommandResultDisplay;

}): void;

backgroundTasks?: {

[taskId: string]: {

type: string;

identity?: {

agentId: string;

};

messages?: Message[];

};

};

// 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;

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;

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;

});

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;

}

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>;

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;

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);

}

// 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;

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));

}

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

};

}