feat: add remote session support across all SDKs

Add a `remote` option to CopilotClientOptions in all 4 language SDKs
(Node, Python, Go, .NET) that passes `--remote` to the CLI process,
enabling Mission Control integration for GitHub web and mobile access.

Also adds `session.rpc.remote.enable()` and `session.rpc.remote.disable()`
RPC methods for on-demand per-session toggling, providing parity with
the CLI's `/remote on` and `/remote off` commands.

Changes:
- Node: remote option in CopilotClientOptions, generated RPC types
- Python: remote field on SubprocessConfig, manual RPC types
- Go: Remote field on ClientOptions, manual RPC types
- .NET: Remote property on CopilotClientOptions + clone, generated RPC
- Docs: new docs/features/remote-sessions.md with all-language examples
- Updated docs/features/index.md and docs/index.md

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: patniko

docs/features/index.md

@@ -17,6 +17,7 @@ These guides cover the capabilities you can add to your Copilot SDK application.
 | [Streaming Events](./streaming-events.md) | Subscribe to real-time session events (40+ event types) |
 | [Steering & Queueing](./steering-and-queueing.md) | Control message delivery — immediate steering vs. sequential queueing |
 | [Session Persistence](./session-persistence.md) | Resume sessions across restarts, manage session storage |
+| [Remote Sessions](./remote-sessions.md) | Share sessions to GitHub web and mobile via Mission Control |
 
 ## Related
 

docs/features/remote-sessions.md

@@ -0,0 +1,154 @@
+# Remote Sessions
+
+Remote sessions let users access their Copilot session from GitHub web and mobile via [Mission Control](https://github.com). When enabled, the SDK connects each session to Mission Control, producing a URL that can be shared as a link or QR code.
+
+## Prerequisites
+
+- The user must be authenticated (GitHub token or logged-in user)
+- The session's working directory must be a GitHub repository
+
+## Enabling Remote Sessions
+
+### Always-on (client-level)
+
+Set `remote: true` when creating the client. Every session in a GitHub repo automatically gets a remote URL.
+
+<!-- tabs:start -->
+
+#### **TypeScript**
+
+```typescript
+import { CopilotClient } from "@github/copilot-sdk";
+
+const client = new CopilotClient({ remote: true });
+const session = await client.createSession({
+  workingDirectory: "/path/to/github-repo",
+  onPermissionRequest: async () => ({ allowed: true }),
+});
+
+session.on("session.info", (event) => {
+  if (event.data.infoType === "remote") {
+    console.log("Remote URL:", event.data.url);
+  }
+});
+```
+
+#### **Python**
+
+```python
+from copilot import CopilotClient, SubprocessConfig
+
+client = CopilotClient(SubprocessConfig(remote=True))
+session = await client.create_session(
+    working_directory="/path/to/github-repo",
+    on_permission_request=lambda req: {"allowed": True},
+)
+
+def on_event(event):
+    if event.type == "session.info" and event.data.info_type == "remote":
+        print(f"Remote URL: {event.data.url}")
+
+session.on(on_event)
+```
+
+#### **Go**
+
+```go
+client, _ := copilot.NewClient(&copilot.ClientOptions{Remote: true})
+session, _ := client.CreateSession(ctx, &copilot.SessionConfig{
+    WorkingDirectory: "/path/to/github-repo",
+    OnPermissionRequest: func(req copilot.PermissionRequest) copilot.PermissionResponse {
+        return copilot.PermissionResponse{Allowed: true}
+    },
+})
+
+session.On(func(event copilot.SessionEvent) {
+    if event.Type == "session.info" {
+        // Check infoType and extract URL
+    }
+})
+```
+
+#### **C#**
+
+```csharp
+var client = new CopilotClient(new CopilotClientOptions { Remote = true });
+var session = await client.CreateSessionAsync(new SessionConfig
+{
+    WorkingDirectory = "/path/to/github-repo",
+    OnPermissionRequest = async (req, ct) => new() { Allowed = true },
+});
+
+session.On((SessionEvent e) =>
+{
+    if (e is SessionInfoEvent info && info.Data.InfoType == "remote")
+    {
+        Console.WriteLine($"Remote URL: {info.Data.Url}");
+    }
+});
+```
+
+<!-- tabs:end -->
+
+### On-demand (per-session toggle)
+
+Use `session.rpc.remote.enable()` to start remote access mid-session, and `session.rpc.remote.disable()` to stop it. This is equivalent to the CLI's `/remote on` and `/remote off` commands.
+
+<!-- tabs:start -->
+
+#### **TypeScript**
+
+```typescript
+const result = await session.rpc.remote.enable();
+console.log("Remote URL:", result.url);
+
+// Later: stop sharing
+await session.rpc.remote.disable();
+```
+
+#### **Python**
+
+```python
+result = await session.rpc.remote.enable()
+print(f"Remote URL: {result.url}")
+
+# Later: stop sharing
+await session.rpc.remote.disable()
+```
+
+#### **Go**
+
+```go
+result, err := session.RPC.Remote.Enable(ctx)
+fmt.Println("Remote URL:", *result.URL)
+
+// Later: stop sharing
+err = session.RPC.Remote.Disable(ctx)
+```
+
+#### **C#**
+
+```csharp
+var result = await session.Rpc.Remote.EnableAsync();
+Console.WriteLine($"Remote URL: {result.Url}");
+
+// Later: stop sharing
+await session.Rpc.Remote.DisableAsync();
+```
+
+<!-- tabs:end -->
+
+## QR Code Generation
+
+The remote URL can be rendered as a QR code for easy mobile access. The SDK provides the URL — use your preferred QR code library:
+
+- **TypeScript**: [qrcode](https://www.npmjs.com/package/qrcode)
+- **Python**: [qrcode](https://pypi.org/project/qrcode/)
+- **Go**: [go-qrcode](https://github.com/skip2/go-qrcode)
+- **C#**: [QRCoder](https://www.nuget.org/packages/QRCoder)
+
+## Notes
+
+- The `remote` client option only applies when the SDK spawns the CLI process. It is ignored when connecting to an external server via `cliUrl`.
+- If the working directory is not a GitHub repository, remote setup is silently skipped (always-on mode) or returns an error (on-demand mode).
+- Remote sessions require authentication. Ensure `gitHubToken` or `useLoggedInUser` is configured.

docs/index.md

@@ -48,6 +48,7 @@ Guides for building with the SDK's capabilities.
 - [Streaming Events](./features/streaming-events.md) — real-time event reference
 - [Steering & Queueing](./features/steering-and-queueing.md) — message delivery modes
 - [Session Persistence](./features/session-persistence.md) — resume sessions across restarts
+- [Remote Sessions](./features/remote-sessions.md) — share sessions to GitHub web and mobile
 
 ### [Hooks Reference](./hooks/index.md)
 

dotnet/src/Client.cs

@@ -1192,6 +1192,11 @@ private async Task VerifyProtocolVersionAsync(Connection connection, Cancellatio
             args.AddRange(["--session-idle-timeout", options.SessionIdleTimeoutSeconds.Value.ToString(CultureInfo.InvariantCulture)]);
         }
 
+        if (options.Remote)
+        {
+            args.Add("--remote");
+        }
+
         var (fileName, processArgs) = ResolveCliCommand(cliPath, args);
 
         var startInfo = new ProcessStartInfo

dotnet/src/Generated/Rpc.cs

@@ -71,6 +71,7 @@ protected CopilotClientOptions(CopilotClientOptions? other)
         OnListModels = other.OnListModels;
         SessionFs = other.SessionFs;
         SessionIdleTimeoutSeconds = other.SessionIdleTimeoutSeconds;
+        Remote = other.Remote;
     }
 
     /// <summary>
@@ -184,6 +185,15 @@ public string? GithubToken
     /// </summary>
     public int? SessionIdleTimeoutSeconds { get; set; }
 
+    /// <summary>
+    /// Enable remote session support (Mission Control integration).
+    /// When true, sessions in a GitHub repository working directory are
+    /// accessible from GitHub web and mobile.
+    /// This option is only used when the SDK spawns the CLI process; it is ignored
+    /// when connecting to an external server via <see cref="CliUrl"/>.
+    /// </summary>
+    public bool Remote { get; set; }
+
     /// <summary>
     /// Creates a shallow clone of this <see cref="CopilotClientOptions"/> instance.
     /// </summary>

dotnet/src/Types.cs

@@ -223,6 +223,7 @@ func NewClient(options *ClientOptions) *Client {
 			opts.CopilotHome = options.CopilotHome
 		}
 		opts.SessionIdleTimeoutSeconds = options.SessionIdleTimeoutSeconds
+		opts.Remote = options.Remote
 	}
 
 	// Default Env to current environment if not set
@@ -1401,6 +1402,10 @@ func (c *Client) startCLIServer(ctx context.Context) error {
 		args = append(args, "--session-idle-timeout", strconv.Itoa(c.options.SessionIdleTimeoutSeconds))
 	}
 
+	if c.options.Remote {
+		args = append(args, "--remote")
+	}
+
 	// If CLIPath is a .js file, run it with node
 	// Note we can't rely on the shebang as Windows doesn't support it
 	command := cliPath