@codingame/monaco-vscode-api 37.3.3 → 37.3.5

package/vscode/src/vs/workbench/contrib/chat/browser/actions/exportAgentHostDebugLogsAction.js

@@ -0,0 +1,670 @@
+
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { Action } from '../../../../../base/common/actions.js';
+import { newWriteableBufferStream, VSBuffer, streamToBuffer } from '../../../../../base/common/buffer.js';
+import { Schemas } from '../../../../../base/common/network.js';
+import { joinPath, basename, dirname } from '../../../../../base/common/resources.js';
+import { hasKey } from '../../../../../base/common/types.js';
+import { URI } from '../../../../../base/common/uri.js';
+import { localize, localize2 } from '../../../../../nls.js';
+import { Categories } from '../../../../../platform/action/common/actionCommonCategories.js';
+import { Action2 } from '../../../../../platform/actions/common/actions.js';
+import { IAgentHostConnectionsService } from '../../../../../platform/agentHost/common/agentHostConnectionsService.service.js';
+import { AGENT_HOST_ENABLED_CONTEXT_KEY } from '../../../../../platform/agentHost/common/agentHostEnablementService.js';
+import { IAgentHostService } from '../../../../../platform/agentHost/common/agentService.service.js';
+import { remoteAgentHostLogOutputChannelId } from '../../../../../platform/agentHost/common/remoteAgentHostService.js';
+import { IRemoteAgentHostService } from '../../../../../platform/agentHost/common/remoteAgentHostService.service.js';
+import { getSessionChatResource, StateComponents, DEFAULT_CHAT_ID } from '../../../../../platform/agentHost/common/state/sessionState.js';
+import { IClipboardService } from '../../../../../platform/clipboard/common/clipboardService.service.js';
+import { ContextKeyExpr } from '../../../../../platform/contextkey/common/contextkey.js';
+import { IsWebContext } from '../../../../../platform/contextkey/common/contextkeys.js';
+import { IFileDialogService } from '../../../../../platform/dialogs/common/dialogs.service.js';
+import { ByteSize } from '../../../../../platform/files/common/files.js';
+import { IFileService } from '../../../../../platform/files/common/files.service.js';
+import { ILogService } from '../../../../../platform/log/common/log.service.js';
+import '../../../../../platform/notification/common/notification.js';
+import { INotificationService } from '../../../../../platform/notification/common/notification.service.js';
+import { ProgressLocation } from '../../../../../platform/progress/common/progress.js';
+import { IProgressService } from '../../../../../platform/progress/common/progress.service.js';
+import { IChatEntitlementService } from '../../../../services/chat/common/chatEntitlementService.service.js';
+import { IWorkbenchEnvironmentService } from '../../../../services/environment/common/environmentService.service.js';
+import { IChatWidgetService } from '../chat.service.js';
+import { ChatContextKeys } from '../../common/actions/chatContextKeys.js';
+import { getCopilotCliSessionRawId, COPILOT_CLI_LOCAL_AH_SCHEME, parseRemoteAuthorityFromScheme } from '../copilotCliEventsUri.js';
+import { sanitizeFilePart, getRemoteConnectionForSession } from '../chatDebug/agentHostLogSources.js';
+import { buildAgentHostUsageUri, buildAgentHostCustomizationsUri } from '../chatDebug/agentHostUsageSidecar.js';
+import { IAgentHostDebugLogsExportService } from './exportAgentHostDebugLogsAction.service.js';
+import Severity$1 from '../../../../../base/common/severity.js';
+
+const SHARED_PROCESS_LOG_FILE_NAME = "sharedprocess.log";
+const OUTPUT_LOG_FOLDER_PREFIX = "output_";
+const MAX_INLINE_DEBUG_LOGS_BYTES = 30 * ByteSize.MB;
+let BrowserAgentHostDebugLogsExportService = class BrowserAgentHostDebugLogsExportService {
+    constructor(fileDialogService, fileService, logService) {
+        this.fileDialogService = fileDialogService;
+        this.fileService = fileService;
+        this.logService = logService;
+        this.hostArtifactKind = "directory";
+    }
+    async selectDestination(exportName) {
+        const folders = await this.fileDialogService.showOpenDialog({
+            title: ( localize(8011, "Select Folder for Agent Host Debug Logs")),
+            canSelectFiles: false,
+            canSelectFolders: true,
+            canSelectMany: false,
+            availableFileSystems: [Schemas.file]
+        });
+        return folders?.[0] ? joinPath(folders[0], exportName) : undefined;
+    }
+    async save(destination, files, hostArtifact) {
+        await exportFilesToLocalFolder(destination, files, hostArtifact, this.fileService, this.logService);
+    }
+};
+BrowserAgentHostDebugLogsExportService = ( __decorate([( __param(0, IFileDialogService)), ( __param(1, IFileService)), ( __param(2, ILogService))], BrowserAgentHostDebugLogsExportService));
+function resolveAgentHostDebugLogsChat(activeSession, state) {
+    let backendChat = activeSession.backendChatResource;
+    let sessionTitle = activeSession.sessionTitle;
+    if (state && !(state instanceof Error)) {
+        if (!backendChat) {
+            const backendChatResource = getSessionChatResource(state, activeSession.chatId);
+            if (backendChatResource) {
+                backendChat = ( URI.parse(backendChatResource));
+            }
+        }
+        sessionTitle ??= state.title;
+    }
+    return {
+        backendChat,
+        sessionTitle
+    };
+}
+function createHostArtifactStream(artifact, readChunk) {
+    const stream = newWriteableBufferStream();
+    (async () => {
+        let position = 0;
+        while (true) {
+            const chunk = await readChunk(position);
+            const byteLength = chunk.data.byteLength;
+            if (byteLength > 0) {
+                position += byteLength;
+                if (position > artifact.size) {
+                    throw ( new Error(
+                        `Agent Host debug log artifact exceeded its declared size of ${artifact.size} bytes`
+                    ));
+                }
+                await stream.write(chunk.data);
+            }
+            if (chunk.eof) {
+                break;
+            }
+            if (byteLength === 0) {
+                throw ( new Error(
+                    "Agent Host returned an empty debug log chunk before the end of the artifact"
+                ));
+            }
+        }
+        if (position !== artifact.size) {
+            throw ( new Error(
+                `Agent Host debug log artifact ended after ${position} bytes, expected ${artifact.size}`
+            ));
+        }
+        stream.end();
+    })().catch(error => {
+        stream.error(error instanceof Error ? error : ( new Error(String(error))));
+        stream.end();
+    });
+    return stream;
+}
+async function collectAgentHostDebugLogs(accessor, activeSession, onDidCreateHostArtifact) {
+    const agentHostService = accessor.get(IAgentHostService);
+    const agentHostConnectionsService = accessor.get(IAgentHostConnectionsService);
+    const remoteAgentHostService = accessor.get(IRemoteAgentHostService);
+    const fileService = accessor.get(IFileService);
+    const logService = accessor.get(ILogService);
+    const environmentService = accessor.get(IWorkbenchEnvironmentService);
+    const exportService = accessor.get(IAgentHostDebugLogsExportService);
+    let connection;
+    let backendSession;
+    let backendChat;
+    if (activeSession) {
+        const sessionResolution = agentHostConnectionsService.resolveSessionResource(activeSession.resource);
+        if (!sessionResolution) {
+            logService.warn(
+                `[ExportAgentHostDebugLogs] No live Agent Host connection owns session ${( activeSession.resource.toString())}; exporting client-owned logs only`
+            );
+        } else {
+            connection = sessionResolution.connection;
+            backendSession = sessionResolution.backendSession;
+            const state = connection.getSubscriptionUnmanaged(StateComponents.Session, backendSession)?.value;
+            backendChat = resolveAgentHostDebugLogsChat(activeSession, state).backendChat;
+            if (!backendChat) {
+                const reason = !state || state instanceof Error ? "session state is unavailable" : `chat '${activeSession.chatId}' is unavailable`;
+                logService.warn(
+                    `[ExportAgentHostDebugLogs] Cannot resolve the active chat because ${reason} for ${( activeSession.resource.toString())}; exporting session and client-owned logs`
+                );
+            }
+        }
+    } else {
+        connection = agentHostConnectionsService.ambientConnection;
+    }
+    let hostArtifact;
+    if (connection) {
+        try {
+            hostArtifact = await connection.collectDebugLogs(backendSession, exportService.hostArtifactKind, backendChat);
+            onDidCreateHostArtifact(hostArtifact);
+        } catch (error) {
+            logService.warn(
+                `[ExportAgentHostDebugLogs] Failed to collect Agent Host logs: ${error instanceof Error ? error.message : String(error)}; exporting client-owned logs only`
+            );
+        }
+    }
+    let remainingInlineBytes = MAX_INLINE_DEBUG_LOGS_BYTES;
+    const forwardedAgentHostLogFileNames = ( new Set());
+    let ahpLogNameFilter;
+    if (activeSession) {
+        if (activeSession.isLocal) {
+            const localClientId = sanitizeFilePart(agentHostService.clientId);
+            ahpLogNameFilter = name => name.includes(localClientId);
+        } else {
+            const remoteConnection = getRemoteConnectionForSession(activeSession.resource, remoteAgentHostService.connections);
+            if (remoteConnection) {
+                forwardedAgentHostLogFileNames.add(
+                    getOutputChannelLogFileName(remoteAgentHostLogOutputChannelId(remoteConnection.address))
+                );
+                const remoteConnectionId = sanitizeFilePart(remoteConnection.address);
+                ahpLogNameFilter = name => name.includes(remoteConnectionId);
+            }
+        }
+    } else {
+        for (const remoteConnection of remoteAgentHostService.connections) {
+            forwardedAgentHostLogFileNames.add(
+                getOutputChannelLogFileName(remoteAgentHostLogOutputChannelId(remoteConnection.address))
+            );
+        }
+    }
+    const files = [];
+    const appendFile = file => {
+        files.push(file);
+        if (hasKey(file, {
+            contents: true
+        })) {
+            remainingInlineBytes -= file.size;
+        }
+    };
+    const appendFiles = collectedFiles => {
+        for (const file of collectedFiles) {
+            appendFile(file);
+        }
+    };
+    const processLogs = [{
+        folder: "Window",
+        resource: environmentService.logFile
+    }, {
+        folder: "Shared",
+        resource: joinPath(environmentService.logsHome, SHARED_PROCESS_LOG_FILE_NAME)
+    }];
+    for (const processLog of processLogs) {
+        try {
+            appendFiles(await collectRotatedLogFiles(
+                `vscode-logs/${processLog.folder}`,
+                processLog.resource,
+                fileService,
+                remainingInlineBytes
+            ));
+        } catch (error) {
+            logService.warn(
+                `[ExportAgentHostDebugLogs] Failed to collect rotated logs for '${( processLog.resource.toString())}': ${error instanceof Error ? error.message : String(error)}`
+            );
+        }
+    }
+    try {
+        const forwardedLogs = await findOutputChannelLogFiles(
+            environmentService.windowLogsPath,
+            forwardedAgentHostLogFileNames,
+            fileService
+        );
+        for (const forwardedLog of forwardedLogs) {
+            const file = await createDebugLogFile(
+                `vscode-logs/Agent Host/${basename(forwardedLog)}`,
+                forwardedLog,
+                fileService,
+                undefined,
+                remainingInlineBytes
+            );
+            if (file) {
+                appendFile(file);
+            }
+        }
+    } catch (error) {
+        logService.warn(
+            `[ExportAgentHostDebugLogs] Failed to collect forwarded Agent Host logs: ${error instanceof Error ? error.message : String(error)}`
+        );
+    }
+    try {
+        const ahpDir = joinPath(environmentService.logsHome, "ahp");
+        const stat = await fileService.resolve(ahpDir, {
+            resolveMetadata: true
+        });
+        for (const child of stat.children ?? []) {
+            if (child.isDirectory || !child.name.endsWith(".jsonl") || ahpLogNameFilter && !ahpLogNameFilter(child.name)) {
+                continue;
+            }
+            try {
+                const file = await createDebugLogFile(
+                    `ahp/${child.name}`,
+                    child.resource,
+                    fileService,
+                    child.size,
+                    remainingInlineBytes
+                );
+                if (file) {
+                    appendFile(file);
+                }
+            } catch (error) {
+                logService.warn(
+                    `[ExportAgentHostDebugLogs] Failed to read AHP log '${child.name}': ${error instanceof Error ? error.message : String(error)}`
+                );
+            }
+        }
+    } catch {}
+    const rawSessionId = getCopilotCliSessionRawId(activeSession?.resource);
+    if (rawSessionId) {
+        const sidecars = [{
+            path: "usage.jsonl",
+            resource: buildAgentHostUsageUri(environmentService.userRoamingDataHome, rawSessionId)
+        }, {
+            path: "customizations.json",
+            resource: buildAgentHostCustomizationsUri(environmentService.userRoamingDataHome, rawSessionId)
+        }];
+        for (const sidecar of sidecars) {
+            try {
+                const file = await createDebugLogFile(
+                    sidecar.path,
+                    sidecar.resource,
+                    fileService,
+                    undefined,
+                    remainingInlineBytes
+                );
+                if (file) {
+                    appendFile(file);
+                }
+            } catch {}
+        }
+    }
+    return {
+        files,
+        hostArtifact: hostArtifact && connection ? {
+            artifact: hostArtifact,
+            readChunk: createChunkReader(connection)
+        } : undefined
+    };
+}
+function getAgentHostDebugLogsExportName(sessionTitle, chatTitle, isPrimaryChat) {
+    const namespace = [
+        toDebugLogsTitleSlug(sessionTitle),
+        ...(!isPrimaryChat ? [toDebugLogsTitleSlug(chatTitle)] : [])
+    ].filter(title => title.length > 0);
+    return namespace.length > 0 ? `ah-logs-${namespace.join("--")}` : "ah-logs";
+}
+function prepareAgentHostDebugLogsExport(selectDestination, collectLogs) {
+    const destinationPromise = selectDestination();
+    const collectionPromise = collectLogs();
+    return Promise.allSettled([collectionPromise, destinationPromise]);
+}
+function toDebugLogsTitleSlug(title) {
+    return title?.replace(/[/\\:*?"<>|\s]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40) ?? "";
+}
+function createChunkReader(connection) {
+    return (resource, position) => connection.readDebugLogsChunk(resource, position);
+}
+async function exportAgentHostDebugLogs(accessor, activeSession) {
+    const exportService = accessor.get(IAgentHostDebugLogsExportService);
+    const notificationService = accessor.get(INotificationService);
+    const chatEntitlementService = accessor.get(IChatEntitlementService);
+    const clipboardService = accessor.get(IClipboardService);
+    const fileService = accessor.get(IFileService);
+    const logService = accessor.get(ILogService);
+    const progressService = accessor.get(IProgressService);
+    let hostArtifact;
+    try {
+        const exportName = resolveAgentHostDebugLogsExportName(accessor, activeSession);
+        const [collectionResult, destinationResult] = await prepareAgentHostDebugLogsExport(
+            () => exportService.selectDestination(exportName),
+            () => progressService.withProgress({
+                location: ProgressLocation.Notification,
+                title: ( localize(8012, "Collecting Agent Host debug logs...")),
+                delay: 500
+            }, () => collectAgentHostDebugLogs(accessor, activeSession, artifact => hostArtifact = artifact))
+        );
+        if (collectionResult.status === "rejected") {
+            notificationService.notify({
+                severity: Severity$1.Error,
+                message: ( localize(
+                    8013,
+                    "Failed to collect debug logs: {0}",
+                    collectionResult.reason instanceof Error ? collectionResult.reason.message : String(collectionResult.reason)
+                ))
+            });
+            return;
+        }
+        if (destinationResult.status === "rejected") {
+            notificationService.notify({
+                severity: Severity$1.Error,
+                message: ( localize(
+                    8014,
+                    "Failed to save debug logs: {0}",
+                    destinationResult.reason instanceof Error ? destinationResult.reason.message : String(destinationResult.reason)
+                ))
+            });
+            return;
+        }
+        const destination = destinationResult.value;
+        if (!destination) {
+            return;
+        }
+        try {
+            await exportService.save(
+                destination,
+                collectionResult.value.files,
+                collectionResult.value.hostArtifact
+            );
+            notifyAgentHostDebugLogsExported(
+                notificationService,
+                clipboardService,
+                chatEntitlementService.isInternal,
+                destination
+            );
+        } catch (error) {
+            notificationService.notify({
+                severity: Severity$1.Error,
+                message: ( localize(
+                    8014,
+                    "Failed to save debug logs: {0}",
+                    error instanceof Error ? error.message : String(error)
+                ))
+            });
+        }
+    } finally {
+        if (hostArtifact) {
+            try {
+                await fileService.del(hostArtifact.resource, {
+                    recursive: hostArtifact.kind === "directory"
+                });
+            } catch (error) {
+                logService.warn(
+                    `[ExportAgentHostDebugLogs] Failed to delete temporary Agent Host log artifact: ${error instanceof Error ? error.message : String(error)}`
+                );
+            }
+        }
+    }
+}
+function resolveAgentHostDebugLogsExportName(accessor, activeSession) {
+    let sessionTitle = activeSession?.sessionTitle;
+    if (activeSession && !sessionTitle) {
+        const sessionResolution = accessor.get(IAgentHostConnectionsService).resolveSessionResource(activeSession.resource);
+        if (sessionResolution) {
+            const state = sessionResolution.connection.getSubscriptionUnmanaged(StateComponents.Session, sessionResolution.backendSession)?.value;
+            sessionTitle = resolveAgentHostDebugLogsChat(activeSession, state).sessionTitle;
+        }
+    }
+    return getAgentHostDebugLogsExportName(
+        sessionTitle,
+        activeSession?.chatTitle,
+        activeSession?.chatId === DEFAULT_CHAT_ID
+    );
+}
+function notifyAgentHostDebugLogsExported(notificationService, clipboardService, isInternal, savedResource) {
+    const savedPath = savedResource.scheme === Schemas.file ? savedResource.fsPath : ( savedResource.toString(true));
+    notificationService.notify({
+        severity: Severity$1.Warning,
+        message: isInternal ? ( localize(
+            8015,
+            "Note: This log may contain personal information such as auth tokens, file contents, or terminal output. It MUST be shared privately via Slack or in an issue filed on the microsoft/vscode-internalbacklog repo."
+        )) : ( localize(
+            8016,
+            "Note: This log may contain personal information such as auth tokens, file contents, or terminal output. Please consider sharing privately or reviewing the contents carefully before sharing."
+        )),
+        actions: {
+            primary: [( new Action("copyAgentHostDebugLogsPath", ( localize(8017, "Copy Path")), undefined, true, () => clipboardService.writeText(savedPath)))]
+        }
+    });
+}
+class ExportAgentHostDebugLogsAction extends Action2 {
+    static {
+        this.ID = "workbench.action.chat.exportAgentHostDebugLogs";
+    }
+    constructor() {
+        super({
+            id: ExportAgentHostDebugLogsAction.ID,
+            title: ( localize2(8018, "Export Agent Host Debug Logs...")),
+            f1: true,
+            category: Categories.Developer,
+            precondition: ( ContextKeyExpr.and(ChatContextKeys.enabled, ( IsWebContext.negate()), AGENT_HOST_ENABLED_CONTEXT_KEY))
+        });
+    }
+    async run(accessor) {
+        const chatWidgetService = accessor.get(IChatWidgetService);
+        const widget = chatWidgetService.lastFocusedWidget;
+        const model = widget?.viewModel?.model;
+        const activeSession = model ? toActiveAgentHostSession(model.sessionResource, model.title) : undefined;
+        await exportAgentHostDebugLogs(accessor, activeSession);
+    }
+}
+function toActiveAgentHostSession(resource, chatTitle, sessionTitle) {
+    if (resource.scheme === COPILOT_CLI_LOCAL_AH_SCHEME) {
+        return {
+            resource: resource.with({
+                fragment: null
+            }),
+            sessionTitle,
+            chatTitle,
+            isLocal: true,
+            chatId: resource.fragment || DEFAULT_CHAT_ID,
+            backendChatResource: undefined
+        };
+    }
+    if (parseRemoteAuthorityFromScheme(resource.scheme)) {
+        return {
+            resource: resource.with({
+                fragment: null
+            }),
+            sessionTitle,
+            chatTitle,
+            isLocal: false,
+            chatId: resource.fragment || DEFAULT_CHAT_ID,
+            backendChatResource: undefined
+        };
+    }
+    return undefined;
+}
+async function exportFilesToLocalFolder(exportFolder, files, hostArtifact, fileService, logService) {
+    await fileService.createFolder(exportFolder);
+    if (hostArtifact) {
+        try {
+            if (hostArtifact.artifact.kind !== "directory") {
+                throw ( new Error(
+                    `Expected an Agent Host debug-log directory, got ${hostArtifact.artifact.kind}`
+                ));
+            }
+            await copyHostArtifactDirectory(exportFolder, hostArtifact, fileService);
+        } catch (error) {
+            logService.warn(
+                `[ExportAgentHostDebugLogs] Failed to save Agent Host logs: ${error instanceof Error ? error.message : String(error)}; saving client-owned logs only`
+            );
+        }
+    }
+    for (const file of files) {
+        const segments = toSafeRelativePathSegments(file.path);
+        if (segments.length === 0) {
+            continue;
+        }
+        let folder = exportFolder;
+        for (const segment of segments.slice(0, -1)) {
+            folder = joinPath(folder, segment);
+            await fileService.createFolder(folder);
+        }
+        const target = joinPath(folder, segments[segments.length - 1]);
+        if (hasKey(file, {
+            contents: true
+        })) {
+            await fileService.writeFile(target, VSBuffer.fromString(file.contents));
+        } else {
+            const source = await fileService.readFileStream(file.resource, {
+                length: file.size
+            });
+            await fileService.writeFile(target, source.value);
+        }
+    }
+}
+async function copyHostArtifactDirectory(target, hostArtifact, fileService) {
+    let copiedSize = 0;
+    for (const entry of hostArtifact.artifact.entries) {
+        copiedSize += entry.size;
+        if (copiedSize > hostArtifact.artifact.uncompressedSize) {
+            throw ( new Error(
+                `Agent Host debug-log directory exceeded its declared size of ${hostArtifact.artifact.uncompressedSize} bytes`
+            ));
+        }
+        const source = joinPath(hostArtifact.artifact.resource, ...entry.path.split("/"));
+        const segments = toSafeRelativePathSegments(entry.path);
+        if (segments.length === 0) {
+            throw ( new Error(`Agent Host returned an invalid debug-log artifact path: ${entry.path}`));
+        }
+        let targetFolder = target;
+        for (const segment of segments.slice(0, -1)) {
+            targetFolder = joinPath(targetFolder, segment);
+            await fileService.createFolder(targetFolder);
+        }
+        const entryTarget = joinPath(targetFolder, segments[segments.length - 1]);
+        if (source.scheme === Schemas.file) {
+            const sourceStat = await fileService.resolve(source, {
+                resolveMetadata: true
+            });
+            if (!sourceStat.isFile || sourceStat.isSymbolicLink || sourceStat.size !== entry.size) {
+                throw ( new Error(`Agent Host debug-log file no longer matches its manifest: ${entry.path}`));
+            }
+            await fileService.copy(source, entryTarget, true);
+            continue;
+        }
+        const artifact = {
+            size: entry.size};
+        await fileService.writeFile(
+            entryTarget,
+            createHostArtifactStream(artifact, position => hostArtifact.readChunk(source, position))
+        );
+    }
+    if (copiedSize !== hostArtifact.artifact.uncompressedSize) {
+        throw ( new Error(
+            `Agent Host debug-log directory manifest accounts for ${copiedSize} bytes, expected ${hostArtifact.artifact.uncompressedSize}`
+        ));
+    }
+}
+async function createDebugLogFile(path, resource, fileService, size, maxInlineSize) {
+    if (resource.scheme === Schemas.file || resource.scheme === Schemas.vscodeUserData) {
+        const observedSize = size ?? (await fileService.resolve(resource, {
+            resolveMetadata: true
+        })).size;
+        return {
+            path,
+            resource,
+            size: observedSize
+        };
+    }
+    const observedSize = size ?? (await fileService.resolve(resource, {
+        resolveMetadata: true
+    })).size;
+    const readSize = Math.min(observedSize, maxInlineSize);
+    if (readSize === 0) {
+        return undefined;
+    }
+    const stream = await fileService.readFileStream(resource, {
+        position: observedSize - readSize,
+        length: readSize
+    });
+    return createInlineDebugLogFile(path, await streamToBuffer(stream.value), maxInlineSize);
+}
+function createInlineDebugLogFile(path, content, maxInlineSize) {
+    const size = Math.min(content.byteLength, maxInlineSize);
+    if (size === 0) {
+        return undefined;
+    }
+    const capturedContent = size === content.byteLength ? content : content.slice(content.byteLength - size);
+    return {
+        path,
+        contents: ( capturedContent.toString()),
+        size
+    };
+}
+async function collectRotatedLogFiles(path, current, fileService, maxInlineSize = MAX_INLINE_DEBUG_LOGS_BYTES) {
+    const currentName = basename(current);
+    const parent = await fileService.resolve(dirname(current), {
+        resolveMetadata: true
+    });
+    const files = [];
+    let remainingInlineSize = maxInlineSize;
+    for (const child of parent.children ?? []) {
+        if (child.isFile && !child.isSymbolicLink && isRotatedLogFile(child.name, currentName)) {
+            const file = await createDebugLogFile(
+                `${path}/${child.name}`,
+                child.resource,
+                fileService,
+                child.size,
+                remainingInlineSize
+            );
+            if (file) {
+                files.push(file);
+                if (hasKey(file, {
+                    contents: true
+                })) {
+                    remainingInlineSize -= file.size;
+                }
+            }
+        }
+    }
+    return files;
+}
+async function findOutputChannelLogFiles(windowLogsPath, fileNames, fileService) {
+    if (fileNames.size === 0) {
+        return [];
+    }
+    const windowLogs = await fileService.resolve(windowLogsPath);
+    const outputFolders = (windowLogs.children ?? []).filter(
+        child => child.isDirectory && child.name.startsWith(OUTPUT_LOG_FOLDER_PREFIX)
+    ).sort((a, b) => b.name.localeCompare(a.name));
+    const remaining = ( new Set(fileNames));
+    const result = [];
+    for (const outputFolder of outputFolders) {
+        const folder = await fileService.resolve(outputFolder.resource);
+        for (const child of folder.children ?? []) {
+            if (child.isFile && !child.isSymbolicLink && remaining.delete(child.name)) {
+                result.push(child.resource);
+            }
+        }
+        if (remaining.size === 0) {
+            break;
+        }
+    }
+    return result;
+}
+function getOutputChannelLogFileName(channelId) {
+    return `${channelId.replace(/[\\/:\*\?"<>\|]/g, "")}.log`;
+}
+function isRotatedLogFile(candidate, current) {
+    if (candidate === current) {
+        return true;
+    }
+    const stem = current.endsWith(".log") ? current.slice(0, -".log".length) : current;
+    const prefix = `${stem}.`;
+    if (!candidate.startsWith(prefix) || !candidate.endsWith(".log")) {
+        return false;
+    }
+    const rotation = candidate.slice(prefix.length, -".log".length);
+    return /^[1-9]\d*$/.test(rotation);
+}
+function toSafeRelativePathSegments(path) {
+    return path.replace(/\\/g, "/").split("/").filter(segment => {
+        return segment.length > 0 && segment !== "." && segment !== "..";
+    }).map(segment => segment.replace(/[/\\:*?"<>|]/g, "-"));
+}
+
+export { BrowserAgentHostDebugLogsExportService, ExportAgentHostDebugLogsAction, collectAgentHostDebugLogs, collectRotatedLogFiles, createHostArtifactStream, exportAgentHostDebugLogs, findOutputChannelLogFiles, getAgentHostDebugLogsExportName, notifyAgentHostDebugLogsExported, prepareAgentHostDebugLogsExport, resolveAgentHostDebugLogsChat, toActiveAgentHostSession };

package/vscode/src/vs/workbench/contrib/chat/browser/actions/exportAgentHostDebugLogsAction.service.d.ts

@@ -1,6 +1,6 @@
 import { AgentHostDebugLogsArtifactKind } from "../../../../../platform/agentHost/common/agentService.js";
 import { URI } from "../../../../../sessions/sessions.web.main.internal.js";
-import { IAgentHostDebugLogFile, IAgentHostDebugLogsHostArtifact } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/workbench/contrib/chat/browser/actions/exportAgentHostDebugLogsAction";
+import { IAgentHostDebugLogFile, IAgentHostDebugLogsHostArtifact } from "./exportAgentHostDebugLogsAction.js";
 export declare const IAgentHostDebugLogsExportService: import("../../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IAgentHostDebugLogsExportService>;
 export interface IAgentHostDebugLogsExportService {
     readonly _serviceBrand: undefined;