# How to Share Locally Hosted Copilot SDK Sessions to GitHub Web via Mission Control

> Share local Copilot SDK sessions to GitHub web using Mission Control. Enable remote support during session creation to generate a shareable URL for seamless collaboration.

- Repository: [GitHub/copilot-sdk](https://github.com/github/copilot-sdk)
- Tags: how-to-guide
- Published: 2026-08-02

---

**You can expose local Copilot SDK sessions on GitHub.com by enabling remote support during session creation, which automatically generates a hidden GitHub task accessible through Mission Control's shareable URL.**

The GitHub Copilot SDK enables developers to run AI-assisted coding sessions locally, but you can also surface these sessions on GitHub.com through Mission Control. According to the `github/copilot-sdk` source code, this integration creates a remote-backed task that represents your local session, allowing collaborative debugging and code review directly through the GitHub web interface.

## Enabling Remote Session Support

To initiate the sharing workflow, you must create a session with the `remote` option set to `true`. This flag, defined in [`nodejs/src/types.ts`](https://github.com/github/copilot-sdk/blob/main/nodejs/src/types.ts) within the `SessionOptions` interface, instructs the SDK to establish a connection with Mission Control and create a corresponding GitHub task.

When you call `client.session.create({ remote: true })`, the SDK allocates a local session ID and begins the background sync process to GitHub's remote infrastructure. Unlike standard local sessions, remote-backed sessions cannot use local message APIs after creation.

## Checking Sync Status and Retrieving the Shareable URL

Once the session exists, you must wait for the sync operation to complete before accessing the shareable link. The `client.session.getState()` method returns a state object containing a `status` field and the `shareUrl` property.

According to the RPC definitions in [`nodejs/src/generated/rpc.ts`](https://github.com/github/copilot-sdk/blob/main/nodejs/src/generated/rpc.ts) (lines 17731-17738), the `status` object includes a `synced` boolean that indicates whether the session has been successfully pushed to Mission Control. When `status.synced` equals `true`, the `shareUrl` field contains a URL in the format `https://github.com/<owner>/<repo>/tasks/<task-id>`.

Poll the session state until synchronization completes:

```typescript
let state = await client.session.getState(sessionId);
while (!state.status?.synced) {
  await new Promise(r => setTimeout(r, 500));
  state = await client.session.getState(sessionId);
}
const shareUrl = state.shareUrl;

```

## Controlling Session Visibility

By default, newly created remote sessions may have restricted visibility. The `client.session.setVisibility()` method allows you to modify who can access the session on GitHub.

As implemented in [`nodejs/src/generated/rpc.ts`](https://github.com/github/copilot-sdk/blob/main/nodejs/src/generated/rpc.ts) (lines 20832-20839), this method accepts a session ID and a visibility string—either `"repo"` (visible to all repository readers) or `"unshared"` (visible only to the creator and collaborators). The method returns the updated state including the current `shareUrl`.

```typescript
// Make visible to all repository readers
await client.session.setVisibility(sessionId, "repo");

```

## Limitations of Remote-Backed Sessions

Mission Control sessions operate differently from purely local sessions. According to comments in [`nodejs/src/generated/rpc.ts`](https://github.com/github/copilot-sdk/blob/main/nodejs/src/generated/rpc.ts) (lines 19041-19043), remote-backed sessions **cannot** use the `sendUserMessage` or `runTurn` APIs. Attempting to call these methods on a Mission Control session returns an error.

You must perform all local interactions before the session syncs, or use the Mission Control web UI to resume and interact with the session after it has been shared.

## Complete Implementation Example

The following TypeScript example demonstrates the complete workflow from session creation to sharing:

```typescript
import { CopilotClient } from "@github/copilot-sdk";

// Initialize client pointing to your local SDK server
const client = new CopilotClient({
  endpoint: "http://localhost:7777",
});

// 1. Create session with Mission Control support
const { sessionId } = await client.session.create({ remote: true });

// 2. Poll until synced to GitHub
let state = await client.session.getState(sessionId);
while (!state.status?.synced) {
  await new Promise(r => setTimeout(r, 500));
  state = await client.session.getState(sessionId);
}

// 3. Extract shareable URL
console.log("GitHub URL:", state.shareUrl);

// 4. Optional: Expand visibility to repository readers
await client.session.setVisibility(sessionId, "repo");

// 5. Cleanup when finished
await client.session.close(sessionId);

```

## Summary

- **Enable remote support** by passing `remote: true` to `client.session.create()` to initiate Mission Control integration.
- **Monitor synchronization** by checking `state.status.synced` via `client.session.getState()` until the session appears on GitHub.
- **Retrieve the share link** from the `shareUrl` property once syncing completes, typically formatted as a GitHub task URL.
- **Adjust visibility** using `client.session.setVisibility()` to choose between repository-wide (`"repo"`) or restricted (`"unshared"`) access.
- **Avoid local message APIs** like `sendUserMessage` on remote-backed sessions; interaction must occur before sync or through the GitHub web UI.

## Frequently Asked Questions

### What is Mission Control in the context of the Copilot SDK?

Mission Control is GitHub's hosted "remote-control" service that allows locally running Copilot SDK sessions to be exposed as interactive tasks on GitHub.com. When you enable remote session support, the SDK creates a hidden GitHub task that represents your local session, enabling collaborative debugging and code review through the GitHub web interface.

### How do I check if my Copilot SDK session has synced to Mission Control?

Call `client.session.getState(sessionId)` and examine the `status.synced` boolean field. According to the RPC client implementation in [`nodejs/src/generated/rpc.ts`](https://github.com/github/copilot-sdk/blob/main/nodejs/src/generated/rpc.ts), this field returns `true` only after the session has been successfully pushed to GitHub's Mission Control infrastructure and the `shareUrl` becomes available.

### Can I send messages to a Mission Control session using the SDK's sendUserMessage API?

No. As noted in the source code comments at lines 19041-19043 of [`nodejs/src/generated/rpc.ts`](https://github.com/github/copilot-sdk/blob/main/nodejs/src/generated/rpc.ts), remote-backed Mission Control sessions do not support the `sendUserMessage` or `runTurn` APIs. All user interactions must occur locally before synchronization, or you must use the Mission Control web interface to resume the session after it has been shared.

### What visibility options are available for shared Copilot SDK sessions?

The `client.session.setVisibility()` method supports two visibility levels: `"repo"` makes the session visible to anyone with read access to the repository, while `"unshared"` restricts visibility to the session creator and specific collaborators. This method is defined in [`nodejs/src/generated/rpc.ts`](https://github.com/github/copilot-sdk/blob/main/nodejs/src/generated/rpc.ts) and returns the updated session state including the current share URL.