# Remotesitzungen

Remote-Sitzungen ermöglichen Nutzern den Zugriff auf ihre Copilot-Sitzung über GitHub im Web und auf Mobilgeräten via Mission Control. Wenn diese Option aktiviert ist, verbindet das SDK jede Sitzung mit Mission Control, wodurch eine URL erzeugt wird, die als Link oder QR-Code freigegeben werden kann.

<!-- markdownlint-disable GHD046 GHD005 -->

<!-- Suppressed: GHD046 (outdated release terminology), GHD005 (hardcoded data variable) -->

Weitere Informationen zum Ausführen von Sitzungen auf von GitHub gehosteten Compute-Ressourcen finden Sie unter [Cloud-Sitzungen](/de/copilot/how-tos/copilot-sdk/features/cloud-sessions).

## Voraussetzungen

* Der Benutzer muss authentifiziert werden (GitHub Token oder angemeldeter Benutzer)
* Das Arbeitsverzeichnis der Sitzung muss ein GitHub Repository sein.

## Aktivieren von Remotesitzungen

### Immer aktiv (auf Clientebene)

Legen Sie `enableRemoteSessions: true` beim Erstellen des Clients fest. Jede Sitzung in einem GitHub Repository erhält automatisch eine Remote-URL.

<!-- tabs:start -->

#### Typescript

<!-- docs-validate: skip -->

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

const client = new CopilotClient({ enableRemoteSessions: 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

<!-- docs-validate: skip -->

```python
from copilot import CopilotClient

client = CopilotClient(enable_remote_sessions=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

<!-- docs-validate: skip -->

```golang
client := copilot.NewClient(&copilot.ClientOptions{EnableRemoteSessions: true})
session, _ := client.CreateSession(ctx, &copilot.SessionConfig{
    WorkingDirectory: "/path/to/github-repo",
    OnPermissionRequest: func(req copilot.PermissionRequest, inv copilot.PermissionInvocation) (rpc.PermissionDecision, error) {
        return &rpc.PermissionDecisionApproveOnce{}, nil
    },
})

session.On(func(event copilot.SessionEvent) {
    if event.Type == "session.info" {
        // Check infoType and extract URL
    }
})
```

#### C\#

<!-- docs-validate: skip -->

```csharp
var client = new CopilotClient(new CopilotClientOptions { EnableRemoteSessions = true });
var session = await client.CreateSessionAsync(new SessionConfig
{
    WorkingDirectory = "/path/to/github-repo",
    OnPermissionRequest = (req, inv) =>
        Task.FromResult(PermissionDecision.ApproveOnce()),
});

session.On((SessionEvent e) =>
{
    if (e is SessionInfoEvent info && info.Data.InfoType == "remote")
    {
        Console.WriteLine($"Remote URL: {info.Data.Url}");
    }
});
```

#### Rust

<!-- docs-validate: skip -->

```rust
use github_copilot_sdk::{Client, ClientOptions, SessionConfig};
use github_copilot_sdk::handler::PermissionResult;

let client = Client::start(
    ClientOptions::new().with_enable_remote_sessions(true)
).await?;
let session = client.create_session(
    SessionConfig::new("/path/to/github-repo")
        .with_permission_handler(|_req, _inv| async {
            Ok(PermissionResult::approve_once())
        }),
).await?;

let mut events = session.subscribe();
while let Ok(event) = events.recv().await {
    if event.event_type == "session.info" {
        // Check info_type and extract URL
    }
}
```

<!-- tabs:end -->

### Bei Bedarf (Umschalter pro Sitzung)

Verwenden Sie `session.rpc.remote.enable()`, um den Remotezugriff während der Sitzung zu starten, und `session.rpc.remote.disable()`, um ihn zu beenden. Dies entspricht den CLI-Befehlen `/remote on` und `/remote off`.

<!-- tabs:start -->

#### Typescript

<!-- docs-validate: skip -->

```typescript
const result = await session.rpc.remote.enable();
console.log("Remote URL:", result.url);

// Later: stop sharing
await session.rpc.remote.disable();
```

#### Python

<!-- docs-validate: skip -->

```python
result = await session.rpc.remote.enable()
print(f"Remote URL: {result.url}")

# Later: stop sharing
await session.rpc.remote.disable()
```

#### Go

<!-- docs-validate: skip -->

```golang
result, err := session.RPC.Remote.Enable(ctx)
if result.URL != nil {
    fmt.Println("Remote URL:", *result.URL)
}

// Later: stop sharing
err = session.RPC.Remote.Disable(ctx)
```

#### C\#

<!-- docs-validate: skip -->

```csharp
var result = await session.Rpc.Remote.EnableAsync();
Console.WriteLine($"Remote URL: {result.Url}");

// Later: stop sharing
await session.Rpc.Remote.DisableAsync();
```

#### Rust

<!-- docs-validate: skip -->

```rust
let result = session.rpc().remote().enable().await?;
if let Some(url) = &result.url {
    println!("Remote URL: {url}");
}

// Later: stop sharing
session.rpc().remote().disable().await?;
```

<!-- tabs:end -->

## QR-Codegenerierung

Die Remote-URL kann als QR-Code für einfachen mobilen Zugriff gerendert werden. Das SDK stellt die URL bereit: Verwenden Sie Ihre bevorzugte QR-Codebibliothek:

* **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)
* **Rost**: [qrcode](https://crates.io/crates/qrcode)

## Hinweise

* Die `enableRemoteSessions` Clientoption gilt, wenn das SDK die Laufzeit startet, entweder als untergeordneter Prozess oder als In-Process-Host. Es wird ignoriert, wenn eine Verbindung mit einer bereits ausgeführten Laufzeit hergestellt wird.
* Wenn das Arbeitsverzeichnis kein GitHub-Repository ist, wird die Remote-Konfiguration stillschweigend übersprungen (Always-on-Modus) oder es wird ein Fehler zurückgegeben (On-demand-Modus).
* Remotesitzungen erfordern eine Authentifizierung. Stellen Sie sicher, dass `gitHubToken` oder `useLoggedInUser` konfiguriert ist.