@codingame/monaco-vscode-api 31.0.1 → 32.0.0

package/vscode/src/vs/platform/agentHost/common/agentHostPermissionService.service.d.ts

@@ -0,0 +1,47 @@
+import { IDisposable } from "../../../base/common/lifecycle.js";
+import { IObservable } from "../../../base/common/observable.js";
+import { URI } from "../../../base/common/uri.js";
+import { AgentHostPermissionMode, IPendingResourceRequest } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentHost/common/agentHostPermissionService";
+import { ResourceRequestParams } from "./state/protocol/commands.js";
+export declare const IAgentHostPermissionService: import("../../instantiation/common/instantiation.js").ServiceIdentifier<IAgentHostPermissionService>;
+export interface IAgentHostPermissionService {
+    readonly _serviceBrand: undefined;
+    /**
+    * Returns whether {@link uri} is already granted for {@link mode} on
+    * {@link address}, considering implicit read grants, in-memory session
+    * grants, and persisted permissions. The URI is canonicalized through
+    * the file service (realpath) before comparison so symlinks and `..`
+    * traversal cannot bypass a grant.
+    */
+    check(address: string, uri: URI, mode: AgentHostPermissionMode): Promise<boolean>;
+    /**
+    * Handle an inbound `resourceRequest` from a host. Resolves once access
+    * is granted (immediately, if {@link check} already covers the request);
+    * rejects if the user denies or the connection closes.
+    */
+    request(address: string, params: ResourceRequestParams): Promise<void>;
+    /** Per-address observable of pending requests for UI surfaces. */
+    pendingFor(address: string): IObservable<readonly IPendingResourceRequest[]>;
+    /**
+    * Observable of all pending requests across every address. Useful for
+    * surfaces that aren't scoped to a single session/connection.
+    */
+    readonly allPending: IObservable<readonly IPendingResourceRequest[]>;
+    /**
+    * Find a pending request by id, across all addresses. Returns
+    * `undefined` once the request has been resolved or rejected.
+    */
+    findPending(id: string): IPendingResourceRequest | undefined;
+    /**
+    * Register an implicit read grant for {@link uri} (and descendants) on
+    * {@link address}. Used by call sites that are about to send a URI to a
+    * host and therefore expect that host to read it back. The returned
+    * disposable revokes the grant.
+    */
+    grantImplicitRead(address: string, uri: URI): IDisposable;
+    /**
+    * Notify that the connection at {@link address} has closed. Drops all
+    * implicit grants and rejects any outstanding pending requests.
+    */
+    connectionClosed(address: string): void;
+}

package/vscode/src/vs/platform/agentHost/common/agentHostPermissionService.service.js

@@ -0,0 +1,6 @@
+
+import { createDecorator } from '../../instantiation/common/instantiation.js';
+
+const IAgentHostPermissionService = ( createDecorator("agentHostPermissionService"));
+
+export { IAgentHostPermissionService };

package/vscode/src/vs/platform/agentHost/common/agentHostUri.js

@@ -59,7 +59,7 @@ function agentHostAuthority(address) {
     if (/^[a-zA-Z0-9.:\-]+$/.test(normalized)) {
         return normalized.replaceAll(":", "__");
     }
-    return "b64-" + encodeBase64(VSBuffer.fromString(normalized), false, true);
+    return `b64-${encodeBase64(VSBuffer.fromString(normalized), false, true)}`;
 }
 const AGENT_HOST_LABEL_FORMATTER = {
     scheme: AGENT_HOST_SCHEME,

package/vscode/src/vs/platform/agentHost/common/agentPluginManager.d.ts

@@ -1,11 +1,11 @@
 import { URI } from "../../../base/common/uri.js";
-import type { ISessionCustomization } from "@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/sessionState";
+import type { SessionCustomization } from "@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/sessionState";
 /**
  * A synced customization with its local plugin directory (when available).
  */
 export interface ISyncedCustomization {
     /** The session customization with loading/error status. */
-    readonly customization: ISessionCustomization;
+    readonly customization: SessionCustomization;
     /** Local plugin directory URI, defined when the sync was successful. */
     readonly pluginDir?: URI;
 }

package/vscode/src/vs/platform/agentHost/common/agentService.service.d.ts

@@ -1,11 +1,11 @@
 import { Event } from "../../../base/common/event.js";
 import { IObservable } from "../../../base/common/observable.js";
 import { URI } from "../../../base/common/uri.js";
-import { IAuthenticateParams, IAuthenticateResult, IAgentSessionMetadata, IAgentCreateSessionConfig, IAgentResolveSessionConfigParams, IAgentSessionConfigCompletionsParams, type IAgentConnection, type IAgentHostSocketInfo } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentHost/common/agentService";
-import { IResolveSessionConfigResult, ISessionConfigCompletionsResult, ICreateTerminalParams } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentHost/common/state/protocol/commands";
-import { IActionEnvelope, INotification, ISessionAction, ITerminalAction } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentHost/common/state/sessionActions";
-import { IResourceListResult, IResourceReadResult, IResourceWriteParams, IResourceWriteResult, IResourceCopyParams, IResourceCopyResult, IResourceDeleteParams, IResourceDeleteResult, IResourceMoveParams, IResourceMoveResult } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentHost/common/state/sessionProtocol";
-import { ISnapshot as IStateSnapshot } from "@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/sessionState";
+import { AuthenticateParams, AuthenticateResult, IAgentSessionMetadata, IAgentCreateSessionConfig, IAgentResolveSessionConfigParams, IAgentSessionConfigCompletionsParams, type IAgentConnection, type IAgentHostInspectInfo, type IAgentHostSocketInfo } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentHost/common/agentService";
+import { ResolveSessionConfigResult, SessionConfigCompletionsResult, CompletionsParams, CompletionsResult, CreateTerminalParams } from "./state/protocol/commands.js";
+import { ActionEnvelope, INotification, SessionAction, TerminalAction, IRootConfigChangedAction } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentHost/common/state/sessionActions";
+import { ResourceListResult, ResourceReadResult, ResourceWriteParams, ResourceWriteResult, ResourceCopyParams, ResourceCopyResult, ResourceDeleteParams, ResourceDeleteResult, ResourceMoveParams, ResourceMoveResult } from "./state/sessionProtocol.js";
+import { Snapshot as IStateSnapshot } from "@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/sessionState";
 export declare const IAgentService: import("../../instantiation/common/instantiation.js").ServiceIdentifier<IAgentService>;
 /**
 * Service contract for communicating with the agent host process. Methods here
@@ -19,23 +19,42 @@ export interface IAgentService {
     readonly _serviceBrand: undefined;
     /**
     * Authenticate for a protected resource on the server.
-    * The {@link IAuthenticateParams.resource} must match a resource from
+    * The {@link AuthenticateParams.resource} must match a resource from
     * the agent's protectedResources in root state. Analogous to RFC 6750
     * bearer token delivery.
     */
-    authenticate(params: IAuthenticateParams): Promise<IAuthenticateResult>;
+    authenticate(params: AuthenticateParams): Promise<AuthenticateResult>;
     /** List all available sessions from the Copilot CLI. */
     listSessions(): Promise<IAgentSessionMetadata[]>;
     /** Create a new session. Returns the session URI. */
     createSession(config?: IAgentCreateSessionConfig): Promise<URI>;
     /** Resolve the dynamic configuration schema for creating a session. */
-    resolveSessionConfig(params: IAgentResolveSessionConfigParams): Promise<IResolveSessionConfigResult>;
+    resolveSessionConfig(params: IAgentResolveSessionConfigParams): Promise<ResolveSessionConfigResult>;
     /** Return dynamic completions for a session configuration property. */
-    sessionConfigCompletions(params: IAgentSessionConfigCompletionsParams): Promise<ISessionConfigCompletionsResult>;
+    sessionConfigCompletions(params: IAgentSessionConfigCompletionsParams): Promise<SessionConfigCompletionsResult>;
+    /**
+    * Return completion items for a partially-typed input (e.g. an `@`-mention
+    * inside a user message the user is composing). Delegates to a pluggable
+    * set of {@link IAgentHostCompletionItemProvider}s registered with the
+    * agent host.
+    *
+    * Note: this method does not accept a {@link CancellationToken} because
+    * `CancellationToken`s do not round-trip through the IPC boundary today
+    * (the deserialised value lacks the prototype methods used by
+    * subscribers). Callers that need cancellation should race the returned
+    * promise on their own side.
+    */
+    completions(params: CompletionsParams): Promise<CompletionsResult>;
+    /**
+    * Returns the set of characters that, when typed in a {@link UserMessage}
+    * input, SHOULD cause the client to issue a `completions` request.
+    * Aggregated from every registered {@link IAgentHostCompletionItemProvider}.
+    */
+    getCompletionTriggerCharacters(): Promise<readonly string[]>;
     /** Dispose a session in the agent host, freeing SDK resources. */
     disposeSession(session: URI): Promise<void>;
     /** Create a new terminal on the agent host. */
-    createTerminal(params: ICreateTerminalParams): Promise<void>;
+    createTerminal(params: CreateTerminalParams): Promise<void>;
     /** Dispose a terminal and kill its process if still running. */
     disposeTerminal(terminal: URI): Promise<void>;
     /** Gracefully shut down all sessions and the underlying client. */
@@ -43,17 +62,32 @@ export interface IAgentService {
     /**
     * Subscribe to state at the given URI. Returns a snapshot of the current
     * state and the serverSeq at snapshot time. Subsequent actions for this
-    * resource arrive via {@link onDidAction}.
+    * resource arrive via {@link onDidAction}. Registers `clientId` against
+    * the resource so the server-side refcount knows who is watching, so the
+    * caller does not need to invoke {@link addSubscriber} separately. Pair
+    * with {@link unsubscribe} when the subscription is released.
     */
-    subscribe(resource: URI): Promise<IStateSnapshot>;
-    /** Unsubscribe from state updates for the given URI. */
-    unsubscribe(resource: URI): void;
+    subscribe(resource: URI, clientId: string): Promise<IStateSnapshot>;
+    /**
+    * Counterpart to {@link subscribe}. Drops `clientId` from the refcount
+    * for `resource`; when the last subscriber is removed, idle session state
+    * for `resource` may be evicted from the server.
+    */
+    unsubscribe(resource: URI, clientId: string): void;
+    /**
+    * Register `clientId` against `resource` without going through
+    * {@link subscribe}. Only needed by callers that hand out snapshots
+    * synchronously (e.g. the JSON-RPC handshake serving `initialSubscriptions`
+    * out of the in-memory state cache); regular subscribers should call
+    * {@link subscribe} instead. Counterpart cleanup is {@link unsubscribe}.
+    */
+    addSubscriber(resource: URI, clientId: string): void;
     /**
     * Fires when the server applies an action to subscribable state.
     * Clients use this alongside {@link subscribe} to keep their local
     * state in sync.
     */
-    readonly onDidAction: Event<IActionEnvelope>;
+    readonly onDidAction: Event<ActionEnvelope>;
     /**
     * Fires when the server broadcasts an ephemeral notification
     * (e.g. sessionAdded, sessionRemoved).
@@ -64,34 +98,34 @@ export interface IAgentService {
     * it to state, triggers side effects, and echoes it back via
     * {@link onDidAction} with the client's origin for reconciliation.
     */
-    dispatchAction(action: ISessionAction | ITerminalAction, clientId: string, clientSeq: number): void;
+    dispatchAction(action: SessionAction | TerminalAction | IRootConfigChangedAction, clientId: string, clientSeq: number): void;
     /**
     * List the contents of a directory on the agent host's filesystem.
     * Used by the client to drive a remote folder picker before session creation.
     */
-    resourceList(uri: URI): Promise<IResourceListResult>;
+    resourceList(uri: URI): Promise<ResourceListResult>;
     /**
     * Read stored content by URI from the agent host (e.g. file edit snapshots,
     * or reading files from the remote filesystem).
     */
-    resourceRead(uri: URI): Promise<IResourceReadResult>;
+    resourceRead(uri: URI): Promise<ResourceReadResult>;
     /**
     * Write content to a file on the agent host's filesystem.
     * Used for undo/redo operations on file edits.
     */
-    resourceWrite(params: IResourceWriteParams): Promise<IResourceWriteResult>;
+    resourceWrite(params: ResourceWriteParams): Promise<ResourceWriteResult>;
     /**
     * Copy a resource from one URI to another on the agent host's filesystem.
     */
-    resourceCopy(params: IResourceCopyParams): Promise<IResourceCopyResult>;
+    resourceCopy(params: ResourceCopyParams): Promise<ResourceCopyResult>;
     /**
     * Delete a resource at a URI on the agent host's filesystem.
     */
-    resourceDelete(params: IResourceDeleteParams): Promise<IResourceDeleteResult>;
+    resourceDelete(params: ResourceDeleteParams): Promise<ResourceDeleteResult>;
     /**
     * Move (rename) a resource from one URI to another on the agent host's filesystem.
     */
-    resourceMove(params: IResourceMoveParams): Promise<IResourceMoveResult>;
+    resourceMove(params: ResourceMoveParams): Promise<ResourceMoveResult>;
 }
 export declare const IAgentHostService: import("../../instantiation/common/instantiation.js").ServiceIdentifier<IAgentHostService>;
 /**
@@ -116,4 +150,11 @@ export interface IAgentHostService extends IAgentConnection {
     setAuthenticationPending(pending: boolean): void;
     restartAgentHost(): Promise<void>;
     startWebSocketServer(): Promise<IAgentHostSocketInfo>;
+    /**
+    * Get inspector listener info for the agent host process. If the inspector
+    * is not currently active and `tryEnable` is true, opens the inspector on
+    * a random local port. Returns `undefined` if the inspector cannot be
+    * enabled.
+    */
+    getInspectInfo(tryEnable: boolean): Promise<IAgentHostInspectInfo | undefined>;
 }

package/vscode/src/vs/platform/agentHost/common/remoteAgentHostService.d.ts

@@ -1,16 +1,66 @@
 import { Event } from "../../../base/common/event.js";
 import type { IAgentConnection } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentHost/common/agentService";
 import { IRemoteAgentHostService } from "./remoteAgentHostService.service.js";
-/** Connection status for a remote agent host. */
-export declare enum RemoteAgentHostConnectionStatus {
-    Connected = "connected",
-    Connecting = "connecting",
-    Disconnected = "disconnected"
+/**
+ * Connection status for a remote agent host.
+ *
+ * Discriminated by `kind`. The `incompatible` variant carries the rejection
+ * message returned by the host (typically when its protocol version is not
+ * compatible with anything the client offered) so the UI can surface it.
+ */
+export type RemoteAgentHostConnectionStatus = {
+    readonly kind: "connected";
+} | {
+    readonly kind: "connecting";
+} | {
+    readonly kind: "disconnected";
+} | {
+    readonly kind: "incompatible";
+    /** Human-readable reason from the host (or a synthesised one when the host did not send one). */
+    readonly message: string;
+    /** Protocol versions the client offered. */
+    readonly supportedByClient: readonly string[];
+    /** Protocol versions the server reported it can speak, if available. */
+    readonly offeredByServer?: readonly string[];
+};
+export declare namespace RemoteAgentHostConnectionStatus {
+    /** Singleton "connected" status. */
+    const connected: RemoteAgentHostConnectionStatus;
+    /** Singleton "connecting" status. */
+    const connecting: RemoteAgentHostConnectionStatus;
+    /** Singleton "disconnected" status. */
+    const disconnected: RemoteAgentHostConnectionStatus;
+    /** Build an "incompatible" status from a host-supplied message and the versions involved. */
+    function incompatible(message: string, supportedByClient: readonly string[], offeredByServer?: readonly string[]): RemoteAgentHostConnectionStatus;
+    /** Whether the connection is fully established and ready for traffic. */
+    function isConnected(status: RemoteAgentHostConnectionStatus | undefined): boolean;
+    /** Whether the connection is mid-handshake. */
+    function isConnecting(status: RemoteAgentHostConnectionStatus | undefined): boolean;
+    /** Whether the connection is in the plain disconnected state. */
+    function isDisconnected(status: RemoteAgentHostConnectionStatus | undefined): boolean;
+    /** Whether the connection rejected our protocol version. */
+    function isIncompatible(status: RemoteAgentHostConnectionStatus | undefined): status is RemoteAgentHostConnectionStatus & {
+        kind: "incompatible";
+    };
+    /** Whether the connection is anything except `connected`. */
+    function isUnavailable(status: RemoteAgentHostConnectionStatus | undefined): boolean;
+    /**
+     * If `err` is a protocol-version mismatch reported by an agent host
+     * during the `initialize` handshake, returns an `incompatible` status
+     * carrying the host's message. Returns `undefined` otherwise so callers
+     * can fall back to their existing failure handling.
+     */
+    function fromConnectError(err: unknown, supportedByClient: readonly string[]): RemoteAgentHostConnectionStatus | undefined;
 }
 /** Configuration key for the list of remote agent host addresses. */
 export declare const RemoteAgentHostsSettingId = "chat.remoteAgentHosts";
 /** Configuration key to enable remote agent host connections. */
 export declare const RemoteAgentHostsEnabledSettingId = "chat.remoteAgentHostsEnabled";
+/**
+ * Configuration key that controls whether online dev tunnels and
+ * configured SSH remote agent hosts are auto-connected at startup.
+ */
+export declare const RemoteAgentHostAutoConnectSettingId = "chat.remoteAgentHostsAutoConnect";
 export declare enum RemoteAgentHostEntryType {
     WebSocket = "websocket",
     SSH = "ssh",
@@ -104,7 +154,7 @@ export declare class NullRemoteAgentHostService implements IRemoteAgentHostServi
     addRemoteAgentHost(): Promise<IRemoteAgentHostConnectionInfo>;
     removeRemoteAgentHost(_address: string): Promise<void>;
     reconnect(_address: string): void;
-    addSSHConnection(): Promise<IRemoteAgentHostConnectionInfo>;
+    addManagedConnection(): Promise<IRemoteAgentHostConnectionInfo>;
     getEntryByAddress(): IRemoteAgentHostEntry | undefined;
 }
 export declare function parseRemoteAgentHostInput(input: string): RemoteAgentHostInputParseResult;

package/vscode/src/vs/platform/agentHost/common/remoteAgentHostService.js

@@ -1,13 +1,58 @@
 
 import { Event } from '../../../base/common/event.js';
 import '../../../base/common/network.js';
+import { ProtocolError, AHP_UNSUPPORTED_PROTOCOL_VERSION } from './state/sessionProtocol.js';
 import { TUNNEL_ADDRESS_PREFIX } from './tunnelAgentHost.js';
 
 var RemoteAgentHostConnectionStatus;
 (function(RemoteAgentHostConnectionStatus) {
-    RemoteAgentHostConnectionStatus["Connected"] = "connected";
-    RemoteAgentHostConnectionStatus["Connecting"] = "connecting";
-    RemoteAgentHostConnectionStatus["Disconnected"] = "disconnected";
+    RemoteAgentHostConnectionStatus.connected = ( Object.freeze({
+        kind: "connected"
+    }));
+    RemoteAgentHostConnectionStatus.connecting = ( Object.freeze({
+        kind: "connecting"
+    }));
+    RemoteAgentHostConnectionStatus.disconnected = ( Object.freeze({
+        kind: "disconnected"
+    }));
+    function incompatible(message, supportedByClient, offeredByServer) {
+        return ( Object.freeze({
+            kind: "incompatible",
+            message,
+            supportedByClient,
+            offeredByServer
+        }));
+    }
+    RemoteAgentHostConnectionStatus.incompatible = incompatible;
+    function isConnected(status) {
+        return status?.kind === "connected";
+    }
+    RemoteAgentHostConnectionStatus.isConnected = isConnected;
+    function isConnecting(status) {
+        return status?.kind === "connecting";
+    }
+    RemoteAgentHostConnectionStatus.isConnecting = isConnecting;
+    function isDisconnected(status) {
+        return status?.kind === "disconnected";
+    }
+    RemoteAgentHostConnectionStatus.isDisconnected = isDisconnected;
+    function isIncompatible(status) {
+        return status?.kind === "incompatible";
+    }
+    RemoteAgentHostConnectionStatus.isIncompatible = isIncompatible;
+    function isUnavailable(status) {
+        return status?.kind !== "connected";
+    }
+    RemoteAgentHostConnectionStatus.isUnavailable = isUnavailable;
+    function fromConnectError(err, supportedByClient) {
+        if (err instanceof ProtocolError && err.code === AHP_UNSUPPORTED_PROTOCOL_VERSION) {
+            const data = err.data;
+            const offeredByServer = Array.isArray(data?.supportedVersions) ? data.supportedVersions : undefined;
+            return incompatible(err.message, supportedByClient, offeredByServer);
+        }
+        return undefined;
+    }
+    RemoteAgentHostConnectionStatus.fromConnectError = fromConnectError;
 })(RemoteAgentHostConnectionStatus || (RemoteAgentHostConnectionStatus = {}));
 const RemoteAgentHostsSettingId = "chat.remoteAgentHosts";
 const RemoteAgentHostsEnabledSettingId = "chat.remoteAgentHostsEnabled";
@@ -47,7 +92,7 @@ class NullRemoteAgentHostService {
     }
     async removeRemoteAgentHost(_address) {}
     reconnect(_address) {}
-    async addSSHConnection() {
+    async addManagedConnection() {
         throw ( new Error("Remote agent host connections are not supported in this environment."));
     }
     getEntryByAddress() {

package/vscode/src/vs/platform/agentHost/common/remoteAgentHostService.service.d.ts

@@ -1,4 +1,5 @@
 import { Event } from "../../../base/common/event.js";
+import { IDisposable } from "../../../base/common/lifecycle.js";
 import { IAgentConnection } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentHost/common/agentService";
 import { IRemoteAgentHostConnectionInfo, IRemoteAgentHostEntry } from "./remoteAgentHostService.js";
 export declare const IRemoteAgentHostService: import("../../instantiation/common/instantiation.js").ServiceIdentifier<IRemoteAgentHostService>;
@@ -43,8 +44,18 @@ export interface IRemoteAgentHostService {
     * Register a pre-connected agent connection.
     * Used by the SSH and tunnel services to inject relay-backed connections
     * without going through the WebSocket connect flow.
+    *
+    * The optional `transportDisposable` represents the underlying transport
+    * (e.g. an SSH tunnel relay or tunnel-relay session) and is owned by this
+    * service for the lifetime of the entry. It will be disposed when:
+    *   - the entry is removed via {@link removeRemoteAgentHost}
+    *   - the entry is reconciled away (config-driven removal)
+    *   - this service itself is disposed
+    * Callers should put any teardown that needs to happen on entry removal
+    * (e.g. closing the shared-process tunnel, dropping renderer-side handles)
+    * into this disposable, so a single removal path tears down the whole stack.
     */
-    addSSHConnection(entry: IRemoteAgentHostEntry, connection: IAgentConnection): Promise<IRemoteAgentHostConnectionInfo>;
+    addManagedConnection(entry: IRemoteAgentHostEntry, connection: IAgentConnection, transportDisposable?: IDisposable): Promise<IRemoteAgentHostConnectionInfo>;
     /**
     * Look up the {@link IRemoteAgentHostEntry} for a given address.
     * Checks both configured entries from settings and dynamically

package/vscode/src/vs/platform/agentHost/common/sshRemoteAgentHost.d.ts

@@ -31,6 +31,8 @@ export interface ISSHAgentHostConfig {
     readonly sshConfigHost?: string;
     /** Dev override: custom command to start the remote agent host instead of the default CLI. */
     readonly remoteAgentHostCommand?: string;
+    /** When true, enables OpenSSH agent forwarding (auth-agent@openssh.com) for this connection. Requires {@link authMethod} to be Agent. */
+    readonly agentForward?: boolean;
 }
 /**
  * A sanitized view of the SSH config that omits secret material

package/vscode/src/vs/platform/agentHost/common/sshRemoteAgentHost.service.d.ts

@@ -1,4 +1,5 @@
 import { Event } from "../../../base/common/event.js";
+import { URI } from "../../../base/common/uri.js";
 import { ISSHConnectProgress, ISSHAgentHostConnection, ISSHAgentHostConfig, ISSHResolvedConfig, type ISSHConnectResult, type ISSHRelayMessage } from "./sshRemoteAgentHost.js";
 export declare const ISSHRemoteAgentHostService: import("../../instantiation/common/instantiation.js").ServiceIdentifier<ISSHRemoteAgentHostService>;
 /**
@@ -37,6 +38,18 @@ export interface ISSHRemoteAgentHostService {
     disconnect(host: string): Promise<void>;
     /** List SSH config host aliases (excluding wildcards). */
     listSSHConfigHosts(): Promise<string[]>;
+    /**
+    * Ensure `~/.ssh/config` exists (creating it with the right permissions if
+    * missing) and return its URI. The parent `~/.ssh` directory is created
+    * with mode 0700 and the config file with mode 0600 on POSIX systems.
+    */
+    ensureUserSSHConfig(): Promise<URI>;
+    /**
+    * List the known SSH configuration file URIs in priority order — typically the
+    * per-user `~/.ssh/config` (always returned, even if it does not yet exist) and
+    * the system-wide `/etc/ssh/ssh_config` (only when present on disk).
+    */
+    listSSHConfigFiles(): Promise<URI[]>;
     /** Resolve full SSH config for a host via `ssh -G`. */
     resolveSSHConfig(host: string): Promise<ISSHResolvedConfig>;
     /**
@@ -78,6 +91,13 @@ export interface ISSHRemoteAgentHostMainService {
     disconnect(host: string): Promise<void>;
     /** List SSH config host aliases (excluding wildcards). */
     listSSHConfigHosts(): Promise<string[]>;
+    /**
+    * Ensure `~/.ssh/config` exists (creating it with the right permissions if
+    * missing) and return its URI.
+    */
+    ensureUserSSHConfig(): Promise<URI>;
+    /** List the known SSH configuration file URIs (user config always included). */
+    listSSHConfigFiles(): Promise<URI[]>;
     /** Resolve full SSH config for a host via `ssh -G`. */
     resolveSSHConfig(host: string): Promise<ISSHResolvedConfig>;
     /**
@@ -85,5 +105,5 @@ export interface ISSHRemoteAgentHostMainService {
     * Resolves the SSH config alias, connects, and returns fresh
     * connection info with a new local forwarded port.
     */
-    reconnect(sshConfigHost: string, name: string, remoteAgentHostCommand?: string): Promise<ISSHConnectResult>;
+    reconnect(sshConfigHost: string, name: string, remoteAgentHostCommand?: string, agentForward?: boolean): Promise<ISSHConnectResult>;
 }

package/vscode/src/vs/platform/agentHost/common/state/protocol/action-origin.generated.d.ts

@@ -1,22 +1,26 @@
-import { type IStateAction, type IRootAgentsChangedAction, type IRootActiveSessionsChangedAction, type IRootTerminalsChangedAction, type ISessionReadyAction, type ISessionCreationFailedAction, type ISessionTurnStartedAction, type ISessionDeltaAction, type ISessionResponsePartAction, type ISessionToolCallStartAction, type ISessionToolCallDeltaAction, type ISessionToolCallReadyAction, type ISessionToolCallConfirmedAction, type ISessionToolCallCompleteAction, type ISessionToolCallResultConfirmedAction, type ISessionToolCallContentChangedAction, type ISessionTurnCompleteAction, type ISessionTurnCancelledAction, type ISessionErrorAction, type ISessionTitleChangedAction, type ISessionUsageAction, type ISessionReasoningAction, type ISessionModelChangedAction, type ISessionServerToolsChangedAction, type ISessionActiveClientChangedAction, type ISessionActiveClientToolsChangedAction, type ISessionPendingMessageSetAction, type ISessionPendingMessageRemovedAction, type ISessionQueuedMessagesReorderedAction, type ISessionInputRequestedAction, type ISessionInputAnswerChangedAction, type ISessionInputCompletedAction, type ISessionCustomizationsChangedAction, type ISessionCustomizationToggledAction, type ISessionTruncatedAction, type ISessionIsReadChangedAction, type ISessionIsDoneChangedAction, type ISessionDiffsChangedAction, type ISessionConfigChangedAction, type ITerminalDataAction, type ITerminalInputAction, type ITerminalResizedAction, type ITerminalClaimedAction, type ITerminalTitleChangedAction, type ITerminalCwdChangedAction, type ITerminalExitedAction, type ITerminalClearedAction, type ITerminalCommandDetectionAvailableAction, type ITerminalCommandExecutedAction, type ITerminalCommandFinishedAction } from "@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/protocol/actions";
+import { type StateAction, type RootAgentsChangedAction, type RootActiveSessionsChangedAction, type RootTerminalsChangedAction, type RootConfigChangedAction, type SessionReadyAction, type SessionCreationFailedAction, type SessionTurnStartedAction, type SessionDeltaAction, type SessionResponsePartAction, type SessionToolCallStartAction, type SessionToolCallDeltaAction, type SessionToolCallReadyAction, type SessionToolCallConfirmedAction, type SessionToolCallCompleteAction, type SessionToolCallResultConfirmedAction, type SessionToolCallContentChangedAction, type SessionTurnCompleteAction, type SessionTurnCancelledAction, type SessionErrorAction, type SessionTitleChangedAction, type SessionUsageAction, type SessionReasoningAction, type SessionModelChangedAction, type SessionServerToolsChangedAction, type SessionActiveClientChangedAction, type SessionActiveClientToolsChangedAction, type SessionPendingMessageSetAction, type SessionPendingMessageRemovedAction, type SessionQueuedMessagesReorderedAction, type SessionInputRequestedAction, type SessionInputAnswerChangedAction, type SessionInputCompletedAction, type SessionCustomizationsChangedAction, type SessionCustomizationToggledAction, type SessionTruncatedAction, type SessionIsReadChangedAction, type SessionIsArchivedChangedAction, type SessionActivityChangedAction, type SessionDiffsChangedAction, type SessionConfigChangedAction, type SessionMetaChangedAction, type TerminalDataAction, type TerminalInputAction, type TerminalResizedAction, type TerminalClaimedAction, type TerminalTitleChangedAction, type TerminalCwdChangedAction, type TerminalExitedAction, type TerminalClearedAction, type TerminalCommandDetectionAvailableAction, type TerminalCommandExecutedAction, type TerminalCommandFinishedAction } from "@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/protocol/actions";
 /** Union of all root-scoped actions. */
-export type IRootAction = IRootAgentsChangedAction | IRootActiveSessionsChangedAction | IRootTerminalsChangedAction;
+export type RootAction = RootAgentsChangedAction | RootActiveSessionsChangedAction | RootTerminalsChangedAction | RootConfigChangedAction;
+/** Union of root actions that clients may dispatch. */
+export type ClientRootAction = RootConfigChangedAction;
+/** Union of root actions that only the server may produce. */
+export type ServerRootAction = RootAgentsChangedAction | RootActiveSessionsChangedAction | RootTerminalsChangedAction;
 /** Union of all session-scoped actions. */
-export type ISessionAction = ISessionReadyAction | ISessionCreationFailedAction | ISessionTurnStartedAction | ISessionDeltaAction | ISessionResponsePartAction | ISessionToolCallStartAction | ISessionToolCallDeltaAction | ISessionToolCallReadyAction | ISessionToolCallConfirmedAction | ISessionToolCallCompleteAction | ISessionToolCallResultConfirmedAction | ISessionToolCallContentChangedAction | ISessionTurnCompleteAction | ISessionTurnCancelledAction | ISessionErrorAction | ISessionTitleChangedAction | ISessionUsageAction | ISessionReasoningAction | ISessionModelChangedAction | ISessionServerToolsChangedAction | ISessionActiveClientChangedAction | ISessionActiveClientToolsChangedAction | ISessionPendingMessageSetAction | ISessionPendingMessageRemovedAction | ISessionQueuedMessagesReorderedAction | ISessionInputRequestedAction | ISessionInputAnswerChangedAction | ISessionInputCompletedAction | ISessionCustomizationsChangedAction | ISessionCustomizationToggledAction | ISessionTruncatedAction | ISessionIsReadChangedAction | ISessionIsDoneChangedAction | ISessionDiffsChangedAction | ISessionConfigChangedAction;
+export type SessionAction = SessionReadyAction | SessionCreationFailedAction | SessionTurnStartedAction | SessionDeltaAction | SessionResponsePartAction | SessionToolCallStartAction | SessionToolCallDeltaAction | SessionToolCallReadyAction | SessionToolCallConfirmedAction | SessionToolCallCompleteAction | SessionToolCallResultConfirmedAction | SessionToolCallContentChangedAction | SessionTurnCompleteAction | SessionTurnCancelledAction | SessionErrorAction | SessionTitleChangedAction | SessionUsageAction | SessionReasoningAction | SessionModelChangedAction | SessionServerToolsChangedAction | SessionActiveClientChangedAction | SessionActiveClientToolsChangedAction | SessionPendingMessageSetAction | SessionPendingMessageRemovedAction | SessionQueuedMessagesReorderedAction | SessionInputRequestedAction | SessionInputAnswerChangedAction | SessionInputCompletedAction | SessionCustomizationsChangedAction | SessionCustomizationToggledAction | SessionTruncatedAction | SessionIsReadChangedAction | SessionIsArchivedChangedAction | SessionActivityChangedAction | SessionDiffsChangedAction | SessionConfigChangedAction | SessionMetaChangedAction;
 /** Union of session actions that clients may dispatch. */
-export type IClientSessionAction = ISessionTurnStartedAction | ISessionToolCallConfirmedAction | ISessionToolCallCompleteAction | ISessionToolCallResultConfirmedAction | ISessionToolCallContentChangedAction | ISessionTurnCancelledAction | ISessionTitleChangedAction | ISessionModelChangedAction | ISessionActiveClientChangedAction | ISessionActiveClientToolsChangedAction | ISessionPendingMessageSetAction | ISessionPendingMessageRemovedAction | ISessionQueuedMessagesReorderedAction | ISessionInputAnswerChangedAction | ISessionInputCompletedAction | ISessionCustomizationToggledAction | ISessionTruncatedAction | ISessionIsReadChangedAction | ISessionIsDoneChangedAction | ISessionConfigChangedAction;
+export type ClientSessionAction = SessionTurnStartedAction | SessionToolCallConfirmedAction | SessionToolCallCompleteAction | SessionToolCallResultConfirmedAction | SessionToolCallContentChangedAction | SessionTurnCancelledAction | SessionTitleChangedAction | SessionModelChangedAction | SessionActiveClientChangedAction | SessionActiveClientToolsChangedAction | SessionPendingMessageSetAction | SessionPendingMessageRemovedAction | SessionQueuedMessagesReorderedAction | SessionInputAnswerChangedAction | SessionInputCompletedAction | SessionCustomizationToggledAction | SessionTruncatedAction | SessionIsReadChangedAction | SessionIsArchivedChangedAction | SessionConfigChangedAction;
 /** Union of session actions that only the server may produce. */
-export type IServerSessionAction = ISessionReadyAction | ISessionCreationFailedAction | ISessionDeltaAction | ISessionResponsePartAction | ISessionToolCallStartAction | ISessionToolCallDeltaAction | ISessionToolCallReadyAction | ISessionTurnCompleteAction | ISessionErrorAction | ISessionUsageAction | ISessionReasoningAction | ISessionServerToolsChangedAction | ISessionInputRequestedAction | ISessionCustomizationsChangedAction | ISessionDiffsChangedAction;
+export type ServerSessionAction = SessionReadyAction | SessionCreationFailedAction | SessionDeltaAction | SessionResponsePartAction | SessionToolCallStartAction | SessionToolCallDeltaAction | SessionToolCallReadyAction | SessionTurnCompleteAction | SessionErrorAction | SessionUsageAction | SessionReasoningAction | SessionServerToolsChangedAction | SessionInputRequestedAction | SessionCustomizationsChangedAction | SessionActivityChangedAction | SessionDiffsChangedAction | SessionMetaChangedAction;
 /** Union of all terminal-scoped actions. */
-export type ITerminalAction = ITerminalDataAction | ITerminalInputAction | ITerminalResizedAction | ITerminalClaimedAction | ITerminalTitleChangedAction | ITerminalCwdChangedAction | ITerminalExitedAction | ITerminalClearedAction | ITerminalCommandDetectionAvailableAction | ITerminalCommandExecutedAction | ITerminalCommandFinishedAction;
+export type TerminalAction = TerminalDataAction | TerminalInputAction | TerminalResizedAction | TerminalClaimedAction | TerminalTitleChangedAction | TerminalCwdChangedAction | TerminalExitedAction | TerminalClearedAction | TerminalCommandDetectionAvailableAction | TerminalCommandExecutedAction | TerminalCommandFinishedAction;
 /** Union of terminal actions that clients may dispatch. */
-export type IClientTerminalAction = ITerminalInputAction | ITerminalResizedAction | ITerminalClaimedAction | ITerminalTitleChangedAction | ITerminalClearedAction;
+export type ClientTerminalAction = TerminalInputAction | TerminalResizedAction | TerminalClaimedAction | TerminalTitleChangedAction | TerminalClearedAction;
 /** Union of terminal actions that only the server may produce. */
-export type IServerTerminalAction = ITerminalDataAction | ITerminalCwdChangedAction | ITerminalExitedAction | ITerminalCommandDetectionAvailableAction | ITerminalCommandExecutedAction | ITerminalCommandFinishedAction;
+export type ServerTerminalAction = TerminalDataAction | TerminalCwdChangedAction | TerminalExitedAction | TerminalCommandDetectionAvailableAction | TerminalCommandExecutedAction | TerminalCommandFinishedAction;
 /**
  * Exhaustive map indicating which action types may be dispatched by clients.
- * Adding a new action to IStateAction without adding it here is a compile error.
+ * Adding a new action to StateAction without adding it here is a compile error.
  */
 export declare const IS_CLIENT_DISPATCHABLE: {
-    readonly [K in IStateAction["type"]]: boolean;
+    readonly [K in StateAction["type"]]: boolean;
 };