@codingame/monaco-vscode-api 36.2.7 → 37.1.0

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

@@ -1,9 +1,11 @@
 import { Event } from "../../../base/common/event.js";
 import { Disposable } from "../../../base/common/lifecycle.js";
 import { ILogService } from "../../log/common/log.service.js";
+import { AgentHostClientConnectionKind } from "./agentHostTelemetry.js";
 import { AhpJsonlLogger } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentHost/common/ahpJsonlLogger";
+import { ReconnectingTransport } from "./reconnectingTransport.js";
 import type { AhpServerNotification, JsonRpcNotification, JsonRpcRequest, JsonRpcResponse, ProtocolMessage } from "./state/sessionProtocol.js";
-import type { IProtocolTransport } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentHost/common/state/sessionTransport";
+import type { IProtocolTransport } from "./state/sessionTransport.js";
 /**
  * A message relayed from a remote agent host through a tunnel managed
  * by the shared process. The shared process acts as a WebSocket proxy,
@@ -23,6 +25,15 @@ export interface IRelayChannel {
     readonly onDidRelayClose: Event<string>;
     relaySend(connectionId: string, message: string): Promise<void>;
 }
+/**
+ * Handle for a relay channel established by a {@link ReconnectingRelayTransport}.
+ */
+export interface IRelayConnectionHandle {
+    /** Identifier of the freshly established relay channel. */
+    readonly connectionId: string;
+    /** Tear down this relay channel. Invoked when the transport is disposed. */
+    close?(): Promise<void>;
+}
 /**
  * A protocol transport that relays messages through a shared-process
  * tunnel via IPC, instead of using a direct WebSocket connection.
@@ -32,15 +43,25 @@ export interface IRelayChannel {
  * through this IPC channel.
  */
 export declare class RelayTransport extends Disposable implements IProtocolTransport {
-    private readonly _connectionId;
+    protected _connectionId: string | undefined;
     private readonly _channel;
     private readonly _ahpLogger;
-    private readonly _logService;
-    private readonly _logPrefix;
+    protected readonly _logService: ILogService;
+    protected readonly _logPrefix: string;
+    readonly clientConnectionKind: AgentHostClientConnectionKind;
     private readonly _onMessage;
     readonly onMessage: Event<ProtocolMessage>;
     private readonly _onClose;
     readonly onClose: Event<void>;
-    constructor(_connectionId: string, _channel: IRelayChannel, _ahpLogger: AhpJsonlLogger | undefined, _logService: ILogService, _logPrefix: string);
+    private _malformedFrames;
+    private _closeFired;
+    constructor(_connectionId: string | undefined, _channel: IRelayChannel, _ahpLogger: AhpJsonlLogger | undefined, _logService: ILogService, _logPrefix: string, clientConnectionKind: AgentHostClientConnectionKind);
     send(message: ProtocolMessage | AhpServerNotification | JsonRpcNotification | JsonRpcResponse | JsonRpcRequest): void;
+    private _fireClose;
+}
+/**
+ * A relay transport that establishes and owns its shared-process relay channel on connect.
+ */
+export declare class ReconnectingRelayTransport extends ReconnectingTransport {
+    constructor(establish: () => Promise<IRelayConnectionHandle>, channel: IRelayChannel, createAhpLogger: () => AhpJsonlLogger | undefined, logService: ILogService, logPrefix: string, clientConnectionKind: AgentHostClientConnectionKind);
 }

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

@@ -0,0 +1,7 @@
+/**
+ * Where a remote host's agents should run: a dedicated (standalone) agent
+ * host process, or inside a remote VS Code editor window.
+ */
+export type RemoteAgentHostLocationPreference = "dedicated" | "editor";
+/** Narrow an unknown value to a valid {@link RemoteAgentHostLocationPreference}. */
+export declare function isRemoteAgentHostLocationPreference(value: unknown): value is RemoteAgentHostLocationPreference;

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

@@ -1,6 +1,15 @@
 import { Event } from "../../../base/common/event.js";
-import type { IAgentConnection } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentHost/common/agentService";
+import { IDisposable } from "../../../base/common/lifecycle.js";
+import type { IObservable } from "../../../base/common/observable.js";
+import { ConfigurationTarget } from "../../configuration/common/configuration.js";
+import { type IConfigurationService } from "../../configuration/common/configuration.service.js";
+import { type IStorageService } from "../../storage/common/storage.service.js";
+import type { IAgentConnection } from "./agentService.js";
+import { AgentHostTransportFailureReason } from "./state/sessionTransport.js";
 import { type IVscodeUpgradeResult } from "./state/protocolUpgrade.js";
+import { type IRemoteAgentHostReconnectPolicy } from "./reconnectPolicy.js";
+import type { SSHAgentHostLifecycle } from "./sshRemoteAgentHost.js";
+import type { AgentHostServerType } from "./agentHostEndpointRegistry.js";
 import { IRemoteAgentHostService } from "./remoteAgentHostService.service.js";
 /**
  * Connection status for a remote agent host.
@@ -13,8 +22,19 @@ export type RemoteAgentHostConnectionStatus = {
     readonly kind: "connected";
 } | {
     readonly kind: "connecting";
+}
+/**
+ * The transport dropped and the protocol client is re-establishing it itself,
+ * preserving session state. Distinct from `connecting` (initial dial) and
+ * `disconnected` (no connection, nothing in flight).
+ */
+ | {
+    readonly kind: "reconnecting";
+    /** When the next automatic attempt fires, if one is scheduled. Absent while an attempt is in flight. */
+    readonly nextAttemptAt?: number;
 } | {
     readonly kind: "disconnected";
+    readonly reason: AgentHostTransportFailureReason;
 } | {
     readonly kind: "incompatible";
     /** Human-readable reason from the host (or a synthesised one when the host did not send one). */
@@ -36,14 +56,22 @@ export declare namespace RemoteAgentHostConnectionStatus {
     const connected: RemoteAgentHostConnectionStatus;
     /** Singleton "connecting" status. */
     const connecting: RemoteAgentHostConnectionStatus;
+    /** Singleton "reconnecting" status. */
+    const reconnecting: RemoteAgentHostConnectionStatus;
+    /** Build a reconnecting status carrying its backoff deadline. */
+    function reconnectingUntil(nextAttemptAt: number | undefined): RemoteAgentHostConnectionStatus;
     /** Singleton "disconnected" status. */
     const disconnected: RemoteAgentHostConnectionStatus;
+    /** Build a disconnected status with a machine-readable reason. */
+    function disconnectedBecause(reason: AgentHostTransportFailureReason): RemoteAgentHostConnectionStatus;
     /** Build an "incompatible" status from a host-supplied message and the versions involved. */
     function incompatible(message: string, supportedByClient: readonly string[], offeredByServer?: readonly string[], vscodeUpgradeMethod?: 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 protocol client is restoring a dropped transport. */
+    function isReconnecting(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. */
@@ -64,16 +92,15 @@ export declare namespace RemoteAgentHostConnectionStatus {
 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.
- */
+/** Configuration key that controls whether online dev tunnels, configured SSH remote agent hosts, and WSL remote agent hosts are auto-connected at startup. */
 export declare const RemoteAgentHostAutoConnectSettingId = "chat.remoteAgentHostsAutoConnect";
 export declare enum RemoteAgentHostEntryType {
     WebSocket = "websocket",
     SSH = "ssh",
     WSL = "wsl",
-    Tunnel = "tunnel"
+    Tunnel = "tunnel",
+    CloudSandbox = "cloudSandbox",
+    DevContainer = "devContainer"
 }
 export interface IRemoteAgentHostWebSocketConnection {
     readonly type: RemoteAgentHostEntryType.WebSocket;
@@ -106,6 +133,14 @@ export interface IRemoteAgentHostSSHConnection {
     readonly user?: string;
     /** SSH port on the remote machine (default 22). */
     readonly port?: number;
+    /** Server type selected for the most recent SSH connection. */
+    readonly serverType?: AgentHostServerType;
+    /** Registry instance id selected for the most recent SSH connection. */
+    readonly instanceId?: string;
+    /** Whether the most recently selected SSH connection was primary. */
+    readonly primary?: boolean;
+    /** Ownership of the remote agent host selected for the most recent SSH connection. */
+    readonly lifecycle?: SSHAgentHostLifecycle;
 }
 export interface IRemoteAgentHostTunnelConnection {
     readonly type: RemoteAgentHostEntryType.Tunnel;
@@ -129,13 +164,204 @@ export interface IRemoteAgentHostWSLConnection {
     /** WSL distro name (e.g. `Ubuntu-22.04`). */
     readonly distro: string;
 }
-export type RemoteAgentHostConnection = IRemoteAgentHostWebSocketConnection | IRemoteAgentHostSSHConnection | IRemoteAgentHostWSLConnection | IRemoteAgentHostTunnelConnection;
+/**
+ * A connection to a Copilot cloud "sandbox" environment (agent integration slug
+ * `copilot-developer-cli`), reached over a Mission Control-brokered Azure Web
+ * PubSub relay. Not persisted to settings — the connection is established
+ * on demand with freshly-minted, short-lived credentials.
+ */
+export interface IRemoteAgentHostCloudSandboxConnection {
+    readonly type: RemoteAgentHostEntryType.CloudSandbox;
+    /** Synthesized display address: `cloudsandbox:<environmentId>`. */
+    readonly address: string;
+    /** Stable Mission Control environment identifier (`env_<uuid>`). */
+    readonly environmentId: string;
+    /** The cloud session/task id this connection is for, when known. */
+    readonly sessionId?: string;
+}
+/**
+ * A runtime-only connection to an agent host running inside a Dev Container.
+ * The Dev Container integration stages its transport for its connection factory.
+ */
+export interface IRemoteAgentHostDevContainerConnection {
+    readonly type: RemoteAgentHostEntryType.DevContainer;
+    /** Stable address for the container connection. */
+    readonly address: string;
+    /** Local source folder containing the Dev Container configuration. */
+    readonly hostPath: string;
+}
+export type RemoteAgentHostConnection = IRemoteAgentHostWebSocketConnection | IRemoteAgentHostSSHConnection | IRemoteAgentHostWSLConnection | IRemoteAgentHostTunnelConnection | IRemoteAgentHostCloudSandboxConnection | IRemoteAgentHostDevContainerConnection;
 /** A configured remote agent host entry. WebSocket entries are persisted in {@link RemoteAgentHostsSettingId}; SSH entries are persisted in storage. */
 export interface IRemoteAgentHostEntry {
     readonly name: string;
     readonly connectionToken?: string;
     readonly connection: RemoteAgentHostConnection;
 }
+/**
+ * Connection states surfaced by a protocol client while the service owns it.
+ * Mirrors the browser client's states without making this common API depend on
+ * a browser implementation.
+ */
+export type RemoteAgentHostProtocolClientState = "connecting" | "incompatible" | "connected" | "reconnecting" | "closed";
+/**
+ * The service-owned protocol-client surface needed to establish and manage a
+ * remote connection. Browser implementations provide this with
+ * `AgentHostProtocolClient`.
+ */
+export interface IRemoteAgentHostProtocolClient extends IAgentConnection, IDisposable {
+    readonly defaultDirectory: string | undefined;
+    /** Deadline for the next scheduled reconnect attempt, if one is pending. */
+    readonly nextReconnectAt: number | undefined;
+    readonly onDidClose: Event<AgentHostTransportFailureReason | undefined>;
+    readonly onDidChangeConnectionState: Event<RemoteAgentHostProtocolClientState>;
+    /**
+     * Fires whenever the pending reconnect schedule changes — a backoff being
+     * armed, or cleared by an immediate retry. Separate from
+     * {@link onDidChangeConnectionState} because the client state is still
+     * `reconnecting` throughout, and consumers of that event do real work on
+     * each transition that must not be repeated per backoff round.
+     */
+    readonly onDidScheduleReconnect: Event<void>;
+    connect(): Promise<void>;
+    reconnectNow(): boolean;
+    notifyTransportClosed(): void;
+    triggerVscodeUpgrade(method: string): Promise<IVscodeUpgradeResult>;
+}
+/** Options describing why a connection is being built. */
+export interface IRemoteAgentHostConnectOptions {
+    /**
+     * Whether an explicit user action triggered this attempt. Background attempts
+     * must never open prompts, pickers or modals.
+     */
+    readonly userInitiated: boolean;
+}
+/** A built, not-yet-handshaken connection and its owned resources. */
+export interface IRemoteAgentHostCreatedConnection {
+    /** The client the service will handshake and own. */
+    readonly connection: IRemoteAgentHostProtocolClient;
+    /**
+     * Teardown for resources the factory established alongside the client
+     * (e.g. a shared-process relay channel). Disposed with the connection entry.
+     */
+    readonly transportDisposable?: IDisposable;
+    /**
+     * Whether a redial transfers transport teardown ownership to the new connection.
+     * Defaults to `false`.
+     */
+    readonly reconnectTransfersTransportOwnership?: boolean;
+}
+/** Builds agent host connections of one {@link RemoteAgentHostEntryType}. */
+export interface IRemoteAgentHostConnectionFactory {
+    /** The entry type this factory builds. */
+    readonly kind: RemoteAgentHostEntryType;
+    /** Entries owned by this factory. */
+    readonly entries: IObservable<readonly IRemoteAgentHostEntry[]>;
+    /**
+     * Build a client bound to a transport for `entry`.
+     *
+     * Must NOT perform the protocol handshake — the service calls `connect()`
+     * itself so handshake outcome classification lives in exactly one place.
+     */
+    createConnection(entry: IRemoteAgentHostEntry, options: IRemoteAgentHostConnectOptions): Promise<IRemoteAgentHostCreatedConnection>;
+}
+/** Raw shape of persisted remote agent host entries. */
+export interface IRawRemoteAgentHostEntry {
+    readonly address: string;
+    readonly name: string;
+    readonly connectionToken?: string;
+    readonly sshConfigHost?: string;
+    readonly sshHostName?: string;
+    readonly sshUser?: string;
+    readonly sshPort?: number;
+    readonly sshServerType?: AgentHostServerType;
+    readonly sshInstanceId?: string;
+    readonly sshPrimary?: boolean;
+    readonly sshLifecycle?: SSHAgentHostLifecycle;
+}
+/** Storage key for SSH remote agent host entries. */
+export declare const SSH_REMOTE_AGENT_HOSTS_STORAGE_KEY = "remoteAgentHost.sshConnections";
+/** Tests whether a value has the persisted remote agent host entry shape. */
+export declare function isRawRemoteAgentHostEntry(value: unknown): value is IRawRemoteAgentHostEntry;
+/** Tests whether a persisted entry uses the legacy SSH-in-settings shape. */
+export declare function isLegacySshRawEntry(entry: IRawRemoteAgentHostEntry): boolean;
+/** Where durable copies of a remote agent host entry live. */
+export type RemoteAgentHostEntryStore = "settings" | "storage" | "runtime";
+/**
+ * Static, per-connection-type description of how an entry is addressed,
+ * persisted and connected. Collects the behavioural differences between
+ * transports into one table so the service does not branch on
+ * {@link RemoteAgentHostEntryType} in a dozen places.
+ */
+interface IRemoteAgentHostEntryTypeConfigBase<TConnection extends RemoteAgentHostConnection> {
+    readonly type: TConnection["type"];
+    /**
+     * Whether this entry-driven kind is dialed during reconciliation from the factory's entries.
+     * On-demand kinds set this to `false`, but an explicit {@link IRemoteAgentHostService.reconnect} still dials their staged entries.
+     */
+    readonly dialedFromEntries: boolean;
+    /**
+     * Whether background dialing is controlled by {@link RemoteAgentHostAutoConnectSettingId}.
+     * Defaults to `false`.
+     */
+    readonly autoConnectGated?: boolean;
+    /** Whether the address is subject to `normalizeRemoteAgentHostAddress`. */
+    readonly normalizedAddress: boolean;
+    /** Policy for restoring a dropped transport. */
+    readonly reconnect: IRemoteAgentHostReconnectPolicy;
+    /** Stable identity for the entry. */
+    address(connection: TConnection): string;
+}
+/**
+ * An entry type with a durable home. Narrowing a config on
+ * `store !== 'runtime'` guarantees both converters are present.
+ */
+export interface IPersistedEntryTypeConfig<TConnection extends RemoteAgentHostConnection = RemoteAgentHostConnection> extends IRemoteAgentHostEntryTypeConfigBase<TConnection> {
+    readonly store: "settings" | "storage";
+    /** Serialize for persistence. */
+    toRaw(entry: IRemoteAgentHostEntry, connection: TConnection): IRawRemoteAgentHostEntry;
+    /** Rehydrate from persisted form. */
+    fromRaw(raw: IRawRemoteAgentHostEntry): IRemoteAgentHostEntry;
+}
+/** An entry type that lives only for the lifetime of its connection and is never written to disk. */
+interface IRuntimeEntryTypeConfig<TConnection extends RemoteAgentHostConnection = RemoteAgentHostConnection> extends IRemoteAgentHostEntryTypeConfigBase<TConnection> {
+    readonly store: "runtime";
+    readonly toRaw?: never;
+    readonly fromRaw?: never;
+}
+export type IRemoteAgentHostEntryTypeConfig<TConnection extends RemoteAgentHostConnection = RemoteAgentHostConnection> = IPersistedEntryTypeConfig<TConnection> | IRuntimeEntryTypeConfig<TConnection>;
+export declare const WEBSOCKET_ENTRY_TYPE_CONFIG: IPersistedEntryTypeConfig<IRemoteAgentHostWebSocketConnection>;
+export declare const SSH_ENTRY_TYPE_CONFIG: IPersistedEntryTypeConfig<IRemoteAgentHostSSHConnection>;
+/** The resolved configuration target and raw remote agent host entries at that target. */
+export interface IRemoteAgentHostSettings {
+    readonly target: ConfigurationTarget;
+    readonly entries: readonly IRawRemoteAgentHostEntry[];
+}
+/** Replaces the entry sharing an address, or appends it. */
+export declare function upsertRemoteAgentHostEntry(entries: readonly IRemoteAgentHostEntry[], entry: IRemoteAgentHostEntry): IRemoteAgentHostEntry[];
+/**
+ * Serializes the entries belonging to one kind, skipping the rest. Written as a
+ * loop rather than `filter().map()` because a `filter` predicate does not narrow
+ * the {@link RemoteAgentHostConnection} union for the following `toRaw` call.
+ */
+export declare function toRawEntriesOfKind(entries: readonly IRemoteAgentHostEntry[], config: IPersistedEntryTypeConfig): IRawRemoteAgentHostEntry[];
+/** Reads raw remote agent host settings from the configuration target that owns them. */
+export declare function readRemoteAgentHostSettings(configurationService: IConfigurationService): IRemoteAgentHostSettings;
+/** Reads WebSocket entries from the global configuration or its owning target. */
+export declare function readWebSocketRemoteAgentHostEntries(configurationService: IConfigurationService, targetOnly?: boolean): IRemoteAgentHostEntry[];
+/** Adds or replaces a WebSocket entry in its configuration store. */
+export declare function addWebSocketRemoteAgentHostEntry(configurationService: IConfigurationService, entry: IRemoteAgentHostEntry): Promise<void>;
+/** Removes a WebSocket entry from its configuration store. */
+export declare function removeWebSocketRemoteAgentHostEntry(configurationService: IConfigurationService, address: string): Promise<void>;
+/** Reads SSH entries from their application storage store. */
+export declare function readSSHRemoteAgentHostEntries(storageService: IStorageService): IRemoteAgentHostEntry[];
+/** Replaces the SSH entries in their application storage store. */
+export declare function storeSSHRemoteAgentHostEntries(storageService: IStorageService, entries: readonly IRemoteAgentHostEntry[]): void;
+/** Adds or replaces an SSH entry in its application storage store. */
+export declare function addSSHRemoteAgentHostEntry(storageService: IStorageService, entry: IRemoteAgentHostEntry): void;
+/** Removes an SSH entry from its application storage store. */
+export declare function removeSSHRemoteAgentHostEntry(storageService: IStorageService, address: string): void;
+/** Gets the static persistence and connection policy for an entry type. */
+export declare function getEntryTypeConfig(type: RemoteAgentHostEntryType): IRemoteAgentHostEntryTypeConfig;
 export declare function getEntryAddress(entry: IRemoteAgentHostEntry): string;
 export declare function remoteAgentHostLogOutputChannelId(address: string): string;
 /**
@@ -164,7 +390,8 @@ export type RemoteAgentHostInputParseResult = {
 export interface IRemoteAgentHostConnectionInfo {
     readonly address: string;
     readonly name: string;
-    readonly clientId: string;
+    /** Identifier of the backing protocol client, when one exists. */
+    readonly clientId?: string;
     readonly defaultDirectory?: string;
     readonly status: RemoteAgentHostConnectionStatus;
 }
@@ -173,26 +400,23 @@ export declare class NullRemoteAgentHostService implements IRemoteAgentHostServi
     readonly onDidChangeConnections: Event<any>;
     readonly connections: readonly IRemoteAgentHostConnectionInfo[];
     readonly configuredEntries: readonly IRemoteAgentHostEntry[];
+    registerConnectionFactory(): IDisposable;
     getConnection(): IAgentConnection | undefined;
     getConnectionByAuthority(): IAgentConnection | undefined;
-    addRemoteAgentHost(): Promise<IRemoteAgentHostConnectionInfo>;
+    waitForConnection(): Promise<IRemoteAgentHostConnectionInfo>;
     removeRemoteAgentHost(_address: string): Promise<void>;
-    reconnect(_address: string): void;
+    reconnect(_address: string, _userInitiated?: boolean): void;
+    reconnectNow(_address: string): void;
     notifyConnectionClosed(_address: string): void;
-    addManagedConnection(): Promise<IRemoteAgentHostConnectionInfo>;
     getEntryByAddress(): IRemoteAgentHostEntry | undefined;
     triggerServerUpgrade(): Promise<IVscodeUpgradeResult>;
 }
 export declare function parseRemoteAgentHostInput(input: string): RemoteAgentHostInputParseResult;
-/** Raw shape of persisted remote agent host entries. */
-export interface IRawRemoteAgentHostEntry {
-    readonly address: string;
-    readonly name: string;
-    readonly connectionToken?: string;
-    readonly sshConfigHost?: string;
-    readonly sshHostName?: string;
-    readonly sshUser?: string;
-    readonly sshPort?: number;
-}
-export declare function rawEntryToEntry(raw: IRawRemoteAgentHostEntry): IRemoteAgentHostEntry | undefined;
-export declare function entryToRawEntry(entry: IRemoteAgentHostEntry): IRawRemoteAgentHostEntry | undefined;
+/**
+ * Parses an entry persisted before each store became type-specific, when a
+ * single flat shape held both WebSocket and SSH entries and the variant had
+ * to be inferred from which `ssh*` fields were present. Used only by the
+ * migration path.
+ */
+export declare function parseLegacyRawEntry(raw: IRawRemoteAgentHostEntry): IRemoteAgentHostEntry;
+export {};