904 lines
33 KiB
TypeScript
904 lines
33 KiB
TypeScript
import { describe, expect, it } from 'vitest';
|
||
import {
|
||
formatVisibleChatTranscript,
|
||
getToolVisibilityId,
|
||
} from '@/pages/Chat/chat-transcript';
|
||
import { mergeChatCommandCatalog } from '@/pages/Chat/chat-command-registry';
|
||
import type { RawMessage } from '@/types/chat';
|
||
|
||
const messages: RawMessage[] = [
|
||
{
|
||
id: 'user-1',
|
||
role: 'user',
|
||
timestamp: Date.UTC(2026, 6, 18, 8, 0, 0),
|
||
content: [
|
||
{ type: 'text', text: 'Inspect the attachment.' },
|
||
{ type: 'image', mimeType: 'image/png', data: 'VERY_SECRET_BASE64' },
|
||
],
|
||
_attachedFiles: [
|
||
{
|
||
fileName: 'diagram.png',
|
||
mimeType: 'image/png',
|
||
fileSize: 10,
|
||
preview: 'data:image/png;base64,ALSO_SECRET',
|
||
filePath: 'C:\\Users\\alice\\secret\\diagram.png',
|
||
runtimeUrl: 'http://127.0.0.1:43123/api/files?path=C%3A%5CUsers%5Calice%5Csecret%5Cdiagram.png',
|
||
},
|
||
],
|
||
},
|
||
{
|
||
id: 'assistant-1',
|
||
role: 'assistant',
|
||
content: [
|
||
{ type: 'thinking', thinking: 'Private chain fragment' },
|
||
{
|
||
type: 'tool_use',
|
||
id: 'tool-1',
|
||
name: 'read',
|
||
input: {
|
||
path: '/Users/alice/private/notes.txt',
|
||
screenshot: 'data:image/png;base64,TOOL_SECRET',
|
||
rawBytes: 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
|
||
},
|
||
},
|
||
{ type: 'text', text: 'Finished.' },
|
||
],
|
||
},
|
||
];
|
||
|
||
describe('formatVisibleChatTranscript', () => {
|
||
it('writes binary placeholders and never emits data, base64, loopback URLs, or absolute paths', () => {
|
||
const markdown = formatVisibleChatTranscript(messages, {
|
||
showThinking: true,
|
||
showTimestamps: true,
|
||
expandedToolIds: new Set([getToolVisibilityId('assistant-1', 'tool-1', 0)]),
|
||
});
|
||
|
||
expect(markdown).toContain('[Attached image/png: diagram.png]');
|
||
expect(markdown).toContain('[Attached image/png: attachment]');
|
||
expect(markdown).toContain('Private chain fragment');
|
||
expect(markdown).toContain('Tool: read');
|
||
expect(markdown).toContain('[Local path: notes.txt]');
|
||
expect(markdown).not.toMatch(/VERY_SECRET|ALSO_SECRET|TOOL_SECRET|A{64}|base64/i);
|
||
expect(markdown).not.toMatch(/127\.0\.0\.1|C:\\Users|\/Users\/alice/);
|
||
});
|
||
|
||
it('omits thinking and collapsed tool details while retaining visible answers and tool names', () => {
|
||
const markdown = formatVisibleChatTranscript(messages, {
|
||
showThinking: false,
|
||
showTimestamps: false,
|
||
expandedToolIds: new Set(),
|
||
});
|
||
|
||
expect(markdown).toContain('Inspect the attachment.');
|
||
expect(markdown).toContain('Finished.');
|
||
expect(markdown).toContain('Tool: read');
|
||
expect(markdown).not.toContain('Private chain fragment');
|
||
expect(markdown).not.toContain('notes.txt');
|
||
expect(markdown).not.toContain('2026-07-18');
|
||
});
|
||
|
||
it('defaults the explicit answer-only mode to user messages and the final answer', () => {
|
||
const markdown = formatVisibleChatTranscript(messages, {
|
||
showThinking: true,
|
||
showTimestamps: false,
|
||
includeExecution: false,
|
||
expandedToolIds: new Set(),
|
||
});
|
||
|
||
expect(markdown).toContain('Inspect the attachment.');
|
||
expect(markdown).toContain('Finished.');
|
||
expect(markdown).not.toContain('Private chain fragment');
|
||
expect(markdown).not.toContain('Tool: read');
|
||
});
|
||
|
||
it('redacts alternate binary encodings, file URLs, IPv6 loopback, and additional absolute roots', () => {
|
||
const base64Url = `${'a'.repeat(32)}-${'b'.repeat(32)}_${'c'.repeat(8)}`;
|
||
const wrappedBase64 = `${'A'.repeat(40)}\n${'B'.repeat(40)}`;
|
||
const markdown = formatVisibleChatTranscript([{
|
||
id: 'assistant-safety',
|
||
role: 'assistant',
|
||
content: [{
|
||
type: 'tool_use',
|
||
id: 'tool-safety',
|
||
name: 'inspect',
|
||
input: {
|
||
dataUrl: `data:image/png;charset=utf-8;name=secret.png;base64,${wrappedBase64}`,
|
||
base64Url,
|
||
ipv6Loopback: 'http://[::1]:43123/private/file.png',
|
||
fileUrl: 'file:///Users/alice/private/file.txt',
|
||
hostedFileUrl: 'file://localhost/Users/alice/private/hosted.txt',
|
||
remoteHostedFileUrl: 'file://server/share/remote-hosted.txt',
|
||
rootPath: '/root/.ssh/id_ed25519',
|
||
usrPath: '/usr/local/share/private.txt',
|
||
srvPath: '/srv/internal/secret.txt',
|
||
customPath: '/company/internal/private/roadmap.txt',
|
||
rootFile: '/secret.txt',
|
||
forwardWindowsPath: 'C:/secret.txt',
|
||
windowsPath: 'C:\\Users\\alice\\private\\windows.txt',
|
||
spacedWindowsPath: 'C:\\Users\\Alice\\Private Notes\\secret.txt',
|
||
uncPath: '\\\\fileserver\\private\\unc.txt',
|
||
},
|
||
}],
|
||
}], {
|
||
showThinking: true,
|
||
showTimestamps: true,
|
||
expandedToolIds: new Set([
|
||
getToolVisibilityId('assistant-safety', 'tool-safety', 0),
|
||
]),
|
||
});
|
||
|
||
expect(markdown).toContain('[Binary data omitted]');
|
||
expect(markdown).toContain('[Local path: file.txt]');
|
||
expect(markdown).toContain('[Local path: id_ed25519]');
|
||
expect(markdown).not.toContain(base64Url);
|
||
expect(markdown).not.toContain('A'.repeat(40));
|
||
expect(markdown).not.toContain('B'.repeat(40));
|
||
expect(markdown).not.toMatch(
|
||
/data:image|base64|http:\/\/\[::1\]|file:\/\/|\/root\/|\/usr\/|\/srv\/|\/company\/|\/secret\.txt|Private Notes/i,
|
||
);
|
||
expect(markdown).not.toMatch(/C:[/\\]|\\\\fileserver/);
|
||
});
|
||
|
||
it('preserves an extensionless slash token because it may be a dynamic project command', () => {
|
||
const markdown = formatVisibleChatTranscript([{
|
||
role: 'assistant',
|
||
content: [
|
||
'/single',
|
||
'/review.v2',
|
||
'Use /base64 now',
|
||
'[the guide](/docs/getting-started)',
|
||
'Call /api/v1/users',
|
||
].join('\n'),
|
||
}], {
|
||
showThinking: false,
|
||
showTimestamps: false,
|
||
expandedToolIds: new Set(),
|
||
});
|
||
|
||
expect(markdown).toMatch(/\n\/single\n/);
|
||
expect(markdown).toContain('/review.v2');
|
||
expect(markdown).toContain('Use /base64 now');
|
||
expect(markdown).toContain('[the guide](/docs/getting-started)');
|
||
expect(markdown).toContain('Call /api/v1/users');
|
||
});
|
||
|
||
it('preserves common root-relative routes without merging adjacent paths', () => {
|
||
const markdown = formatVisibleChatTranscript([{
|
||
role: 'assistant',
|
||
content: [
|
||
'GET /v1/users now',
|
||
'Load /assets/js/app.js and /health/check',
|
||
'Paths /Volumes/Private/file.txt and /data/private/cache.bin',
|
||
].join('\n'),
|
||
}], {
|
||
showThinking: false,
|
||
showTimestamps: false,
|
||
expandedToolIds: new Set(),
|
||
});
|
||
|
||
expect(markdown).toContain('GET /v1/users now');
|
||
expect(markdown).toContain('Load /assets/js/app.js and /health/check');
|
||
expect(markdown).toContain(
|
||
'Paths [Local path: file.txt] and [Local path: cache.bin]',
|
||
);
|
||
});
|
||
|
||
it('does not exempt an absolute local path merely because it is a Markdown link', () => {
|
||
const markdown = formatVisibleChatTranscript([{
|
||
role: 'assistant',
|
||
content: [
|
||
'See [guide](/docs/getting-started).',
|
||
'See [secret](/Users/alice/private/secret.txt).',
|
||
'See [volume](/Volumes/Private/volume.txt).',
|
||
].join('\n'),
|
||
}], {
|
||
showThinking: false,
|
||
showTimestamps: false,
|
||
expandedToolIds: new Set(),
|
||
});
|
||
|
||
expect(markdown).toContain('See [guide](/docs/getting-started).');
|
||
expect(markdown).toContain('See [secret]([Local path: secret.txt]).');
|
||
expect(markdown).toContain('See [volume]([Local path: volume.txt]).');
|
||
expect(markdown).not.toMatch(/\/Users\/alice|\/Volumes\/Private/);
|
||
});
|
||
|
||
it('preserves a known nested project command while sanitizing path arguments', () => {
|
||
const commandCatalog = mergeChatCommandCatalog([{
|
||
name: 'workspace/build',
|
||
hints: ['$ARGUMENTS'],
|
||
}]);
|
||
const slashCommandNames = new Set(commandCatalog.flatMap(
|
||
(command) => [command.inputName, ...command.aliases],
|
||
));
|
||
const markdown = formatVisibleChatTranscript([{
|
||
role: 'user',
|
||
content: '/workspace/build inspect /Users/alice/private/input.txt',
|
||
}], {
|
||
showThinking: false,
|
||
showTimestamps: false,
|
||
expandedToolIds: new Set(),
|
||
slashCommandNames,
|
||
});
|
||
|
||
expect(markdown).toContain('/workspace/build inspect');
|
||
expect(markdown).toContain('[Local path: input.txt]');
|
||
expect(markdown).not.toContain('/Users/alice/private');
|
||
});
|
||
|
||
it('redacts forward-slash UNC paths and backtick-wrapped custom-root paths', () => {
|
||
const markdown = formatVisibleChatTranscript([{
|
||
role: 'assistant',
|
||
content: '//server/share/private.txt\nGenerated at `/company/internal/secret.txt`',
|
||
}], {
|
||
showThinking: false,
|
||
showTimestamps: false,
|
||
expandedToolIds: new Set(),
|
||
});
|
||
|
||
expect(markdown).toContain('[Local path: private.txt]');
|
||
expect(markdown).toContain('`[Local path: secret.txt]`');
|
||
expect(markdown).not.toMatch(/\/\/server\/share|\/company\/internal/);
|
||
});
|
||
|
||
it('redacts encoded and non-base64 data URLs, shorthand loopback, and spaced POSIX paths', () => {
|
||
const oversizedDataHeader = 'a'.repeat(2_050);
|
||
const markdown = formatVisibleChatTranscript([{
|
||
role: 'assistant',
|
||
content: [
|
||
'data:;base64,U0VDUkVUX1BBWUxPQUQ=',
|
||
'data:;base64,U0VD UkVU',
|
||
'data:image/png;base64,%2FSECRET_PAYLOAD_12345%3D',
|
||
'data:text/plain,PLAIN_TEXT_SECRET',
|
||
'data:text/plain;name="foo bar";base64,U0VDUkVU',
|
||
'data:foo,HEADER_FOO_SECRET',
|
||
'data:text,HEADER_TEXT_SECRET',
|
||
'data:@,HEADER_SYMBOL_SECRET',
|
||
'metadata:text/plain,hello',
|
||
'The data: are stored, safely.',
|
||
'data:image/png;base64,U0VDUkVU Done safely.',
|
||
`data:text/plain;name=${oversizedDataHeader},HEADER_LIMIT_SECRET`,
|
||
'data:text/plain;name="foo,QUOTE_SECRET',
|
||
'http://127.1:43123/private/file.png',
|
||
'http://localhost.:43123/private/dotted.png',
|
||
'Open `/Users/Alice/Private Notes/secret.txt` safely.',
|
||
'Use /copy now',
|
||
'/copy',
|
||
].join('\n'),
|
||
}], {
|
||
showThinking: false,
|
||
showTimestamps: false,
|
||
expandedToolIds: new Set(),
|
||
});
|
||
|
||
expect(markdown).toContain('[Binary data omitted]');
|
||
expect(markdown).toContain('[Runtime attachment: file.png]');
|
||
expect(markdown).toContain('[Runtime attachment: dotted.png]');
|
||
expect(markdown).toContain('Open `[Local path: secret.txt]` safely.');
|
||
expect(markdown).toContain('Use /copy now');
|
||
expect(markdown).toMatch(/\n\/copy\n/);
|
||
expect(markdown).not.toMatch(
|
||
/127\.1|localhost\.|\/Users\/Alice|Private Notes\/secret\.txt/i,
|
||
);
|
||
expect(markdown).not.toMatch(/(^|\n)data:/im);
|
||
expect(markdown).not.toContain('U0VDUkVUX1BBWUxPQUQ=');
|
||
expect(markdown).not.toMatch(/U0VD|UkVU/);
|
||
expect(markdown).not.toContain('%2FSECRET_PAYLOAD_12345%3D');
|
||
expect(markdown).not.toContain('PLAIN_TEXT_SECRET');
|
||
expect(markdown).toContain('metadata:text/plain,hello');
|
||
expect(markdown).not.toMatch(
|
||
/HEADER_FOO_SECRET|HEADER_TEXT_SECRET|HEADER_SYMBOL_SECRET|are stored, safely/,
|
||
);
|
||
expect(markdown).toContain('[Binary data omitted] Done safely.');
|
||
expect(markdown).not.toMatch(/HEADER_LIMIT_SECRET|QUOTE_SECRET/);
|
||
});
|
||
|
||
it('redacts complete quoted data and loopback URL payloads with legal delimiters', () => {
|
||
const markdown = formatVisibleChatTranscript([{
|
||
id: 'assistant-delimited-urls',
|
||
role: 'assistant',
|
||
content: [{
|
||
type: 'tool_use',
|
||
id: 'tool-delimited-urls',
|
||
name: 'inspect',
|
||
input: {
|
||
parenthesized: 'data:text/plain,HEAD_SECRET)TAIL_SECRET',
|
||
apostrophe: 'data:text/plain,ONE_SECRET\'TWO_SECRET',
|
||
backtick: 'data:text/plain,LEFT_SECRET`RIGHT_SECRET',
|
||
spaced: 'data:text/plain,SEC RET',
|
||
loopbackParen:
|
||
'http://127.0.0.1:43123/private)TOP_SECRET_DIR/public.png',
|
||
loopbackApostrophe:
|
||
'http://localhost:43123/private\'SECOND_SECRET_DIR/public.png',
|
||
loopbackQuote:
|
||
'http://localhost:43123/private"HTTP_SECRET_DIR/public.png',
|
||
fileParen:
|
||
'file:///Users/alice/private)FILE_PAREN_SECRET/public.txt',
|
||
fileQuote:
|
||
'file:///Users/alice/private"FILE_SECRET_DIR/public.txt',
|
||
},
|
||
}],
|
||
}], {
|
||
showThinking: false,
|
||
showTimestamps: false,
|
||
expandedToolIds: new Set([
|
||
getToolVisibilityId(
|
||
'assistant-delimited-urls',
|
||
'tool-delimited-urls',
|
||
0,
|
||
),
|
||
]),
|
||
});
|
||
|
||
expect(markdown).toContain('[Binary data omitted]');
|
||
expect(markdown).toContain('[Runtime attachment: public.png]');
|
||
expect(markdown).toContain('[Local path: public.txt]');
|
||
expect(markdown).not.toMatch(
|
||
/HEAD_SECRET|TAIL_SECRET|ONE_SECRET|TWO_SECRET|LEFT_SECRET|RIGHT_SECRET|SEC RET|TOP_SECRET_DIR|SECOND_SECRET_DIR|HTTP_SECRET_DIR|FILE_PAREN_SECRET|FILE_SECRET_DIR/,
|
||
);
|
||
});
|
||
|
||
it('redacts malformed data headers and direct unquoted local URL suffixes', () => {
|
||
const markdown = formatVisibleChatTranscript([{
|
||
role: 'assistant',
|
||
content: [
|
||
'data: text/plain,LEADING_SPACE_SECRET',
|
||
'data:\ttext/plain,TAB_HEADER_SECRET',
|
||
'data:\ftext/plain,FORM_FEED_HEADER_SECRET',
|
||
'data:text/\nplain,NEWLINE_HEADER_SECRET',
|
||
'data:text/plain;name=foo`bar,HEADER_BACKTICK_SECRET',
|
||
'data:text/plain;name=foo\\,BACKSLASH_COMMA_SECRET',
|
||
'da\nta:text/plain,DATA_SCHEME_SECRET',
|
||
'ht\ntp://localhost:43123/private/HTTP_SCHEME_SECRET/public.png',
|
||
'fi\nle:///Users/Alice/private/FILE_SCHEME_SECRET/public.txt',
|
||
'http://127.0.0.1:43123/private)TOP_SECRET_DIR/public.png',
|
||
'file:///Users/alice/private)FILE_SECRET_DIR/public.txt',
|
||
'http://local\nhost:43123/private/NEWLINE_LOOP_SECRET/public.png',
|
||
'file:///Users/ali\nce/private/NEWLINE_FILE_SECRET/public.txt',
|
||
'http://localhost:43123/private/\nHTTP_FINAL_FOLD_SECRET.png',
|
||
'file:///Users/Alice/private/\r\nFILE_FINAL_FOLD_SECRET.txt',
|
||
'`http://localhost:43123/private/\nHTTP_WRAPPED_FOLD_SECRET.png`',
|
||
'`file:///Users/Alice/private/\nFILE_WRAPPED_FOLD_SECRET.txt`',
|
||
'http://localhost:43123/Private Notes/HTTP_SPACE_SECRET/public.png',
|
||
'file:///Users/Alice/Private Notes/FILE_SPACE_SECRET/public.txt',
|
||
].join('\n'),
|
||
}], {
|
||
showThinking: false,
|
||
showTimestamps: false,
|
||
expandedToolIds: new Set(),
|
||
});
|
||
|
||
expect(markdown).toContain('[Runtime attachment: public.png]');
|
||
expect(markdown).toContain('[Local path: public.txt]');
|
||
expect(markdown).toContain(
|
||
'[Runtime attachment: HTTP_FINAL_FOLD_SECRET.png]',
|
||
);
|
||
expect(markdown).toContain('[Local path: FILE_FINAL_FOLD_SECRET.txt]');
|
||
expect(markdown).toContain(
|
||
'`[Runtime attachment: HTTP_WRAPPED_FOLD_SECRET.png]`',
|
||
);
|
||
expect(markdown).toContain(
|
||
'`[Local path: FILE_WRAPPED_FOLD_SECRET.txt]`',
|
||
);
|
||
expect(markdown).not.toMatch(/private\/\r?\n(?:HTTP|FILE)_(?:FINAL|WRAPPED)_FOLD_SECRET/);
|
||
expect(markdown).not.toMatch(
|
||
/LEADING_SPACE_SECRET|TAB_HEADER_SECRET|FORM_FEED_HEADER_SECRET|NEWLINE_HEADER_SECRET|HEADER_BACKTICK_SECRET|BACKSLASH_COMMA_SECRET|DATA_SCHEME_SECRET|HTTP_SCHEME_SECRET|FILE_SCHEME_SECRET|TOP_SECRET_DIR|FILE_SECRET_DIR|NEWLINE_LOOP_SECRET|NEWLINE_FILE_SECRET|HTTP_SPACE_SECRET|FILE_SPACE_SECRET/,
|
||
);
|
||
});
|
||
|
||
it('stops a quoted data URL at its closing wrapper', () => {
|
||
const markdown = formatVisibleChatTranscript([{
|
||
role: 'assistant',
|
||
content: 'Open "data:text/plain,secret" and then "click Save".',
|
||
}], {
|
||
showThinking: false,
|
||
showTimestamps: false,
|
||
expandedToolIds: new Set(),
|
||
});
|
||
|
||
expect(markdown).toContain(
|
||
'Open "[Binary data omitted]" and then "click Save".',
|
||
);
|
||
expect(markdown).not.toContain('secret');
|
||
});
|
||
|
||
it.each(['\n', '\r\n'])(
|
||
'stops an unclosed quoted data URL at the current line for %j',
|
||
(lineBreak) => {
|
||
const markdown = formatVisibleChatTranscript([{
|
||
role: 'assistant',
|
||
content: `Open "data:text/plain,secret${lineBreak}Keep this visible.`,
|
||
}], {
|
||
showThinking: false,
|
||
showTimestamps: false,
|
||
expandedToolIds: new Set(),
|
||
});
|
||
|
||
expect(markdown).toContain('Open "[Binary data omitted]');
|
||
expect(markdown).toContain('Keep this visible.');
|
||
expect(markdown).not.toContain('secret');
|
||
},
|
||
);
|
||
|
||
it.each([
|
||
['"', '\n'],
|
||
['"', '\r\n'],
|
||
['\'', '\n'],
|
||
['\'', '\r\n'],
|
||
['`', '\n'],
|
||
['`', '\r\n'],
|
||
])(
|
||
'does not consume visible text after a line-ended Data URL (%s, %j)',
|
||
(wrapper, lineBreak) => {
|
||
const markdown = formatVisibleChatTranscript([{
|
||
role: 'assistant',
|
||
content:
|
||
`Open ${wrapper}data:text/plain,FIRST_SECRET${lineBreak}`
|
||
+ `Keep this visible ${wrapper}quoted text${wrapper}.`,
|
||
}], {
|
||
showThinking: false,
|
||
showTimestamps: false,
|
||
expandedToolIds: new Set(),
|
||
});
|
||
|
||
expect(markdown).toContain(`Open ${wrapper}[Binary data omitted]`);
|
||
expect(markdown).toContain(
|
||
`Keep this visible ${wrapper}quoted text${wrapper}.`,
|
||
);
|
||
expect(markdown).not.toContain('FIRST_SECRET');
|
||
},
|
||
);
|
||
|
||
it.each([
|
||
['http://localhost:43123/private/', '[Runtime attachment: private]', '', '\n'],
|
||
['http://localhost:43123/private/', '[Runtime attachment: private]', '"', '\r\n'],
|
||
['file:///Users/Alice/private/', '[Local path: private]', '', '\n'],
|
||
['file:///Users/Alice/private/', '[Local path: private]', '`', '\r\n'],
|
||
])(
|
||
'does not fold ordinary prose into a line-ended local URL (%s, %s, %j)',
|
||
(url, placeholder, wrapper, lineBreak) => {
|
||
const markdown = formatVisibleChatTranscript([{
|
||
role: 'assistant',
|
||
content:
|
||
`Open ${wrapper}${url}${lineBreak}`
|
||
+ `Keep this visible.${wrapper}`,
|
||
}], {
|
||
showThinking: false,
|
||
showTimestamps: false,
|
||
expandedToolIds: new Set(),
|
||
});
|
||
|
||
expect(markdown).toContain(`Open ${wrapper}${placeholder}`);
|
||
expect(markdown).toContain(`Keep this visible.${wrapper}`);
|
||
},
|
||
);
|
||
|
||
it('preserves surrounding Markdown and prose when redacting Windows and file URL paths', () => {
|
||
const markdown = formatVisibleChatTranscript([{
|
||
role: 'assistant',
|
||
content: [
|
||
'Open `C:\\Users\\alice\\secret\\file.txt` and retry.',
|
||
'See `file:///Users/Alice/Private Notes/file.txt` safely.',
|
||
'See file:///Users/alice/private/file.txt and retry.',
|
||
'Open /Users/alice/file.txt and retry.',
|
||
'Open /Users/Alice/Private Notes/direct-posix.txt safely.',
|
||
'Open /Volumes/Private/volume.txt safely.',
|
||
'Open /data/private/cache.bin safely.',
|
||
'Open /company/internal/roadmap.txt safely.',
|
||
'Open /acme/Private Notes/acme.txt safely.',
|
||
'Open /project/My Folder/project.txt safely.',
|
||
'Open /Custom Root/private/custom.txt safely.',
|
||
'Open C:\\Users\\alice\\file.txt and retry.',
|
||
'Open C:\\Users\\Alice\\Private Notes\\direct-windows.txt safely.',
|
||
'Open C:/Users/alice/file.txt and retry.',
|
||
'Open C:/Users/Alice/Private Notes/direct-forward.txt safely.',
|
||
'Open \\\\server\\share\\file.txt and retry.',
|
||
].join('\n'),
|
||
}], {
|
||
showThinking: false,
|
||
showTimestamps: false,
|
||
expandedToolIds: new Set(),
|
||
});
|
||
|
||
expect(markdown).toContain('Open `[Local path: file.txt]` and retry.');
|
||
expect(markdown).toContain('See `[Local path: file.txt]` safely.');
|
||
expect(markdown).toContain('See [Local path: file.txt] and retry.');
|
||
expect(markdown.match(/Open \[Local path: file\.txt\] and retry\./g))
|
||
.toHaveLength(4);
|
||
expect(markdown).toContain('Open [Local path: direct-posix.txt] safely.');
|
||
expect(markdown).toContain('Open [Local path: direct-windows.txt] safely.');
|
||
expect(markdown).toContain('Open [Local path: direct-forward.txt] safely.');
|
||
expect(markdown).toContain('Open [Local path: volume.txt] safely.');
|
||
expect(markdown).toContain('Open [Local path: cache.bin] safely.');
|
||
expect(markdown).toContain('Open [Local path: roadmap.txt] safely.');
|
||
expect(markdown).toContain('Open [Local path: acme.txt] safely.');
|
||
expect(markdown).toContain('Open [Local path: project.txt] safely.');
|
||
expect(markdown).toContain('Open [Local path: custom.txt] safely.');
|
||
expect(markdown).not.toMatch(
|
||
/Private Notes|My Folder|Custom Root|\/Volumes\/|\/data\/private|\/company\/internal/,
|
||
);
|
||
});
|
||
|
||
it('redacts a short Base64 payload in visible prose without changing the command token', () => {
|
||
const markdown = formatVisibleChatTranscript([{
|
||
role: 'assistant',
|
||
content: [
|
||
'Image base64=U0VDUkVU',
|
||
'Wrapped base64: `U0VDUkVU`',
|
||
'Spaced base64: U0VD UkVU',
|
||
'Folded base64: U0VD\nUkVU',
|
||
'CRLF base64: U0VD\r\nUkVU',
|
||
'Triple folded base64: QUJD\nREVG\nR0hJ',
|
||
'The data: analysis is complete.',
|
||
'Screenshot: attached below.',
|
||
'Preview: available tomorrow.',
|
||
'Use /base64 now',
|
||
].join('\n'),
|
||
}], {
|
||
showThinking: false,
|
||
showTimestamps: false,
|
||
expandedToolIds: new Set(),
|
||
});
|
||
|
||
expect(markdown).toContain('Image base64=[Binary data omitted]');
|
||
expect(markdown).toContain('Wrapped base64: `[Binary data omitted]`');
|
||
expect(markdown).toContain('Spaced base64: [Binary data omitted]');
|
||
expect(markdown).toContain('Folded base64: [Binary data omitted]');
|
||
expect(markdown).toContain('CRLF base64: [Binary data omitted]');
|
||
expect(markdown).toContain('Triple folded base64: [Binary data omitted]');
|
||
expect(markdown).toContain('The data: analysis is complete.');
|
||
expect(markdown).toContain('Screenshot: attached below.');
|
||
expect(markdown).toContain('Preview: available tomorrow.');
|
||
expect(markdown).toContain('Use /base64 now');
|
||
expect(markdown).not.toContain('U0VDUkVU');
|
||
});
|
||
|
||
it('keeps multiple local paths on one line as separate placeholders', () => {
|
||
const markdown = formatVisibleChatTranscript([{
|
||
role: 'assistant',
|
||
content: [
|
||
'Paths C:\\Users\\Alice\\one.txt and C:\\data\\two.txt done',
|
||
'Paths C:/Users/Alice/one.txt and C:/data/two.txt done',
|
||
'Paths \\\\server\\share\\one.txt and \\\\server\\share\\two.txt done',
|
||
'Paths //server/share/one.txt and //server/share/two.txt done',
|
||
].join('\n'),
|
||
}], {
|
||
showThinking: false,
|
||
showTimestamps: false,
|
||
expandedToolIds: new Set(),
|
||
});
|
||
|
||
expect(markdown.match(/\[Local path: one\.txt\]/g)).toHaveLength(4);
|
||
expect(markdown.match(/\[Local path: two\.txt\]/g)).toHaveLength(4);
|
||
expect(markdown.match(/ and /g)).toHaveLength(4);
|
||
expect(markdown).not.toMatch(/C:[/\\]|\/\/server|\\\\server/);
|
||
});
|
||
|
||
it('stops spaced paths and URLs at punctuation or a following absolute value', () => {
|
||
const markdown = formatVisibleChatTranscript([{
|
||
role: 'assistant',
|
||
content: [
|
||
'POSIX /Volumes/one.txt, /data/two.txt done',
|
||
'POSIX /Volumes/one.txt; /data/two.txt done',
|
||
'POSIX /Volumes/one.txt /data/two.txt done',
|
||
'POSIX /Volumes/one.txt，然后 /data/two.txt done',
|
||
'POSIX /Users/Alice/Private Notes/one.txt. Next /data/two.txt done',
|
||
'WIN C:\\Users\\A\\one.txt, C:\\Users\\B\\two.txt done',
|
||
'URL http://localhost:43123/Private Notes/one.png, http://localhost:43123/Private Notes/two.png done',
|
||
'URL file:///Users/Alice/Private Notes/one.txt; file:///Users/Alice/Private Notes/two.txt done',
|
||
].join('\n'),
|
||
}], {
|
||
showThinking: false,
|
||
showTimestamps: false,
|
||
expandedToolIds: new Set(),
|
||
});
|
||
|
||
expect(markdown.match(/\[Local path: one\.txt\]/g)).toHaveLength(7);
|
||
expect(markdown.match(/\[Local path: two\.txt\]/g)).toHaveLength(7);
|
||
expect(markdown.match(/\[Runtime attachment: one\.png\]/g)).toHaveLength(1);
|
||
expect(markdown.match(/\[Runtime attachment: two\.png\]/g)).toHaveLength(1);
|
||
expect(markdown).toContain(
|
||
'[Local path: one.txt]. Next [Local path: two.txt] done',
|
||
);
|
||
expect(markdown).not.toMatch(
|
||
/\/Volumes\/|\/data\/|\/Users\/|C:\\|localhost:43123|Private Notes/,
|
||
);
|
||
});
|
||
|
||
it('keeps punctuation inside one directory while redacting its full path', () => {
|
||
const markdown = formatVisibleChatTranscript([{
|
||
role: 'assistant',
|
||
content: [
|
||
'Open /Users/Alice/Smith, John/POSIX_COMMA_SECRET.txt safely.',
|
||
'Open C:\\Users\\Alice\\Smith, John\\WIN_COMMA_SECRET.txt safely.',
|
||
'Open C:/Users/Alice/R&D/WIN_AMP_SECRET.txt safely.',
|
||
'Open file:///Users/Alice/Smith, John/FILE_COMMA_SECRET.txt safely.',
|
||
'Open http://localhost:43123/Smith, John/HTTP_COMMA_SECRET.png safely.',
|
||
].join('\n'),
|
||
}], {
|
||
showThinking: false,
|
||
showTimestamps: false,
|
||
expandedToolIds: new Set(),
|
||
});
|
||
|
||
expect(markdown).toContain('[Local path: POSIX_COMMA_SECRET.txt]');
|
||
expect(markdown).toContain('[Local path: WIN_COMMA_SECRET.txt]');
|
||
expect(markdown).toContain('[Local path: WIN_AMP_SECRET.txt]');
|
||
expect(markdown).toContain('[Local path: FILE_COMMA_SECRET.txt]');
|
||
expect(markdown).toContain('[Runtime attachment: HTTP_COMMA_SECRET.png]');
|
||
expect(markdown).not.toMatch(/Smith, John|R&D|\/Users\/|C:[/\\]|localhost/);
|
||
});
|
||
|
||
it('bounds punctuation-heavy path scanning for long visible messages', () => {
|
||
const startedAt = performance.now();
|
||
const markdown = formatVisibleChatTranscript([{
|
||
role: 'assistant',
|
||
content: `Open /Custom Root/${'a,'.repeat(100_000)}tail/file.txt safely.`,
|
||
}], {
|
||
showThinking: false,
|
||
showTimestamps: false,
|
||
expandedToolIds: new Set(),
|
||
});
|
||
const elapsedMilliseconds = performance.now() - startedAt;
|
||
|
||
expect(markdown).toContain('[Local path: file.txt]');
|
||
expect(elapsedMilliseconds).toBeLessThan(1_500);
|
||
});
|
||
|
||
it.each([
|
||
['circular', (() => {
|
||
const value: Record<string, unknown> = {};
|
||
value.self = value;
|
||
return value;
|
||
})()],
|
||
['BigInt', { value: 1n }],
|
||
['throwing toJSON', { toJSON: () => { throw new Error('secret serializer failure'); } }],
|
||
])('uses a fixed placeholder when %s tool input cannot be serialized', (_label, input) => {
|
||
const markdown = formatVisibleChatTranscript([{
|
||
id: 'assistant-unserializable',
|
||
role: 'assistant',
|
||
content: [{
|
||
type: 'tool_use',
|
||
id: 'tool-unserializable',
|
||
name: 'inspect',
|
||
input,
|
||
}],
|
||
}], {
|
||
showThinking: true,
|
||
showTimestamps: false,
|
||
expandedToolIds: new Set([
|
||
getToolVisibilityId('assistant-unserializable', 'tool-unserializable', 0),
|
||
]),
|
||
});
|
||
|
||
expect(markdown).toContain('[Tool details unavailable]');
|
||
});
|
||
|
||
it('redacts short Base64 under explicit binary tool keys', () => {
|
||
const shortBase64 = 'U0VDUkVU';
|
||
const markdown = formatVisibleChatTranscript([{
|
||
id: 'assistant-short-binary',
|
||
role: 'assistant',
|
||
content: [{
|
||
type: 'tool_use',
|
||
id: 'tool-short-binary',
|
||
name: 'inspect',
|
||
input: {
|
||
screenshotBase64: shortBase64,
|
||
rawBytes: shortBase64,
|
||
label: 'ordinary short text',
|
||
},
|
||
}],
|
||
}], {
|
||
showThinking: false,
|
||
showTimestamps: false,
|
||
expandedToolIds: new Set([
|
||
getToolVisibilityId('assistant-short-binary', 'tool-short-binary', 0),
|
||
]),
|
||
});
|
||
|
||
expect(markdown).not.toContain(shortBase64);
|
||
expect(markdown.match(/\[Binary data omitted\]/g)).toHaveLength(2);
|
||
expect(markdown).toContain('ordinary short text');
|
||
});
|
||
|
||
it('redacts short Base64 from JSON-encoded string tool input', () => {
|
||
const shortBase64 = 'U0VDUkVU';
|
||
const markdown = formatVisibleChatTranscript([{
|
||
id: 'assistant-string-binary',
|
||
role: 'assistant',
|
||
content: [{
|
||
type: 'tool_use',
|
||
id: 'tool-string-binary',
|
||
name: 'inspect',
|
||
input: JSON.stringify({
|
||
screenshotBase64: shortBase64,
|
||
ordinary: 'visible text',
|
||
}),
|
||
}],
|
||
}], {
|
||
showThinking: false,
|
||
showTimestamps: false,
|
||
expandedToolIds: new Set([
|
||
getToolVisibilityId(
|
||
'assistant-string-binary',
|
||
'tool-string-binary',
|
||
0,
|
||
),
|
||
]),
|
||
});
|
||
|
||
expect(markdown).not.toContain(shortBase64);
|
||
expect(markdown).toContain('[Binary data omitted]');
|
||
expect(markdown).toContain('visible text');
|
||
});
|
||
|
||
it.each([
|
||
['plain labelled input', 'screenshotBase64: U0VDUkVU'],
|
||
['partial JSON input', '{"screenshotBase64":"U0VDUkVU"'],
|
||
['folded partial JSON input', '{"screenshotBase64":"U0VD\\nUkVU"'],
|
||
])('redacts short Base64 from %s', (_label, input) => {
|
||
const markdown = formatVisibleChatTranscript([{
|
||
id: 'assistant-partial-binary',
|
||
role: 'assistant',
|
||
content: [{
|
||
type: 'tool_use',
|
||
id: 'tool-partial-binary',
|
||
name: 'inspect',
|
||
input,
|
||
}],
|
||
}], {
|
||
showThinking: false,
|
||
showTimestamps: false,
|
||
expandedToolIds: new Set([
|
||
getToolVisibilityId(
|
||
'assistant-partial-binary',
|
||
'tool-partial-binary',
|
||
0,
|
||
),
|
||
]),
|
||
});
|
||
|
||
expect(markdown).not.toContain('U0VDUkVU');
|
||
expect(markdown).toContain('[Binary data omitted]');
|
||
});
|
||
|
||
it('redacts single-segment absolute paths in structured tool details', () => {
|
||
const markdown = formatVisibleChatTranscript([{
|
||
id: 'assistant-structured-paths',
|
||
role: 'assistant',
|
||
content: [{
|
||
type: 'tool_use',
|
||
id: 'tool-structured-paths',
|
||
name: 'inspect',
|
||
input: {
|
||
dotEnv: '/.env',
|
||
extensionlessPath: '/secret',
|
||
},
|
||
}],
|
||
}], {
|
||
showThinking: false,
|
||
showTimestamps: false,
|
||
expandedToolIds: new Set([
|
||
getToolVisibilityId(
|
||
'assistant-structured-paths',
|
||
'tool-structured-paths',
|
||
0,
|
||
),
|
||
]),
|
||
});
|
||
|
||
expect(markdown).toContain('[Local path: .env]');
|
||
expect(markdown).toContain('[Local path: secret]');
|
||
expect(markdown).not.toMatch(/"\/(?:\.env|secret)"/);
|
||
});
|
||
|
||
it('keeps every unnamed binary placeholder and deduplicates only a matching named attachment', () => {
|
||
const markdown = formatVisibleChatTranscript([{
|
||
id: 'user-binary',
|
||
role: 'user',
|
||
content: [
|
||
{ type: 'image', mimeType: 'image/png', data: 'FIRST' },
|
||
{ type: 'image', mimeType: 'image/png', data: 'SECOND' },
|
||
{ type: 'image', mimeType: 'image/png', data: 'THIRD', fileName: '/tmp/diagram.png' },
|
||
],
|
||
_attachedFiles: [{
|
||
fileName: 'diagram.png',
|
||
mimeType: 'image/png',
|
||
fileSize: 10,
|
||
preview: null,
|
||
}],
|
||
}], {
|
||
showThinking: false,
|
||
showTimestamps: false,
|
||
expandedToolIds: new Set(),
|
||
});
|
||
|
||
expect(markdown.match(/\[Attached image\/png: attachment\]/g)).toHaveLength(2);
|
||
expect(markdown.match(/\[Attached image\/png: diagram\.png\]/g)).toHaveLength(1);
|
||
});
|
||
|
||
it('sanitizes untrusted attachment names and MIME metadata before formatting placeholders', () => {
|
||
const encodedSecret = 'A'.repeat(80);
|
||
const shortDataUrlSecret = 'SHORT_SECRET_PAYLOAD_12345';
|
||
const fileUrlToken = 'TOP_SECRET_TOKEN';
|
||
const markdown = formatVisibleChatTranscript([{
|
||
id: 'user-attachment-metadata',
|
||
role: 'user',
|
||
content: [{
|
||
type: 'image',
|
||
mimeType: `data:image/png;base64,${encodedSecret}`,
|
||
data: 'BINARY',
|
||
fileName: encodedSecret,
|
||
}],
|
||
_attachedFiles: [
|
||
{
|
||
fileName: encodedSecret,
|
||
mimeType: 'image/png',
|
||
fileSize: 10,
|
||
preview: null,
|
||
},
|
||
{
|
||
fileName: 'safe.png',
|
||
mimeType: `data:image/png;base64,${encodedSecret}`,
|
||
fileSize: 10,
|
||
preview: null,
|
||
},
|
||
{
|
||
fileName: `data:image/png;base64,${shortDataUrlSecret}`,
|
||
mimeType: 'image/png',
|
||
fileSize: 10,
|
||
preview: null,
|
||
},
|
||
{
|
||
fileName: 'http://127.0.0.1:43123/api/files?path=C%3A%5CUsers%5CAlice%5Cprivate%5Csecret.png',
|
||
mimeType: 'image/png',
|
||
fileSize: 10,
|
||
preview: null,
|
||
},
|
||
{
|
||
fileName: `file://server/share/private.txt?token=${fileUrlToken}`,
|
||
mimeType: 'image/png',
|
||
fileSize: 10,
|
||
preview: null,
|
||
},
|
||
],
|
||
}], {
|
||
showThinking: false,
|
||
showTimestamps: false,
|
||
expandedToolIds: new Set(),
|
||
});
|
||
|
||
expect(markdown).toContain('[Attached image/png: [Binary data omitted]]');
|
||
expect(markdown).toContain('[Attached application/octet-stream: safe.png]');
|
||
expect(markdown).not.toContain(encodedSecret);
|
||
expect(markdown).not.toContain(shortDataUrlSecret);
|
||
expect(markdown).not.toContain(fileUrlToken);
|
||
expect(markdown).not.toMatch(/127\.0\.0\.1|%5CUsers|file:\/\/server/i);
|
||
expect(markdown).not.toMatch(/data:image|base64/i);
|
||
});
|
||
|
||
it('uses stable fallbacks for empty message and tool IDs', () => {
|
||
expect(getToolVisibilityId('', '', 3)).toBe('message:tool:3');
|
||
|
||
const markdown = formatVisibleChatTranscript([{
|
||
role: 'assistant',
|
||
content: [{
|
||
type: 'tool_use',
|
||
id: '',
|
||
name: 'read',
|
||
input: { file: 'README.md' },
|
||
}],
|
||
}], {
|
||
showThinking: false,
|
||
showTimestamps: false,
|
||
expandedToolIds: new Set([
|
||
getToolVisibilityId('assistant-0', undefined, 0),
|
||
]),
|
||
});
|
||
|
||
expect(markdown).toContain('README.md');
|
||
});
|
||
});
|