@codingame/monaco-vscode-chat-service-override 36.2.7 → 37.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/chatDebug/agentHostLogSources.d.ts

@@ -0,0 +1,132 @@
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IAgentHostService } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService.service";
+import { IRemoteAgentHostConnectionInfo } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/remoteAgentHostService";
+import { IRemoteAgentHostService } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/remoteAgentHostService.service";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IEnvironmentService } from "@codingame/monaco-vscode-api/vscode/vs/platform/environment/common/environment.service";
+import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IProductService } from "@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service";
+import { ITextModelService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/resolverService.service";
+import { IOutputService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/output/common/output.service";
+import { IPathService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/path/common/pathService.service";
+/** Bound the best-effort scan of Copilot SDK process logs. */
+export declare const MAX_COPILOT_LOG_SCAN_FILES = 10;
+export declare const MAX_COPILOT_LOG_SCAN_FILE_SIZE: number;
+/** Default cap for the amount of text loaded into the inline raw-log viewer. */
+export declare const DEFAULT_RAW_LOG_VIEW_CAP_BYTES: number;
+/**
+ * A selected Copilot process log that can be read lazily.
+ */
+export interface ICopilotLogFile {
+    readonly path: string;
+    readonly resource: URI;
+    readonly size: number;
+}
+/**
+ * Discriminates the kind of agent-host log a {@link IAgentHostLogSource}
+ * points at, so the viewer can pick the appropriate reader and syntax.
+ */
+export declare enum AgentHostLogSourceKind {
+    /** The Copilot CLI `events.jsonl` model/conversation stream. */
+    Events = "events",
+    /** The client-side AHP JSON-RPC wire log (`<logsHome>/ahp/*.jsonl`). */
+    WireLog = "wire",
+    /** The Copilot SDK process logs under `<COPILOT_HOME>/logs`. */
+    CliLog = "cliLog",
+    /** A VS Code output channel (agent host process, renderer, shared). */
+    ProcessChannel = "processChannel",
+    /** The remote machine's `agenthost.log`, downloaded on demand. */
+    RemoteProcessLog = "remoteProcessLog"
+}
+/**
+ * Describes one raw log source available for an agent-host session. Descriptors
+ * are cheap to enumerate; the actual (bounded) content is read lazily via
+ * {@link readAgentHostLogSourceContent} when the user selects the source.
+ */
+export interface IAgentHostLogSource {
+    readonly id: string;
+    readonly label: string;
+    readonly kind: AgentHostLogSourceKind;
+    readonly isRemote: boolean;
+    /** File resource for file-backed sources (events, wire log). */
+    readonly resource?: URI;
+    /** Output channel id for channel-backed sources. */
+    readonly channelId?: string;
+    /** Copilot logs directory + session id, for the lazy session-matched CLI log read. */
+    readonly cliLogs?: {
+        readonly dir: URI;
+        readonly rawSessionId: string;
+    };
+    /** Remote connection for lazily downloading `agenthost.log`. */
+    readonly remoteConnection?: IRemoteAgentHostConnectionInfo;
+}
+/** Bag of services required to enumerate and read agent-host log sources. */
+export interface IAgentHostLogSourceServices {
+    readonly pathService: IPathService;
+    readonly agentHostService: IAgentHostService;
+    readonly remoteAgentHostService: IRemoteAgentHostService;
+    readonly outputService: IOutputService;
+    readonly fileService: IFileService;
+    readonly textModelService: ITextModelService;
+    readonly configurationService: IConfigurationService;
+    readonly environmentService: IEnvironmentService;
+    readonly productService: IProductService;
+    readonly logService: ILogService;
+}
+/** Result of a bounded raw-log read. */
+export interface IAgentHostLogContent {
+    readonly text: string;
+    /** Total size of the underlying source in bytes, when known. */
+    readonly totalBytes: number | undefined;
+    /** True when only the tail of the source was loaded. */
+    readonly truncated: boolean;
+    /** Full-fidelity resource to open in an editor, when the source is file-backed. */
+    readonly fileResource?: URI;
+}
+/**
+ * Returns true when the chat session belongs to an agent host (local or
+ * remote Copilot CLI). Only these sessions have AHP logs and agent-host
+ * process logs, so the AHP Log view is gated on this.
+ */
+export declare function isAgentHostSession(resource: URI | undefined): boolean;
+/**
+ * Resolves the remote agent-host connection that backs a given remote session
+ * URI, or `undefined` for local/unknown sessions.
+ */
+export declare function getRemoteConnectionForSession(sessionResource: URI, connections: readonly IRemoteAgentHostConnectionInfo[]): IRemoteAgentHostConnectionInfo | undefined;
+/** Sanitizes a value for use as (part of) a file name. */
+export declare function sanitizeFilePart(value: string): string;
+/**
+ * Enumerates the raw log sources available for a given agent-host session.
+ * Cheap: performs at most a couple of directory stats and never reads file
+ * contents. Returns an empty array for non-agent-host sessions.
+ */
+export declare function enumerateAgentHostLogSources(services: IAgentHostLogSourceServices, sessionResource: URI | undefined): Promise<IAgentHostLogSource[]>;
+/**
+ * Reads the (bounded) content of a log source. File-backed sources are tailed
+ * to at most `capBytes`; the returned {@link IAgentHostLogContent.fileResource}
+ * lets callers offer an "open full file" affordance.
+ */
+export declare function readAgentHostLogSourceContent(source: IAgentHostLogSource, services: IAgentHostLogSourceServices, capBytes?: number): Promise<IAgentHostLogContent | undefined>;
+/**
+ * Reads Copilot process logs selected for a session, or the newest log when
+ * none mention the session id. Bounded by
+ * {@link MAX_COPILOT_LOG_SCAN_FILES} and {@link MAX_COPILOT_LOG_SCAN_FILE_SIZE}.
+ */
+export declare function readCopilotLogsForSession(logsDir: URI, rawSessionId: string, fileService: IFileService, logService: ILogService): Promise<{
+    path: string;
+    contents: string;
+}[]>;
+/**
+ * Scans a bounded set of Copilot process logs for the session id, falling back
+ * to the newest process log when no match can be found.
+ */
+export declare function findRelevantCopilotLogs(logsDir: URI, rawSessionId: string | undefined, fileService: IFileService, logService: ILogService): Promise<ICopilotLogFile[]>;
+/**
+ * Reads the remote agent host's `agenthost.log` from the remote machine via the
+ * `vscode-agent-host://` filesystem proxy. The CLI launches the server with its
+ * default data dir at `<home>/<serverDataFolderName>/data/logs/<datestamp>/`,
+ * so we list the logs directory and pick the most recent date-stamped folder.
+ */
+export declare function readRemoteAgentHostLog(connection: IRemoteAgentHostConnectionInfo, serverDataFolderName: string | undefined, fileService: IFileService): Promise<string | undefined>;

package/vscode/src/vs/workbench/contrib/chat/browser/chatDebug/agentHostLogSources.js

@@ -0,0 +1,446 @@
+
+import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { joinPath } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { agentHostAuthority, toAgentHostUri } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostUri';
+import { AgentHostAhpJsonlLoggingSettingId } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService';
+import { AGENT_HOST_LOG_OUTPUT_CHANNEL_ID, remoteAgentHostLogOutputChannelId } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/remoteAgentHostService';
+import { COPILOT_CLI_LOCAL_AH_SCHEME, parseRemoteAuthorityFromScheme, resolveEventsUri, getCopilotCliSessionRawId, buildLocalCopilotLogsUri, buildRemoteCopilotLogsUri } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/copilotCliEventsUri';
+
+const WINDOW_LOG_CHANNEL_ID = "rendererLog";
+const SHARED_PROCESS_LOG_CHANNEL_ID = "shared";
+const MAX_COPILOT_LOG_SCAN_FILES = 10;
+const MAX_COPILOT_LOG_SCAN_FILE_SIZE = 1024 * 1024 * 1024;
+const MAX_COPILOT_LOG_VIEW_FILE_SIZE = 10 * 1024 * 1024;
+const DEFAULT_RAW_LOG_VIEW_CAP_BYTES = 2 * 1024 * 1024;
+var AgentHostLogSourceKind;
+(function(AgentHostLogSourceKind) {
+    AgentHostLogSourceKind["Events"] = "events";
+    AgentHostLogSourceKind["WireLog"] = "wire";
+    AgentHostLogSourceKind["CliLog"] = "cliLog";
+    AgentHostLogSourceKind["ProcessChannel"] = "processChannel";
+    AgentHostLogSourceKind["RemoteProcessLog"] = "remoteProcessLog";
+})(AgentHostLogSourceKind || (AgentHostLogSourceKind = {}));
+function isAgentHostSession(resource) {
+    if (!resource) {
+        return false;
+    }
+    return resource.scheme === COPILOT_CLI_LOCAL_AH_SCHEME || !!parseRemoteAuthorityFromScheme(resource.scheme);
+}
+function getRemoteConnectionForSession(sessionResource, connections) {
+    const authority = parseRemoteAuthorityFromScheme(sessionResource.scheme);
+    return authority ? connections.find(connection => agentHostAuthority(connection.address) === authority) : undefined;
+}
+function sanitizeFilePart(value) {
+    return value.replace(/[\\/:\*\?"<>|\s]+/g, "-").replace(/^-+|-+$/g, "") || "connection";
+}
+async function enumerateAgentHostLogSources(services, sessionResource) {
+    if (!isAgentHostSession(sessionResource) || !sessionResource) {
+        return [];
+    }
+    const {
+        pathService,
+        agentHostService,
+        remoteAgentHostService,
+        outputService,
+        fileService,
+        configurationService,
+        environmentService
+    } = services;
+    const userHome = pathService.userHome({
+        preferLocal: true
+    });
+    const isLocal = sessionResource.scheme === COPILOT_CLI_LOCAL_AH_SCHEME;
+    const remoteConnection = isLocal ? undefined : getRemoteConnectionForSession(sessionResource, remoteAgentHostService.connections);
+    const sources = [];
+    const eventsResult = resolveEventsUri(
+        sessionResource,
+        userHome,
+        authority => remoteAgentHostService.connections.find(c => agentHostAuthority(c.address) === authority)
+    );
+    if (eventsResult.kind === "ok") {
+        sources.push({
+            id: "events",
+            label: ( localize(7577, "Session Events (events.jsonl)")),
+            kind: AgentHostLogSourceKind.Events,
+            isRemote: !isLocal,
+            resource: eventsResult.resource
+        });
+    }
+    if (configurationService.getValue(AgentHostAhpJsonlLoggingSettingId)) {
+        const nameToken = isLocal ? sanitizeFilePart(agentHostService.clientId) : remoteConnection ? sanitizeFilePart(remoteConnection.address) : undefined;
+        const wireFiles = await listWireLogFiles(fileService, environmentService, nameToken);
+        wireFiles.forEach((file, index) => {
+            sources.push({
+                id: `wire:${( file.resource.toString())}`,
+                label: index === 0 ? ( localize(7578, "AHP Log")) : ( localize(7579, "AHP Log — {0}", file.name)),
+                kind: AgentHostLogSourceKind.WireLog,
+                isRemote: !isLocal,
+                resource: file.resource
+            });
+        });
+    }
+    const channelIds = [];
+    if (isLocal) {
+        channelIds.push(AGENT_HOST_LOG_OUTPUT_CHANNEL_ID);
+    } else if (remoteConnection) {
+        channelIds.push(remoteAgentHostLogOutputChannelId(remoteConnection.address));
+    }
+    channelIds.push(WINDOW_LOG_CHANNEL_ID, SHARED_PROCESS_LOG_CHANNEL_ID);
+    for (const channelId of channelIds) {
+        const descriptor = outputService.getChannelDescriptor(channelId);
+        if (!descriptor) {
+            continue;
+        }
+        sources.push({
+            id: `channel:${channelId}`,
+            label: ( localize(7580, "{0} (Log)", descriptor.label)),
+            kind: AgentHostLogSourceKind.ProcessChannel,
+            isRemote: !isLocal,
+            channelId
+        });
+    }
+    if (remoteConnection?.defaultDirectory) {
+        sources.push({
+            id: "remoteProcessLog",
+            label: ( localize(7581, "Remote Agent Host Log (agenthost.log)")),
+            kind: AgentHostLogSourceKind.RemoteProcessLog,
+            isRemote: true,
+            remoteConnection
+        });
+    }
+    const rawSessionId = getCopilotCliSessionRawId(sessionResource);
+    if (rawSessionId) {
+        const copilotLogsDir = isLocal ? buildLocalCopilotLogsUri(userHome) : remoteConnection ? buildRemoteCopilotLogsUri(remoteConnection) : undefined;
+        if (copilotLogsDir) {
+            sources.push({
+                id: "cliLog",
+                label: ( localize(7582, "Copilot Logs")),
+                kind: AgentHostLogSourceKind.CliLog,
+                isRemote: !isLocal,
+                cliLogs: {
+                    dir: copilotLogsDir,
+                    rawSessionId
+                }
+            });
+        }
+    }
+    return sources;
+}
+async function readAgentHostLogSourceContent(source, services, capBytes = DEFAULT_RAW_LOG_VIEW_CAP_BYTES) {
+    const {
+        fileService,
+        outputService,
+        textModelService,
+        productService,
+        logService
+    } = services;
+    switch (source.kind) {
+    case AgentHostLogSourceKind.Events:
+    case AgentHostLogSourceKind.WireLog:
+        {
+            if (!source.resource) {
+                return undefined;
+            }
+            return readFileTail(fileService, source.resource, capBytes);
+        }
+    case AgentHostLogSourceKind.ProcessChannel:
+        {
+            if (!source.channelId) {
+                return undefined;
+            }
+            const channel = outputService.getChannel(source.channelId);
+            if (!channel) {
+                return undefined;
+            }
+            const modelRef = await textModelService.createModelReference(channel.uri);
+            try {
+                const value = modelRef.object.textEditorModel.getValue();
+                return tailString(value, capBytes);
+            } finally {
+                modelRef.dispose();
+            }
+        }
+    case AgentHostLogSourceKind.RemoteProcessLog:
+        {
+            if (!source.remoteConnection) {
+                return undefined;
+            }
+            const value = await readRemoteAgentHostLog(source.remoteConnection, productService.serverDataFolderName, fileService);
+            return value === undefined ? undefined : tailString(value, capBytes);
+        }
+    case AgentHostLogSourceKind.CliLog:
+        {
+            if (!source.cliLogs) {
+                return undefined;
+            }
+            const files = await readCopilotLogsForSession(source.cliLogs.dir, source.cliLogs.rawSessionId, fileService, logService);
+            if (files.length === 0) {
+                return {
+                    text: "",
+                    totalBytes: 0,
+                    truncated: false
+                };
+            }
+            const combined = ( files.map(f => `===== ${f.path} =====\n${f.contents}`)).join("\n\n");
+            return tailString(combined, capBytes);
+        }
+    }
+}
+async function listWireLogFiles(fileService, environmentService, nameToken) {
+    const ahpDir = joinPath(environmentService.logsHome, "ahp");
+    let children;
+    try {
+        children = (await fileService.resolve(ahpDir, {
+            resolveMetadata: true
+        })).children;
+    } catch {
+        return [];
+    }
+    const files = ( (children ?? []).filter(child => !child.isDirectory && child.name.endsWith(".jsonl")).map(child => ({
+        resource: child.resource,
+        name: child.name,
+        mtime: child.mtime ?? 0
+    })));
+    const matching = nameToken ? files.filter(file => file.name.includes(nameToken)) : [];
+    const selected = matching.length > 0 ? matching : files;
+    return selected.sort((a, b) => b.mtime - a.mtime);
+}
+async function readFileTail(fileService, resource, capBytes) {
+    let size;
+    try {
+        size = (await fileService.resolve(resource, {
+            resolveMetadata: true
+        })).size;
+    } catch {
+        size = undefined;
+    }
+    if (size !== undefined && size > capBytes) {
+        const content = await fileService.readFile(resource, {
+            position: size - capBytes,
+            length: capBytes
+        });
+        let text = ( content.value.toString());
+        const firstNewline = text.indexOf("\n");
+        if (firstNewline >= 0) {
+            text = text.slice(firstNewline + 1);
+        }
+        return {
+            text,
+            totalBytes: size,
+            truncated: true,
+            fileResource: resource
+        };
+    }
+    const content = await fileService.readFile(resource, {
+        limits: {
+            size: capBytes
+        }
+    });
+    return {
+        text: ( content.value.toString()),
+        totalBytes: size,
+        truncated: false,
+        fileResource: resource
+    };
+}
+function tailString(value, capBytes) {
+    if (value.length <= capBytes) {
+        return {
+            text: value,
+            totalBytes: value.length,
+            truncated: false
+        };
+    }
+    let text = value.slice(value.length - capBytes);
+    const firstNewline = text.indexOf("\n");
+    if (firstNewline >= 0) {
+        text = text.slice(firstNewline + 1);
+    }
+    return {
+        text,
+        totalBytes: value.length,
+        truncated: true
+    };
+}
+async function readCopilotLogsForSession(logsDir, rawSessionId, fileService, logService) {
+    const matchingLogs = await findRelevantCopilotLogs(logsDir, rawSessionId, fileService, logService);
+    const files = [];
+    for (const log of matchingLogs) {
+        try {
+            const content = log.size > MAX_COPILOT_LOG_VIEW_FILE_SIZE ? await fileService.readFile(log.resource, {
+                position: log.size - MAX_COPILOT_LOG_VIEW_FILE_SIZE,
+                length: MAX_COPILOT_LOG_VIEW_FILE_SIZE
+            }) : await fileService.readFile(log.resource, {
+                limits: {
+                    size: MAX_COPILOT_LOG_VIEW_FILE_SIZE
+                }
+            });
+            files.push({
+                path: log.path,
+                contents: ( content.value.toString())
+            });
+        } catch (error) {
+            logService.warn(
+                `[AgentHostLogSources] Failed to read Copilot log '${log.resource.path}': ${error instanceof Error ? error.message : String(error)}`
+            );
+        }
+    }
+    return files;
+}
+async function findRelevantCopilotLogs(logsDir, rawSessionId, fileService, logService) {
+    let children;
+    try {
+        children = (await fileService.resolve(logsDir, {
+            resolveMetadata: true
+        })).children;
+    } catch {
+        return [];
+    }
+    const processLogs = ( (children ?? []).filter(child => !child.isDirectory && child.name.endsWith(".log")).sort((a, b) => b.mtime - a.mtime).map(child => ({
+        path: `copilot-logs/${child.name}`,
+        resource: child.resource,
+        size: child.size
+    })));
+    const files = [];
+    const candidateLogs = processLogs.slice(0, MAX_COPILOT_LOG_SCAN_FILES).filter(child => child.size <= MAX_COPILOT_LOG_SCAN_FILE_SIZE);
+    if (rawSessionId) {
+        for (const candidate of candidateLogs) {
+            try {
+                if (await logStreamContains(candidate.resource, rawSessionId, fileService)) {
+                    files.push(candidate);
+                }
+            } catch (error) {
+                logService.warn(
+                    `[AgentHostLogSources] Failed to scan Copilot log '${candidate.path}': ${error instanceof Error ? error.message : String(error)}`
+                );
+            }
+        }
+    }
+    return files.length > 0 ? files : processLogs.slice(0, 1);
+}
+async function logStreamContains(resource, rawSessionId, fileService) {
+    const tokenSource = ( new CancellationTokenSource());
+    let stream;
+    try {
+        stream = (await fileService.readFileStream(resource, {
+            length: MAX_COPILOT_LOG_SCAN_FILE_SIZE,
+            limits: {
+                size: MAX_COPILOT_LOG_SCAN_FILE_SIZE
+            }
+        }, tokenSource.token)).value;
+    } catch (error) {
+        tokenSource.dispose(true);
+        throw error;
+    }
+    return ( new Promise((resolve, reject) => {
+        let settled = false;
+        let previous = "";
+        const cleanup = removeErrorListener => {
+            stream.removeListener("data", onData);
+            stream.removeListener("end", onEnd);
+            if (removeErrorListener) {
+                stream.removeListener("error", onError);
+            }
+        };
+        const settle = contains => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            tokenSource.dispose(contains);
+            cleanup(!contains);
+            resolve(contains);
+        };
+        const onData = chunk => {
+            const text = previous + ( chunk.toString());
+            if (text.includes(rawSessionId)) {
+                settle(true);
+                return;
+            }
+            previous = text.slice(Math.max(0, text.length - rawSessionId.length + 1));
+        };
+        const onError = error => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            tokenSource.dispose();
+            cleanup(true);
+            reject(error);
+        };
+        const onEnd = () => {
+            settle(false);
+        };
+        stream.on("error", onError);
+        stream.on("end", onEnd);
+        stream.on("data", onData);
+    }));
+}
+async function readRemoteAgentHostLog(connection, serverDataFolderName, fileService) {
+    const homePath = connection.defaultDirectory;
+    if (!homePath) {
+        return undefined;
+    }
+    const authority = agentHostAuthority(connection.address);
+    const homeUri = toAgentHostUri(( URI.from({
+        scheme: "file",
+        path: homePath
+    })), authority);
+    const candidates = ( new Set());
+    if (serverDataFolderName) {
+        candidates.add(serverDataFolderName);
+        if (serverDataFolderName.endsWith("-dev")) {
+            candidates.add(serverDataFolderName.slice(0, -"-dev".length));
+        }
+    }
+    candidates.add(".vscode-server");
+    candidates.add(".vscode-server-insiders");
+    candidates.add(".vscode-server-oss");
+    candidates.add(".vscode-server-exploration");
+    let best;
+    for (const folderName of candidates) {
+        const logsDirUri = joinPath(homeUri, folderName, "data", "logs");
+        let entries;
+        try {
+            const stat = await fileService.resolve(logsDirUri, {
+                resolveMetadata: true
+            });
+            entries = stat.children;
+        } catch {
+            continue;
+        }
+        if (!entries) {
+            continue;
+        }
+        for (const dir of entries) {
+            if (!dir.isDirectory) {
+                continue;
+            }
+            const logUri = joinPath(dir.resource, "agenthost.log");
+            let logStat;
+            try {
+                logStat = await fileService.resolve(logUri, {
+                    resolveMetadata: true
+                });
+            } catch {
+                continue;
+            }
+            const mtime = logStat.mtime ?? 0;
+            if (!best || mtime > best.mtime) {
+                best = {
+                    uri: logUri,
+                    mtime
+                };
+            }
+        }
+    }
+    if (!best) {
+        return undefined;
+    }
+    const content = await fileService.readFile(best.uri);
+    return ( content.value.toString());
+}
+
+export { AgentHostLogSourceKind, DEFAULT_RAW_LOG_VIEW_CAP_BYTES, MAX_COPILOT_LOG_SCAN_FILES, MAX_COPILOT_LOG_SCAN_FILE_SIZE, enumerateAgentHostLogSources, findRelevantCopilotLogs, getRemoteConnectionForSession, isAgentHostSession, readAgentHostLogSourceContent, readCopilotLogsForSession, readRemoteAgentHostLog, sanitizeFilePart };