# LibTmux.FSharp.Pane.pressKey

- **Module:** LibTmux.FSharp
- **Package:** LibTmux.FSharp
- **Language:** F#
- **Kind:** function
- **Source:** https://github.com/libtmux/libtmux-dotnet/blob/cf34b255c896d19a97e7d7fabea58609c916012d/src/LibTmux.FSharp/Hierarchy.fsi#L330
- **Page:** https://libtmux.org/en/fsharp/latest/reference/libtmux-fsharp-pane-presskey/

```
val pressKey: cancellationToken: CancellationToken -> key: string -> pane: LibTmux.Pane -> Task
```

Presses one key by its tmux name, such as <c>Enter</c>, <c>C-c</c> or <c>Up</c>.

tmux types a name it does not know as text. Cancellation can occur after dispatch; it does not undo the key.

## Examples

Type a shell command literally, press the named Enter key, and wait for its private completion signal before capturing output. Timeout and command failures escape the program after scoped cleanup; cancellation does not undo dispatched input. Use Linux or macOS with Git, tmux 3.2a or newer, .NET SDK 10.0.303, and the .NET 8 and 10 runtimes. In an empty directory, fetch the documented library revision:

```console
$ git clone https://github.com/libtmux/libtmux-dotnet.git libtmux-source && \
  git -C libtmux-source checkout --detach cf34b255c896d19a97e7d7fabea58609c916012d
```

Save this complete consumer setup as global.json:

[Source example](https://github.com/libtmux/libtmux-dotnet/blob/cf34b255c896d19a97e7d7fabea58609c916012d/global.json).

```json
{
  "sdk": {
    "version": "10.0.303",
    "rollForward": "disable",
    "allowPrerelease": false
  },
  "test": {
    "runner": "Microsoft.Testing.Platform"
  }
}
```

Save this complete consumer setup as NuGet.config:

[Source example](https://github.com/libtmux/libtmux-dotnet/blob/cf34b255c896d19a97e7d7fabea58609c916012d/examples/api/NuGet.config).

```xml
<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <packageSources>
    <clear />
    <add key="libtmux-source" value="libtmux-source/artifacts/api-example-packages" />
    <add key="nuget.org" value="https://api.nuget.org/v3/index.json" />
  </packageSources>
  <packageSourceMapping>
    <clear />
    <packageSource key="libtmux-source">
      <package pattern="LibTmux" />
      <package pattern="LibTmux.*" />
    </packageSource>
    <packageSource key="nuget.org">
      <package pattern="*" />
    </packageSource>
  </packageSourceMapping>
</configuration>
```

Save this complete consumer setup as Example.fsproj:

[Source example](https://github.com/libtmux/libtmux-dotnet/blob/cf34b255c896d19a97e7d7fabea58609c916012d/examples/api/fsharp/Example.fsproj).

```xml
<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFrameworks>net8.0;net10.0</TargetFrameworks>
    <LangVersion>10.0</LangVersion>
    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
    <DisableImplicitFSharpCoreReference>true</DisableImplicitFSharpCoreReference>
    <DisableImplicitLibraryPacksFolder>true</DisableImplicitLibraryPacksFolder>
  </PropertyGroup>
  <ItemGroup>
    <Compile Include="Program.fs" />
    <PackageReference Include="FSharp.Core" Version="[10.1.303]" />
    <PackageReference Include="LibTmux.FSharp" Version="[0.0.0-alpha.20]" />
  </ItemGroup>
</Project>
```

Save this complete program as Program.fs. It creates a private server with LibTmux.Server.CreateOwnedAsync; use! disposes owned scopes after success, cancellation or failure. The F# facade has no separate server constructor.

[Source example](https://github.com/libtmux/libtmux-dotnet/blob/cf34b255c896d19a97e7d7fabea58609c916012d/examples/LibTmux.FSharp.Examples/Programs/InputCapture.fs).

```fsharp
open System
open System.Threading
open LibTmux
open LibTmux.FSharp

let quoteShell (value: string) = "'" + value.Replace("'", "'\\''") + "'"

let runAsync () =
    task {
        use deadline = new CancellationTokenSource(TimeSpan.FromSeconds 10.)
        let token = deadline.Token

        let socketName = "fsharp-capture-" + Guid.NewGuid().ToString("N")

        let options =
            ServerConnectionOptions(SocketName = socketName, ConfigurationFile = "/dev/null")

        use! owned = options |> Server.createOwned token

        use! _session =
            owned.Value.CreateOwnedSessionAsync(NewSessionRequest(Name = "demo", Command = "/bin/sh"), token)

        let server = owned.Value
        let! panes = server |> Server.panes |> Query.list token
        let pane = panes |> Seq.exactlyOne
        let channel = "capture-" + Guid.NewGuid().ToString("N")
        use wait = server.OpenWaitChannel(channel)
        let marker = "api capture ready"

        let command =
            sprintf
                "printf '%%s\\n' %s; tmux -L %s wait-for -S %s"
                (quoteShell marker)
                (quoteShell socketName)
                (quoteShell channel)

        do! pane |> Pane.sendText token command

        do! pane |> Pane.pressKey token "Enter"
        let! ready = wait.WaitAsync(TimeSpan.FromSeconds 5., token)
        printfn "The shell signalled: %b" ready

        let! lines = pane |> Pane.capture token (CapturePaneRequest(JoinWrappedLines = true))

        // Joining wrapped lines keeps the terminal's padding after the output,
        // and only a whole line counts, so the echoed command cannot match.
        match lines |> Seq.map (fun line -> line.TrimEnd()) |> Seq.tryFind ((=) marker) with
        | Some line -> printfn "Captured line: %s" line
        | None -> printfn "Captured line: none"
    }

runAsync().GetAwaiter().GetResult()
```

Build the exact source packages and the saved consumer, then run both supported frameworks. The local package feed prevents an unrelated published package from satisfying the restore. Each program checks its result and exits unsuccessfully after an unhandled error:

```console
$ export NUGET_PACKAGES="$PWD/packages" && \
  dotnet restore libtmux-source/src/LibTmux.FSharp/LibTmux.FSharp.fsproj --locked-mode && \
  dotnet pack libtmux-source/src/LibTmux/LibTmux.csproj \
    --configuration Release --no-restore -p:ContinuousIntegrationBuild=true \
    --output "$PWD/libtmux-source/artifacts/api-example-packages" && \
  dotnet pack libtmux-source/src/LibTmux.FSharp/LibTmux.FSharp.fsproj \
    --configuration Release --no-restore -p:ContinuousIntegrationBuild=true \
    --output "$PWD/libtmux-source/artifacts/api-example-packages" && \
  dotnet restore Example.fsproj --configfile NuGet.config && \
  dotnet build Example.fsproj --configuration Release --no-restore --warnaserror && \
  export LIBTMUX_TMUX="$(command -v tmux)" && \
  export TMUX_TMPDIR=/tmp/libtmux-dotnet-dev && \
  mkdir -p "$TMUX_TMPDIR" && \
  unset TMUX TMUX_PANE && \
  dotnet bin/Release/net8.0/Example.dll && \
  dotnet bin/Release/net10.0/Example.dll
```

Expected program output from each framework:

```text
The shell signalled: true
Captured line: api capture ready
```

## Parameters

- `cancellationToken` (`CancellationToken`)
- `key` (`string`)
- `pane` (`LibTmux.Pane`)

## Raises

- [`System.ArgumentException`](https://learn.microsoft.com/dotnet/api/system.argumentexception): The key is empty or white space.