@codingame/monaco-vscode-chat-service-override 26.2.2 → 28.0.0

package/vscode/src/vs/sessions/contrib/fileTreeView/browser/githubFileSystemProvider.js

@@ -0,0 +1,263 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { FileSystemProviderCapabilities, createFileSystemProviderError, FileSystemProviderErrorCode, FileType } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files';
+import { asJson } from '@codingame/monaco-vscode-api/vscode/vs/platform/request/common/request';
+import { IRequestService } from '@codingame/monaco-vscode-api/vscode/vs/platform/request/common/request.service';
+import { IAuthenticationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/authentication/common/authentication.service';
+import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+
+var GitHubFileSystemProvider_1;
+const GITHUB_REMOTE_FILE_SCHEME = "github-remote-file";
+let GitHubFileSystemProvider = class GitHubFileSystemProvider extends Disposable {
+    static {
+        GitHubFileSystemProvider_1 = this;
+    }
+    static {
+        this.CACHE_TTL_MS = 5 * 60 * 1000;
+    }
+    static {
+        this.NOT_FOUND_CACHE_TTL_MS = 60 * 1000;
+    }
+    constructor(requestService, authenticationService, logService) {
+        super();
+        this.requestService = requestService;
+        this.authenticationService = authenticationService;
+        this.logService = logService;
+        this._onDidChangeCapabilities = this._register(( new Emitter()));
+        this.onDidChangeCapabilities = this._onDidChangeCapabilities.event;
+        this.capabilities = FileSystemProviderCapabilities.Readonly | FileSystemProviderCapabilities.FileReadWrite | FileSystemProviderCapabilities.PathCaseSensitive;
+        this._onDidChangeFile = this._register(( new Emitter()));
+        this.onDidChangeFile = this._onDidChangeFile.event;
+        this.treeCache = ( new Map());
+        this.notFoundCache = ( new Map());
+        this.pendingFetches = ( new Map());
+    }
+    parseUri(resource) {
+        const parts = resource.path.split("/").filter(Boolean);
+        if (parts.length < 3) {
+            throw createFileSystemProviderError(
+                "Invalid github-remote-file URI: expected /{owner}/{repo}/{ref}/...",
+                FileSystemProviderErrorCode.FileNotFound
+            );
+        }
+        const owner = decodeURIComponent(parts[0]);
+        const repo = decodeURIComponent(parts[1]);
+        const ref = decodeURIComponent(parts[2]);
+        const path = ( parts.slice(3).map(decodeURIComponent)).join("/");
+        return {
+            owner,
+            repo,
+            ref,
+            path
+        };
+    }
+    getCacheKey(owner, repo, ref) {
+        return `${owner}/${repo}/${ref}`;
+    }
+    async getAuthToken() {
+        const sessions = (await this.authenticationService.getSessions("github", ["repo"], {
+            silent: true
+        })) ?? (await this.authenticationService.getSessions("github", ["repo"], {
+            createIfNone: true
+        }));
+        return sessions[0].accessToken ?? "";
+    }
+    fetchTree(owner, repo, ref) {
+        const cacheKey = this.getCacheKey(owner, repo, ref);
+        const cached = this.treeCache.get(cacheKey);
+        if (cached && (Date.now() - cached.fetchedAt) < GitHubFileSystemProvider_1.CACHE_TTL_MS) {
+            return Promise.resolve(cached);
+        }
+        const notFoundAt = this.notFoundCache.get(cacheKey);
+        if (notFoundAt !== undefined && (Date.now() - notFoundAt) < GitHubFileSystemProvider_1.NOT_FOUND_CACHE_TTL_MS) {
+            return Promise.reject(createFileSystemProviderError(
+                `Tree not found for ${owner}/${repo}@${ref}`,
+                FileSystemProviderErrorCode.FileNotFound
+            ));
+        }
+        const pending = this.pendingFetches.get(cacheKey);
+        if (pending) {
+            return pending;
+        }
+        const promise = this.doFetchTree(owner, repo, ref, cacheKey).finally(() => {
+            this.pendingFetches.delete(cacheKey);
+        });
+        this.pendingFetches.set(cacheKey, promise);
+        return promise;
+    }
+    async doFetchTree(owner, repo, ref, cacheKey) {
+        this.logService.info(`[SessionRepoFS] Fetching tree for ${owner}/${repo}@${ref}`);
+        const token = await this.getAuthToken();
+        const url = `https://api.github.com/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/git/trees/${encodeURIComponent(ref)}?recursive=1`;
+        const response = await this.requestService.request({
+            type: "GET",
+            url,
+            headers: {
+                "Authorization": `token ${token}`,
+                "Accept": "application/vnd.github.v3+json",
+                "User-Agent": "VSCode-SessionRepoFS"
+            }
+        }, CancellationToken.None);
+        if (response.res.statusCode === 404) {
+            this.notFoundCache.set(cacheKey, Date.now());
+            throw createFileSystemProviderError(
+                `Tree not found for ${owner}/${repo}@${ref}`,
+                FileSystemProviderErrorCode.FileNotFound
+            );
+        }
+        const data = await asJson(response);
+        if (!data) {
+            throw createFileSystemProviderError(
+                `Failed to fetch tree for ${owner}/${repo}@${ref}`,
+                FileSystemProviderErrorCode.Unavailable
+            );
+        }
+        const entries = ( new Map());
+        entries.set("", {
+            type: FileType.Directory,
+            size: 0,
+            sha: data.sha
+        });
+        const dirs = ( new Set());
+        for (const entry of data.tree) {
+            const fileType = entry.type === "tree" ? FileType.Directory : FileType.File;
+            entries.set(entry.path, {
+                type: fileType,
+                size: entry.size ?? 0,
+                sha: entry.sha
+            });
+            if (fileType === FileType.Directory) {
+                dirs.add(entry.path);
+            }
+            const pathParts = entry.path.split("/");
+            for (let i = 1; i < pathParts.length; i++) {
+                const parentPath = pathParts.slice(0, i).join("/");
+                if (!( dirs.has(parentPath))) {
+                    dirs.add(parentPath);
+                    if (!( entries.has(parentPath))) {
+                        entries.set(parentPath, {
+                            type: FileType.Directory,
+                            size: 0,
+                            sha: ""
+                        });
+                    }
+                }
+            }
+        }
+        const cacheEntry = {
+            entries,
+            fetchedAt: Date.now()
+        };
+        this.treeCache.set(cacheKey, cacheEntry);
+        return cacheEntry;
+    }
+    async stat(resource) {
+        const {
+            owner,
+            repo,
+            ref,
+            path
+        } = this.parseUri(resource);
+        const tree = await this.fetchTree(owner, repo, ref);
+        const entry = tree.entries.get(path);
+        if (!entry) {
+            throw createFileSystemProviderError("File not found", FileSystemProviderErrorCode.FileNotFound);
+        }
+        return {
+            type: entry.type,
+            ctime: 0,
+            mtime: 0,
+            size: entry.size
+        };
+    }
+    async readdir(resource) {
+        const {
+            owner,
+            repo,
+            ref,
+            path
+        } = this.parseUri(resource);
+        const tree = await this.fetchTree(owner, repo, ref);
+        const prefix = path ? path + "/" : "";
+        const result = [];
+        for (const [entryPath, entry] of tree.entries) {
+            if (!entryPath.startsWith(prefix)) {
+                continue;
+            }
+            const relativePath = entryPath.slice(prefix.length);
+            if (relativePath && !relativePath.includes("/")) {
+                result.push([relativePath, entry.type]);
+            }
+        }
+        return result;
+    }
+    async readFile(resource) {
+        const {
+            owner,
+            repo,
+            ref,
+            path
+        } = this.parseUri(resource);
+        const tree = await this.fetchTree(owner, repo, ref);
+        const entry = tree.entries.get(path);
+        if (!entry || entry.type === FileType.Directory) {
+            throw createFileSystemProviderError("File not found", FileSystemProviderErrorCode.FileNotFound);
+        }
+        const token = await this.getAuthToken();
+        const url = `https://api.github.com/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/git/blobs/${encodeURIComponent(entry.sha)}`;
+        const response = await this.requestService.request({
+            type: "GET",
+            url,
+            headers: {
+                "Authorization": `token ${token}`,
+                "Accept": "application/vnd.github.v3+json",
+                "User-Agent": "VSCode-SessionRepoFS"
+            }
+        }, CancellationToken.None);
+        const data = await asJson(response);
+        if (!data) {
+            throw createFileSystemProviderError(`Failed to read file ${path}`, FileSystemProviderErrorCode.Unavailable);
+        }
+        if (data.encoding === "base64") {
+            const binaryString = atob(data.content.replace(/\n/g, ""));
+            const bytes = ( new Uint8Array(binaryString.length));
+            for (let i = 0; i < binaryString.length; i++) {
+                bytes[i] = binaryString.charCodeAt(i);
+            }
+            return bytes;
+        }
+        return ( new TextEncoder()).encode(data.content);
+    }
+    watch() {
+        return Disposable.None;
+    }
+    async writeFile(_resource, _content, _opts) {
+        throw createFileSystemProviderError("Operation not supported", FileSystemProviderErrorCode.NoPermissions);
+    }
+    async mkdir(_resource) {
+        throw createFileSystemProviderError("Operation not supported", FileSystemProviderErrorCode.NoPermissions);
+    }
+    async delete(_resource, _opts) {
+        throw createFileSystemProviderError("Operation not supported", FileSystemProviderErrorCode.NoPermissions);
+    }
+    async rename(_from, _to, _opts) {
+        throw createFileSystemProviderError("Operation not supported", FileSystemProviderErrorCode.NoPermissions);
+    }
+    invalidateCache(owner, repo, ref) {
+        const cacheKey = this.getCacheKey(owner, repo, ref);
+        this.treeCache.delete(cacheKey);
+        this.notFoundCache.delete(cacheKey);
+    }
+    dispose() {
+        this.treeCache.clear();
+        this.notFoundCache.clear();
+        this.pendingFetches.clear();
+        super.dispose();
+    }
+};
+GitHubFileSystemProvider = GitHubFileSystemProvider_1 = ( __decorate([( __param(0, IRequestService)), ( __param(1, IAuthenticationService)), ( __param(2, ILogService))], GitHubFileSystemProvider));
+
+export { GITHUB_REMOTE_FILE_SCHEME, GitHubFileSystemProvider };

package/vscode/src/vs/sessions/contrib/sessions/browser/sessionsManagementService.d.ts

@@ -0,0 +1,85 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { RawContextKey } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey";
+import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { ISessionOpenOptions } from "@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsOpener";
+import { IChatWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service";
+import { IChatSessionsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service";
+import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service";
+import { IAgentSessionsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsService.service";
+import { ICommandService } from "@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service";
+import { AgentSessionProviders } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessions";
+import { INewSession } from "../../chat/browser/newSession.js";
+import { IUriIdentityService } from "@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service";
+import { ILanguageModelsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service";
+import { ISessionsManagementService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/sessions/browser/sessionsManagementService.service";
+export declare const IsNewChatSessionContext: RawContextKey<boolean>;
+/**
+ * True when the active session uses the Background provider type (copilotcli).
+ * Used to gate actions that require a local worktree (run script, open in VS Code, terminal).
+ */
+export declare const IsActiveSessionBackgroundProviderContext: RawContextKey<boolean>;
+/**
+ * An active session item extends IChatSessionItem with repository information.
+ * - For agent session items: repository is the workingDirectory from metadata
+ * - For new sessions: repository comes from the session option with id 'repository'
+ */
+export interface IActiveSessionItem {
+    readonly resource: URI;
+    readonly isUntitled: boolean;
+    readonly label: string | undefined;
+    readonly repository: URI | undefined;
+    readonly worktree: URI | undefined;
+    readonly providerType: string;
+}
+export declare class SessionsManagementService extends Disposable implements ISessionsManagementService {
+    private readonly storageService;
+    private readonly uriIdentityService;
+    private readonly agentSessionsService;
+    private readonly chatSessionsService;
+    private readonly chatWidgetService;
+    private readonly chatService;
+    private readonly instantiationService;
+    private readonly logService;
+    private readonly commandService;
+    private readonly languageModelsService;
+    readonly _serviceBrand: undefined;
+    private readonly _activeSession;
+    readonly activeSession: IObservable<IActiveSessionItem | undefined>;
+    private readonly _newActiveSessionDisposables;
+    private readonly _newSession;
+    private lastSelectedSession;
+    private readonly isNewChatSessionContext;
+    private readonly _isBackgroundProvider;
+    constructor(storageService: IStorageService, uriIdentityService: IUriIdentityService, agentSessionsService: IAgentSessionsService, chatSessionsService: IChatSessionsService, chatWidgetService: IChatWidgetService, chatService: IChatService, instantiationService: IInstantiationService, logService: ILogService, contextKeyService: IContextKeyService, commandService: ICommandService, languageModelsService: ILanguageModelsService);
+    private refreshActiveSessionFromModel;
+    private showNextSession;
+    private getRepositoryFromMetadata;
+    private getRepositoryFromSessionOption;
+    getActiveSession(): IActiveSessionItem | undefined;
+    openSession(sessionResource: URI, openOptions?: ISessionOpenOptions): Promise<void>;
+    createNewSessionForTarget(target: AgentSessionProviders, sessionResource: URI, defaultRepoUri?: URI): Promise<INewSession>;
+    /**
+     * Open an existing agent session - set it as active and reveal it.
+     */
+    private openExistingSession;
+    /**
+     * Open a new remote session - load the model first, then show it in the ChatViewPane.
+     */
+    private openNewSession;
+    sendRequestForNewSession(sessionResource: URI, options?: {
+        openNewSessionView?: boolean;
+    }): Promise<void>;
+    private doSendRequestForNewSession;
+    openNewSessionView(): void;
+    private setActiveSession;
+    private doSetActiveSession;
+    private equalsSessionItem;
+    commitWorktreeFiles(session: IActiveSessionItem, fileUris: URI[]): Promise<void>;
+    private loadLastSelectedSession;
+    private saveLastSelectedSession;
+}