# Session switcher Source: https://libtmux.org/en/prompts/session-switcher/ > A fuzzy picker over every session, window and pane, that attaches or switches to the selection. A fuzzy picker over every session, window and pane, that attaches or switches to the selection. Task A fuzzy picker over every session, window and pane, that attaches or switches to the selection. ``` Then build a tmux session switcher. libtmux drives a real tmux server from code. It gives you objects for the server, its sessions, windows and panes. Documentation for every language is at https://libtmux.org/en/. Language: Python Package: libtmux (PyPI) Repository: https://github.com/tmux-python/libtmux Read these before writing code: - https://libtmux.org/en/py/latest/llms.txt every page for Python, as a list - https://libtmux.org/en/py/latest/docs.json the same list with headings, as JSON - https://libtmux.org/en/py/latest/reference/ the Python API reference If you cannot fetch URLs, clone the repository above and read its README and examples instead, or ask me to paste those pages in. Set up first: 1. Report the tmux version with `tmux -V`. libtmux drives a real tmux, so nothing below works without one. Stop and tell me if it is missing. 2. If this directory is not a Python project yet, start one: uv init Skip this in a project that already exists, and match what is here. 3. Add the dependency. libtmux 0.62.0 is the current release on PyPI. uv add libtmux Check https://pypi.org/project/libtmux/ if you need a different version. If this project already uses pip, Poetry or PDM, add the dependency with that tool instead: the package is the same. 4. Write the smallest program that proves the install works: connect to a tmux server, create a session, confirm it is there, then kill it. Give that server a socket of its own rather than using the default one, so this never touches a tmux I am already running. Run it, and show me the output and the files you added. Rules for everything below: - Use the reference above rather than guessing names. The ten libtmux ports do not share spellings, and a name from another language will look plausible and not exist. - If the reference does not have something you expected, say so instead of writing a call that does not exist. - Follow the conventions already in this repository. Session switcher What it does: - Lists every session on the server with its windows, and shows what each window's active pane is running, so the list says something more useful than a set of names. - Filters as I type and attaches to, or switches the client to, what I pick. - Works both from outside tmux and from inside it. Those need different calls, and getting the inside case wrong is the usual bug here: attaching from within a session nests one client inside another. Constraints: - Read the live server every time. Do not cache a session list between runs. - Handle there being no server running at all, which is the first-run case. - Fetch the listing in as few round trips as the API allows and say how many it costs. One call per pane is the slow shape this should avoid. - Keep it to one file I can read in a sitting. Anchor it in these pages: - https://libtmux.org/en/tmux/concepts/queries/ queries - https://libtmux.org/en/tmux/guides/querying-and-filtering/ querying and filtering - https://libtmux.org/en/tmux/guides/attaching-to-tmux/ attaching to tmux ``` ``` Then build a tmux session switcher. libtmux drives a real tmux server from code. It gives you objects for the server, its sessions, windows and panes. Documentation for every language is at https://libtmux.org/en/. Language: Ruby Package: libtmux (RubyGems) Repository: https://github.com/libtmux/libtmux-ruby Read these before writing code: - https://libtmux.org/en/ruby/latest/llms.txt every page for Ruby, as a list - https://libtmux.org/en/ruby/latest/docs.json the same list with headings, as JSON - https://libtmux.org/en/ruby/latest/reference/ the Ruby API reference If you cannot fetch URLs, clone the repository above and read its README and examples instead, or ask me to paste those pages in. Set up first: 1. Report the tmux version with `tmux -V`. libtmux drives a real tmux, so nothing below works without one. Stop and tell me if it is missing. 2. If this directory is not a Ruby project yet, start one: bundle init Skip this in a project that already exists, and match what is here. 3. Add the dependency. libtmux has no stable release. 0.1.0.alpha.1 is the newest prerelease on RubyGems, and the command below names it because the resolver skips prereleases otherwise. bundle add libtmux --version 0.1.0.alpha.1 Check https://rubygems.org/gems/libtmux for a newer version, and prefer a stable release over this one if there now is any. 4. Write the smallest program that proves the install works: connect to a tmux server, create a session, confirm it is there, then kill it. Give that server a socket of its own rather than using the default one, so this never touches a tmux I am already running. Run it, and show me the output and the files you added. Rules for everything below: - Use the reference above rather than guessing names. The ten libtmux ports do not share spellings, and a name from another language will look plausible and not exist. - If the reference does not have something you expected, say so instead of writing a call that does not exist. - Follow the conventions already in this repository. Session switcher What it does: - Lists every session on the server with its windows, and shows what each window's active pane is running, so the list says something more useful than a set of names. - Filters as I type and attaches to, or switches the client to, what I pick. - Works both from outside tmux and from inside it. Those need different calls, and getting the inside case wrong is the usual bug here: attaching from within a session nests one client inside another. Constraints: - Read the live server every time. Do not cache a session list between runs. - Handle there being no server running at all, which is the first-run case. - Fetch the listing in as few round trips as the API allows and say how many it costs. One call per pane is the slow shape this should avoid. - Keep it to one file I can read in a sitting. Anchor it in these pages: - https://libtmux.org/en/tmux/concepts/queries/ queries - https://libtmux.org/en/tmux/guides/querying-and-filtering/ querying and filtering - https://libtmux.org/en/tmux/guides/attaching-to-tmux/ attaching to tmux ``` ``` Then build a tmux session switcher. libtmux drives a real tmux server from code. It gives you objects for the server, its sessions, windows and panes. Documentation for every language is at https://libtmux.org/en/. Language: Lua Package: libtmux (LuaRocks) Repository: https://github.com/libtmux/libtmux-lua Read these before writing code: - https://libtmux.org/en/lua/latest/llms.txt every page for Lua, as a list - https://libtmux.org/en/lua/latest/docs.json the same list with headings, as JSON - https://libtmux.org/en/lua/latest/reference/ the Lua API reference If you cannot fetch URLs, clone the repository above and read its README and examples instead, or ask me to paste those pages in. Set up first: 1. Report the tmux version with `tmux -V`. libtmux drives a real tmux, so nothing below works without one. Stop and tell me if it is missing. 2. If this directory is not a Lua project yet, start one: luarocks init Skip this in a project that already exists, and match what is here. 3. Add the dependency. libtmux has no stable release. 0.1.0alpha1-1 is the newest prerelease on LuaRocks, and the command below names it because the resolver skips prereleases otherwise. luarocks --local install libtmux 0.1.0alpha1-1 Check https://luarocks.org/modules/tony/libtmux for a newer version, and prefer a stable release over this one if there now is any. 4. Write the smallest program that proves the install works: connect to a tmux server, create a session, confirm it is there, then kill it. Give that server a socket of its own rather than using the default one, so this never touches a tmux I am already running. Run it, and show me the output and the files you added. Rules for everything below: - Use the reference above rather than guessing names. The ten libtmux ports do not share spellings, and a name from another language will look plausible and not exist. - If the reference does not have something you expected, say so instead of writing a call that does not exist. - Follow the conventions already in this repository. Session switcher What it does: - Lists every session on the server with its windows, and shows what each window's active pane is running, so the list says something more useful than a set of names. - Filters as I type and attaches to, or switches the client to, what I pick. - Works both from outside tmux and from inside it. Those need different calls, and getting the inside case wrong is the usual bug here: attaching from within a session nests one client inside another. Constraints: - Read the live server every time. Do not cache a session list between runs. - Handle there being no server running at all, which is the first-run case. - Fetch the listing in as few round trips as the API allows and say how many it costs. One call per pane is the slow shape this should avoid. - Keep it to one file I can read in a sitting. Anchor it in these pages: - https://libtmux.org/en/tmux/concepts/queries/ queries - https://libtmux.org/en/tmux/guides/querying-and-filtering/ querying and filtering - https://libtmux.org/en/tmux/guides/attaching-to-tmux/ attaching to tmux ``` ``` Then build a tmux session switcher. libtmux drives a real tmux server from code. It gives you objects for the server, its sessions, windows and panes. Documentation for every language is at https://libtmux.org/en/. Language: PowerShell Package: LibTmux (PowerShell Gallery) Repository: https://github.com/libtmux/libtmux-powershell Read these before writing code: - https://libtmux.org/en/powershell/latest/llms.txt every page for PowerShell, as a list - https://libtmux.org/en/powershell/latest/docs.json the same list with headings, as JSON - https://libtmux.org/en/powershell/latest/reference/ the PowerShell API reference If you cannot fetch URLs, clone the repository above and read its README and examples instead, or ask me to paste those pages in. Set up first: 1. Report the tmux version with `tmux -V`. libtmux drives a real tmux, so nothing below works without one. Stop and tell me if it is missing. 2. If this directory is not a PowerShell project yet, Create a PowerShell script in this directory; no project manifest is required. Skip this in a project that already exists, and match what is here. 3. Add the dependency. LibTmux has no stable release. 0.1.0-alpha2 is the newest prerelease on PowerShell Gallery, and the command below names it because the resolver skips prereleases otherwise. Install-Module -Name LibTmux -RequiredVersion 0.1.0-alpha2 -AllowPrerelease Check https://www.powershellgallery.com/packages/LibTmux for a newer version, and prefer a stable release over this one if there now is any. Import LibTmux after installation. LibTmux.Workspace is a separate module; the .NET MCP tool does not import either module. 4. Write the smallest program that proves the install works: connect to a tmux server, create a session, confirm it is there, then kill it. Give that server a socket of its own rather than using the default one, so this never touches a tmux I am already running. Run it, and show me the output and the files you added. Rules for everything below: - Use the reference above rather than guessing names. The ten libtmux ports do not share spellings, and a name from another language will look plausible and not exist. - If the reference does not have something you expected, say so instead of writing a call that does not exist. - Follow the conventions already in this repository. Session switcher What it does: - Lists every session on the server with its windows, and shows what each window's active pane is running, so the list says something more useful than a set of names. - Filters as I type and attaches to, or switches the client to, what I pick. - Works both from outside tmux and from inside it. Those need different calls, and getting the inside case wrong is the usual bug here: attaching from within a session nests one client inside another. Constraints: - Read the live server every time. Do not cache a session list between runs. - Handle there being no server running at all, which is the first-run case. - Fetch the listing in as few round trips as the API allows and say how many it costs. One call per pane is the slow shape this should avoid. - Keep it to one file I can read in a sitting. Anchor it in these pages: - https://libtmux.org/en/tmux/concepts/queries/ queries - https://libtmux.org/en/tmux/guides/querying-and-filtering/ querying and filtering - https://libtmux.org/en/tmux/guides/attaching-to-tmux/ attaching to tmux ``` ``` Then build a tmux session switcher. libtmux drives a real tmux server from code. It gives you objects for the server, its sessions, windows and panes. Documentation for every language is at https://libtmux.org/en/. Language: Julia Package: LibTmux (its repository) Repository: https://github.com/libtmux/libtmux-julia Read these before writing code: - https://libtmux.org/en/julia/latest/llms.txt every page for Julia, as a list - https://libtmux.org/en/julia/latest/docs.json the same list with headings, as JSON - https://libtmux.org/en/julia/latest/reference/ the Julia API reference If you cannot fetch URLs, clone the repository above and read its README and examples instead, or ask me to paste those pages in. Set up first: 1. Report the tmux version with `tmux -V`. libtmux drives a real tmux, so nothing below works without one. Stop and tell me if it is missing. 2. If this directory is not a Julia project yet, start one: using Pkg Pkg.activate(".") Skip this in a project that already exists, and match what is here. 3. Add the dependency. LibTmux is not published to its registry yet, so this installs from the repository at tag v0.1.0-alpha.1. using Pkg Pkg.add(PackageSpec(url="https://github.com/libtmux/libtmux-julia.git", rev="v0.1.0-alpha.1")) Check https://github.com/libtmux/libtmux-julia for a newer version, and prefer a stable release over this one if there now is any. Julia 1.10+ and tmux 3.2a+ are compatibility targets; see the compatibility guide for tested versions. Companion packages share the core source release. 4. Write the smallest program that proves the install works: connect to a tmux server, create a session, confirm it is there, then kill it. Give that server a socket of its own rather than using the default one, so this never touches a tmux I am already running. Run it, and show me the output and the files you added. Rules for everything below: - Use the reference above rather than guessing names. The ten libtmux ports do not share spellings, and a name from another language will look plausible and not exist. - If the reference does not have something you expected, say so instead of writing a call that does not exist. - Follow the conventions already in this repository. Session switcher What it does: - Lists every session on the server with its windows, and shows what each window's active pane is running, so the list says something more useful than a set of names. - Filters as I type and attaches to, or switches the client to, what I pick. - Works both from outside tmux and from inside it. Those need different calls, and getting the inside case wrong is the usual bug here: attaching from within a session nests one client inside another. Constraints: - Read the live server every time. Do not cache a session list between runs. - Handle there being no server running at all, which is the first-run case. - Fetch the listing in as few round trips as the API allows and say how many it costs. One call per pane is the slow shape this should avoid. - Keep it to one file I can read in a sitting. Anchor it in these pages: - https://libtmux.org/en/tmux/concepts/queries/ queries - https://libtmux.org/en/tmux/guides/querying-and-filtering/ querying and filtering - https://libtmux.org/en/tmux/guides/attaching-to-tmux/ attaching to tmux ``` ``` Then build a tmux session switcher. libtmux drives a real tmux server from code. It gives you objects for the server, its sessions, windows and panes. Documentation for every language is at https://libtmux.org/en/. Language: TypeScript Package: libtmux (npm) Repository: https://github.com/libtmux/libtmux-ts Read these before writing code: - https://libtmux.org/en/ts/latest/llms.txt every page for TypeScript, as a list - https://libtmux.org/en/ts/latest/docs.json the same list with headings, as JSON - https://libtmux.org/en/ts/latest/reference/ the TypeScript API reference If you cannot fetch URLs, clone the repository above and read its README and examples instead, or ask me to paste those pages in. Set up first: 1. Report the tmux version with `tmux -V`. libtmux drives a real tmux, so nothing below works without one. Stop and tell me if it is missing. 2. If this directory is not a TypeScript project yet, start one: bun init Skip this in a project that already exists, and match what is here. 3. Add the dependency. libtmux has no stable release. 0.1.0-alpha.12 is the newest prerelease on npm, and the command below names it because the resolver skips prereleases otherwise. bun add libtmux@0.1.0-alpha.12 Check https://www.npmjs.com/package/libtmux for a newer version, and prefer a stable release over this one if there now is any. 4. Write the smallest program that proves the install works: connect to a tmux server, create a session, confirm it is there, then kill it. Give that server a socket of its own rather than using the default one, so this never touches a tmux I am already running. Run it, and show me the output and the files you added. Rules for everything below: - Use the reference above rather than guessing names. The ten libtmux ports do not share spellings, and a name from another language will look plausible and not exist. - If the reference does not have something you expected, say so instead of writing a call that does not exist. - Follow the conventions already in this repository. Session switcher What it does: - Lists every session on the server with its windows, and shows what each window's active pane is running, so the list says something more useful than a set of names. - Filters as I type and attaches to, or switches the client to, what I pick. - Works both from outside tmux and from inside it. Those need different calls, and getting the inside case wrong is the usual bug here: attaching from within a session nests one client inside another. Constraints: - Read the live server every time. Do not cache a session list between runs. - Handle there being no server running at all, which is the first-run case. - Fetch the listing in as few round trips as the API allows and say how many it costs. One call per pane is the slow shape this should avoid. - Keep it to one file I can read in a sitting. Anchor it in these pages: - https://libtmux.org/en/tmux/concepts/queries/ queries - https://libtmux.org/en/tmux/guides/querying-and-filtering/ querying and filtering - https://libtmux.org/en/tmux/guides/attaching-to-tmux/ attaching to tmux ``` ``` Then build a tmux session switcher. libtmux drives a real tmux server from code. It gives you objects for the server, its sessions, windows and panes. Documentation for every language is at https://libtmux.org/en/. Language: Rust Package: libtmux (crates.io) Repository: https://github.com/libtmux/libtmux-rs Read these before writing code: - https://libtmux.org/en/rs/latest/llms.txt every page for Rust, as a list - https://libtmux.org/en/rs/latest/docs.json the same list with headings, as JSON - https://libtmux.org/en/rs/latest/reference/ the Rust API reference - https://docs.rs/libtmux Rust reference on docs.rs If you cannot fetch URLs, clone the repository above and read its README and examples instead, or ask me to paste those pages in. Set up first: 1. Report the tmux version with `tmux -V`. libtmux drives a real tmux, so nothing below works without one. Stop and tell me if it is missing. 2. If this directory is not a Rust project yet, start one: cargo init Skip this in a project that already exists, and match what is here. 3. Add the dependency. libtmux has no stable release. 0.1.0-alpha.15 is the newest prerelease on crates.io, and the command below names it because the resolver skips prereleases otherwise. cargo add libtmux@0.1.0-alpha.15 Check https://crates.io/crates/libtmux for a newer version, and prefer a stable release over this one if there now is any. 4. Write the smallest program that proves the install works: connect to a tmux server, create a session, confirm it is there, then kill it. Give that server a socket of its own rather than using the default one, so this never touches a tmux I am already running. Run it, and show me the output and the files you added. Rules for everything below: - Use the reference above rather than guessing names. The ten libtmux ports do not share spellings, and a name from another language will look plausible and not exist. - If the reference does not have something you expected, say so instead of writing a call that does not exist. - Follow the conventions already in this repository. Session switcher What it does: - Lists every session on the server with its windows, and shows what each window's active pane is running, so the list says something more useful than a set of names. - Filters as I type and attaches to, or switches the client to, what I pick. - Works both from outside tmux and from inside it. Those need different calls, and getting the inside case wrong is the usual bug here: attaching from within a session nests one client inside another. Constraints: - Read the live server every time. Do not cache a session list between runs. - Handle there being no server running at all, which is the first-run case. - Fetch the listing in as few round trips as the API allows and say how many it costs. One call per pane is the slow shape this should avoid. - Keep it to one file I can read in a sitting. Anchor it in these pages: - https://libtmux.org/en/tmux/concepts/queries/ queries - https://libtmux.org/en/tmux/guides/querying-and-filtering/ querying and filtering - https://libtmux.org/en/tmux/guides/attaching-to-tmux/ attaching to tmux ``` ``` Then build a tmux session switcher. libtmux drives a real tmux server from code. It gives you objects for the server, its sessions, windows and panes. Documentation for every language is at https://libtmux.org/en/. Language: Go Package: github.com/libtmux/libtmux-go/tmux (pkg.go.dev) Repository: https://github.com/libtmux/libtmux-go Read these before writing code: - https://libtmux.org/en/go/latest/llms.txt every page for Go, as a list - https://libtmux.org/en/go/latest/docs.json the same list with headings, as JSON - https://libtmux.org/en/go/latest/reference/ the Go API reference - https://pkg.go.dev/github.com/libtmux/libtmux-go/tmux Go reference on pkg.go.dev If you cannot fetch URLs, clone the repository above and read its README and examples instead, or ask me to paste those pages in. Set up first: 1. Report the tmux version with `tmux -V`. libtmux drives a real tmux, so nothing below works without one. Stop and tell me if it is missing. 2. If this directory is not a Go project yet, start one: go mod init example.com/tmuxdemo Skip this in a project that already exists, and match what is here. 3. Add the dependency. github.com/libtmux/libtmux-go/tmux has no stable release. v0.0.1-alpha.9 is the newest prerelease on pkg.go.dev, and the command below names it because the resolver skips prereleases otherwise. go get github.com/libtmux/libtmux-go@v0.0.1-alpha.9 Check https://pkg.go.dev/github.com/libtmux/libtmux-go/tmux for a newer version, and prefer a stable release over this one if there now is any. 4. Write the smallest program that proves the install works: connect to a tmux server, create a session, confirm it is there, then kill it. Give that server a socket of its own rather than using the default one, so this never touches a tmux I am already running. Run it, and show me the output and the files you added. Rules for everything below: - Use the reference above rather than guessing names. The ten libtmux ports do not share spellings, and a name from another language will look plausible and not exist. - If the reference does not have something you expected, say so instead of writing a call that does not exist. - Follow the conventions already in this repository. Session switcher What it does: - Lists every session on the server with its windows, and shows what each window's active pane is running, so the list says something more useful than a set of names. - Filters as I type and attaches to, or switches the client to, what I pick. - Works both from outside tmux and from inside it. Those need different calls, and getting the inside case wrong is the usual bug here: attaching from within a session nests one client inside another. Constraints: - Read the live server every time. Do not cache a session list between runs. - Handle there being no server running at all, which is the first-run case. - Fetch the listing in as few round trips as the API allows and say how many it costs. One call per pane is the slow shape this should avoid. - Keep it to one file I can read in a sitting. Anchor it in these pages: - https://libtmux.org/en/tmux/concepts/queries/ queries - https://libtmux.org/en/tmux/guides/querying-and-filtering/ querying and filtering - https://libtmux.org/en/tmux/guides/attaching-to-tmux/ attaching to tmux ``` ``` Then build a tmux session switcher. libtmux drives a real tmux server from code. It gives you objects for the server, its sessions, windows and panes. Documentation for every language is at https://libtmux.org/en/. Language: Java Package: io.github.libtmux:libtmux (Maven Central) Repository: https://github.com/libtmux/libtmux-java Read these before writing code: - https://libtmux.org/en/java/latest/llms.txt every page for Java, as a list - https://libtmux.org/en/java/latest/docs.json the same list with headings, as JSON - https://libtmux.org/en/java/latest/reference/ the Java API reference - https://javadoc.io/doc/io.github.libtmux/libtmux Java reference on javadoc.io If you cannot fetch URLs, clone the repository above and read its README and examples instead, or ask me to paste those pages in. Set up first: 1. Report the tmux version with `tmux -V`. libtmux drives a real tmux, so nothing below works without one. Stop and tell me if it is missing. 2. If this directory is not a Java project yet, start one: gradle init --type java-application --dsl kotlin Skip this in a project that already exists, and match what is here. 3. Add the dependency. io.github.libtmux:libtmux has no stable release. 0.0.1-alpha.17 is the newest prerelease on Maven Central, and the command below names it because the resolver skips prereleases otherwise. implementation("io.github.libtmux:libtmux:0.0.1-alpha.17") Check https://central.sonatype.com/artifact/io.github.libtmux/libtmux for a newer version, and prefer a stable release over this one if there now is any. 4. Write the smallest program that proves the install works: connect to a tmux server, create a session, confirm it is there, then kill it. Give that server a socket of its own rather than using the default one, so this never touches a tmux I am already running. Run it, and show me the output and the files you added. Rules for everything below: - Use the reference above rather than guessing names. The ten libtmux ports do not share spellings, and a name from another language will look plausible and not exist. - If the reference does not have something you expected, say so instead of writing a call that does not exist. - Follow the conventions already in this repository. Session switcher What it does: - Lists every session on the server with its windows, and shows what each window's active pane is running, so the list says something more useful than a set of names. - Filters as I type and attaches to, or switches the client to, what I pick. - Works both from outside tmux and from inside it. Those need different calls, and getting the inside case wrong is the usual bug here: attaching from within a session nests one client inside another. Constraints: - Read the live server every time. Do not cache a session list between runs. - Handle there being no server running at all, which is the first-run case. - Fetch the listing in as few round trips as the API allows and say how many it costs. One call per pane is the slow shape this should avoid. - Keep it to one file I can read in a sitting. Anchor it in these pages: - https://libtmux.org/en/tmux/concepts/queries/ queries - https://libtmux.org/en/tmux/guides/querying-and-filtering/ querying and filtering - https://libtmux.org/en/tmux/guides/attaching-to-tmux/ attaching to tmux ``` ``` Then build a tmux session switcher. libtmux drives a real tmux server from code. It gives you objects for the server, its sessions, windows and panes. Documentation for every language is at https://libtmux.org/en/. Language: Kotlin Package: io.github.libtmux:libtmux-kotlin (Maven Central) Repository: https://github.com/libtmux/libtmux-java Read these before writing code: - https://libtmux.org/en/kotlin/latest/llms.txt every page for Kotlin, as a list - https://libtmux.org/en/kotlin/latest/docs.json the same list with headings, as JSON - https://libtmux.org/en/kotlin/latest/reference/ the Kotlin API reference - https://javadoc.io/doc/io.github.libtmux/libtmux-kotlin Kotlin reference on Dokka If you cannot fetch URLs, clone the repository above and read its README and examples instead, or ask me to paste those pages in. Set up first: 1. Report the tmux version with `tmux -V`. libtmux drives a real tmux, so nothing below works without one. Stop and tell me if it is missing. 2. If this directory is not a Kotlin project yet, start one: gradle init --type kotlin-application --dsl kotlin Skip this in a project that already exists, and match what is here. 3. Add the dependency. io.github.libtmux:libtmux-kotlin has no stable release. 0.0.1-alpha.17 is the newest prerelease on Maven Central, and the command below names it because the resolver skips prereleases otherwise. implementation("io.github.libtmux:libtmux-kotlin:0.0.1-alpha.17") Check https://central.sonatype.com/artifact/io.github.libtmux/libtmux-kotlin for a newer version, and prefer a stable release over this one if there now is any. 4. Write the smallest program that proves the install works: connect to a tmux server, create a session, confirm it is there, then kill it. Give that server a socket of its own rather than using the default one, so this never touches a tmux I am already running. Run it, and show me the output and the files you added. Rules for everything below: - Use the reference above rather than guessing names. The ten libtmux ports do not share spellings, and a name from another language will look plausible and not exist. - If the reference does not have something you expected, say so instead of writing a call that does not exist. - Follow the conventions already in this repository. Session switcher What it does: - Lists every session on the server with its windows, and shows what each window's active pane is running, so the list says something more useful than a set of names. - Filters as I type and attaches to, or switches the client to, what I pick. - Works both from outside tmux and from inside it. Those need different calls, and getting the inside case wrong is the usual bug here: attaching from within a session nests one client inside another. Constraints: - Read the live server every time. Do not cache a session list between runs. - Handle there being no server running at all, which is the first-run case. - Fetch the listing in as few round trips as the API allows and say how many it costs. One call per pane is the slow shape this should avoid. - Keep it to one file I can read in a sitting. Anchor it in these pages: - https://libtmux.org/en/tmux/concepts/queries/ queries - https://libtmux.org/en/tmux/guides/querying-and-filtering/ querying and filtering - https://libtmux.org/en/tmux/guides/attaching-to-tmux/ attaching to tmux ``` ``` Then build a tmux session switcher. libtmux drives a real tmux server from code. It gives you objects for the server, its sessions, windows and panes. Documentation for every language is at https://libtmux.org/en/. Language: Scala Package: io.github.libtmux:libtmux-scala_3 (Maven Central) Repository: https://github.com/libtmux/libtmux-java Read these before writing code: - https://libtmux.org/en/scala/latest/llms.txt every page for Scala, as a list - https://libtmux.org/en/scala/latest/docs.json the same list with headings, as JSON - https://libtmux.org/en/scala/latest/reference/ the Scala API reference - https://javadoc.io/doc/io.github.libtmux/libtmux-scala_3 Scala reference on Scaladoc If you cannot fetch URLs, clone the repository above and read its README and examples instead, or ask me to paste those pages in. Set up first: 1. Report the tmux version with `tmux -V`. libtmux drives a real tmux, so nothing below works without one. Stop and tell me if it is missing. 2. If this directory is not a Scala project yet, start one: sbt new scala/scala3.g8 Skip this in a project that already exists, and match what is here. 3. Add the dependency. io.github.libtmux:libtmux-scala_3 has no stable release. 0.0.1-alpha.17 is the newest prerelease on Maven Central, and the command below names it because the resolver skips prereleases otherwise. libraryDependencies += "io.github.libtmux" %% "libtmux-scala" % "0.0.1-alpha.17" Check https://central.sonatype.com/artifact/io.github.libtmux/libtmux-scala_3 for a newer version, and prefer a stable release over this one if there now is any. 4. Write the smallest program that proves the install works: connect to a tmux server, create a session, confirm it is there, then kill it. Give that server a socket of its own rather than using the default one, so this never touches a tmux I am already running. Run it, and show me the output and the files you added. Rules for everything below: - Use the reference above rather than guessing names. The ten libtmux ports do not share spellings, and a name from another language will look plausible and not exist. - If the reference does not have something you expected, say so instead of writing a call that does not exist. - Follow the conventions already in this repository. Session switcher What it does: - Lists every session on the server with its windows, and shows what each window's active pane is running, so the list says something more useful than a set of names. - Filters as I type and attaches to, or switches the client to, what I pick. - Works both from outside tmux and from inside it. Those need different calls, and getting the inside case wrong is the usual bug here: attaching from within a session nests one client inside another. Constraints: - Read the live server every time. Do not cache a session list between runs. - Handle there being no server running at all, which is the first-run case. - Fetch the listing in as few round trips as the API allows and say how many it costs. One call per pane is the slow shape this should avoid. - Keep it to one file I can read in a sitting. Anchor it in these pages: - https://libtmux.org/en/tmux/concepts/queries/ queries - https://libtmux.org/en/tmux/guides/querying-and-filtering/ querying and filtering - https://libtmux.org/en/tmux/guides/attaching-to-tmux/ attaching to tmux ``` ``` Then build a tmux session switcher. libtmux drives a real tmux server from code. It gives you objects for the server, its sessions, windows and panes. Documentation for every language is at https://libtmux.org/en/. Language: C# Package: LibTmux (NuGet) Repository: https://github.com/libtmux/libtmux-dotnet Read these before writing code: - https://libtmux.org/en/csharp/latest/llms.txt every page for C#, as a list - https://libtmux.org/en/csharp/latest/docs.json the same list with headings, as JSON - https://libtmux.org/en/csharp/latest/reference/ the C# API reference If you cannot fetch URLs, clone the repository above and read its README and examples instead, or ask me to paste those pages in. Set up first: 1. Report the tmux version with `tmux -V`. libtmux drives a real tmux, so nothing below works without one. Stop and tell me if it is missing. 2. If this directory is not a C# project yet, start one: dotnet new console Skip this in a project that already exists, and match what is here. 3. Add the dependency. LibTmux has no stable release. 0.0.0-alpha.21 is the newest prerelease on NuGet, and the command below names it because the resolver skips prereleases otherwise. dotnet add package LibTmux --version 0.0.0-alpha.21 Check https://www.nuget.org/packages/LibTmux for a newer version, and prefer a stable release over this one if there now is any. 4. Write the smallest program that proves the install works: connect to a tmux server, create a session, confirm it is there, then kill it. Give that server a socket of its own rather than using the default one, so this never touches a tmux I am already running. Run it, and show me the output and the files you added. Rules for everything below: - Use the reference above rather than guessing names. The ten libtmux ports do not share spellings, and a name from another language will look plausible and not exist. - If the reference does not have something you expected, say so instead of writing a call that does not exist. - Follow the conventions already in this repository. Session switcher What it does: - Lists every session on the server with its windows, and shows what each window's active pane is running, so the list says something more useful than a set of names. - Filters as I type and attaches to, or switches the client to, what I pick. - Works both from outside tmux and from inside it. Those need different calls, and getting the inside case wrong is the usual bug here: attaching from within a session nests one client inside another. Constraints: - Read the live server every time. Do not cache a session list between runs. - Handle there being no server running at all, which is the first-run case. - Fetch the listing in as few round trips as the API allows and say how many it costs. One call per pane is the slow shape this should avoid. - Keep it to one file I can read in a sitting. Anchor it in these pages: - https://libtmux.org/en/tmux/concepts/queries/ queries - https://libtmux.org/en/tmux/guides/querying-and-filtering/ querying and filtering - https://libtmux.org/en/tmux/guides/attaching-to-tmux/ attaching to tmux ``` ``` Then build a tmux session switcher. libtmux drives a real tmux server from code. It gives you objects for the server, its sessions, windows and panes. Documentation for every language is at https://libtmux.org/en/. Language: F# Package: LibTmux.FSharp (NuGet) Repository: https://github.com/libtmux/libtmux-dotnet Read these before writing code: - https://libtmux.org/en/fsharp/latest/llms.txt every page for F#, as a list - https://libtmux.org/en/fsharp/latest/docs.json the same list with headings, as JSON - https://libtmux.org/en/fsharp/latest/reference/ the F# API reference If you cannot fetch URLs, clone the repository above and read its README and examples instead, or ask me to paste those pages in. Set up first: 1. Report the tmux version with `tmux -V`. libtmux drives a real tmux, so nothing below works without one. Stop and tell me if it is missing. 2. If this directory is not a F# project yet, start one: dotnet new console --language F# Skip this in a project that already exists, and match what is here. 3. Add the dependency. LibTmux.FSharp has no stable release. 0.0.0-alpha.21 is the newest prerelease on NuGet, and the command below names it because the resolver skips prereleases otherwise. dotnet package add LibTmux.FSharp --version 0.0.0-alpha.21 Check https://www.nuget.org/packages/LibTmux.FSharp for a newer version, and prefer a stable release over this one if there now is any. 4. Write the smallest program that proves the install works: connect to a tmux server, create a session, confirm it is there, then kill it. Give that server a socket of its own rather than using the default one, so this never touches a tmux I am already running. Run it, and show me the output and the files you added. Rules for everything below: - Use the reference above rather than guessing names. The ten libtmux ports do not share spellings, and a name from another language will look plausible and not exist. - If the reference does not have something you expected, say so instead of writing a call that does not exist. - Follow the conventions already in this repository. Session switcher What it does: - Lists every session on the server with its windows, and shows what each window's active pane is running, so the list says something more useful than a set of names. - Filters as I type and attaches to, or switches the client to, what I pick. - Works both from outside tmux and from inside it. Those need different calls, and getting the inside case wrong is the usual bug here: attaching from within a session nests one client inside another. Constraints: - Read the live server every time. Do not cache a session list between runs. - Handle there being no server running at all, which is the first-run case. - Fetch the listing in as few round trips as the API allows and say how many it costs. One call per pane is the slow shape this should avoid. - Keep it to one file I can read in a sitting. Anchor it in these pages: - https://libtmux.org/en/tmux/concepts/queries/ queries - https://libtmux.org/en/tmux/guides/querying-and-filtering/ querying and filtering - https://libtmux.org/en/tmux/guides/attaching-to-tmux/ attaching to tmux ``` ``` Then build a tmux session switcher. libtmux drives a real tmux server from code. It gives you objects for the server, its sessions, windows and panes. Documentation for every language is at https://libtmux.org/en/. Language: C++ Package: libtmux-cxx (its repository) Repository: https://github.com/libtmux/libtmux-cxx Read these before writing code: - https://libtmux.org/en/cxx/latest/llms.txt every page for C++, as a list - https://libtmux.org/en/cxx/latest/docs.json the same list with headings, as JSON - https://libtmux.org/en/cxx/latest/reference/ the C++ API reference If you cannot fetch URLs, clone the repository above and read its README and examples instead, or ask me to paste those pages in. Set up first: 1. Report the tmux version with `tmux -V`. libtmux drives a real tmux, so nothing below works without one. Stop and tell me if it is missing. 2. If this directory is not a C++ project yet, write a CMakeLists.txt declaring cmake_minimum_required and project(), targeting C++23. Skip this in a project that already exists, and match what is here. 3. Add the dependency. libtmux-cxx is not published to its registry yet, so this installs from the repository at tag v0.1.0-alpha.11. include(FetchContent) FetchContent_Declare(libtmux-cxx GIT_REPOSITORY https://github.com/libtmux/libtmux-cxx GIT_TAG v0.1.0-alpha.11) FetchContent_MakeAvailable(libtmux-cxx) Check https://github.com/libtmux/libtmux-cxx for a newer version, and prefer a stable release over this one if there now is any. 4. Write the smallest program that proves the install works: connect to a tmux server, create a session, confirm it is there, then kill it. Give that server a socket of its own rather than using the default one, so this never touches a tmux I am already running. Run it, and show me the output and the files you added. Rules for everything below: - Use the reference above rather than guessing names. The ten libtmux ports do not share spellings, and a name from another language will look plausible and not exist. - If the reference does not have something you expected, say so instead of writing a call that does not exist. - Follow the conventions already in this repository. Session switcher What it does: - Lists every session on the server with its windows, and shows what each window's active pane is running, so the list says something more useful than a set of names. - Filters as I type and attaches to, or switches the client to, what I pick. - Works both from outside tmux and from inside it. Those need different calls, and getting the inside case wrong is the usual bug here: attaching from within a session nests one client inside another. Constraints: - Read the live server every time. Do not cache a session list between runs. - Handle there being no server running at all, which is the first-run case. - Fetch the listing in as few round trips as the API allows and say how many it costs. One call per pane is the slow shape this should avoid. - Keep it to one file I can read in a sitting. Anchor it in these pages: - https://libtmux.org/en/tmux/concepts/queries/ queries - https://libtmux.org/en/tmux/guides/querying-and-filtering/ querying and filtering - https://libtmux.org/en/tmux/guides/attaching-to-tmux/ attaching to tmux ``` ``` Then build a tmux session switcher. libtmux drives a real tmux server from code. It gives you objects for the server, its sessions, windows and panes. Documentation for every language is at https://libtmux.org/en/. Language: Swift Package: libtmux-swift (Swift Package Index) Repository: https://github.com/libtmux/libtmux-swift Read these before writing code: - https://libtmux.org/en/swift/latest/llms.txt every page for Swift, as a list - https://libtmux.org/en/swift/latest/docs.json the same list with headings, as JSON - https://libtmux.org/en/swift/latest/reference/ the Swift API reference If you cannot fetch URLs, clone the repository above and read its README and examples instead, or ask me to paste those pages in. Set up first: 1. Report the tmux version with `tmux -V`. libtmux drives a real tmux, so nothing below works without one. Stop and tell me if it is missing. 2. If this directory is not a Swift project yet, start one: swift package init --type executable Skip this in a project that already exists, and match what is here. 3. Add the dependency. libtmux-swift has no stable release. 0.1.0-alpha.6 is the newest prerelease on Swift Package Index, and the command below names it because the resolver skips prereleases otherwise. .package(url: "https://github.com/libtmux/libtmux-swift", exact: "0.1.0-alpha.6") Check https://swiftpackageindex.com/libtmux/libtmux-swift for a newer version, and prefer a stable release over this one if there now is any. A target depends on the product, not the package: write .product(name: "LibTmux", package: "libtmux-swift"). The library is `LibTmux` while the package identity SwiftPM derives from the URL is `libtmux-swift`, which is neither the product name nor the `name:` in the package manifest. 4. Write the smallest program that proves the install works: connect to a tmux server, create a session, confirm it is there, then kill it. Give that server a socket of its own rather than using the default one, so this never touches a tmux I am already running. Run it, and show me the output and the files you added. Rules for everything below: - Use the reference above rather than guessing names. The ten libtmux ports do not share spellings, and a name from another language will look plausible and not exist. - If the reference does not have something you expected, say so instead of writing a call that does not exist. - Follow the conventions already in this repository. Session switcher What it does: - Lists every session on the server with its windows, and shows what each window's active pane is running, so the list says something more useful than a set of names. - Filters as I type and attaches to, or switches the client to, what I pick. - Works both from outside tmux and from inside it. Those need different calls, and getting the inside case wrong is the usual bug here: attaching from within a session nests one client inside another. Constraints: - Read the live server every time. Do not cache a session list between runs. - Handle there being no server running at all, which is the first-run case. - Fetch the listing in as few round trips as the API allows and say how many it costs. One call per pane is the slow shape this should avoid. - Keep it to one file I can read in a sitting. Anchor it in these pages: - https://libtmux.org/en/tmux/concepts/queries/ queries - https://libtmux.org/en/tmux/guides/querying-and-filtering/ querying and filtering - https://libtmux.org/en/tmux/guides/attaching-to-tmux/ attaching to tmux ``` ## As plain text The same prompt per language, as a file rather than a page. * [Python](https://libtmux.org/en/prompts/py/session-switcher.txt) * [Ruby](https://libtmux.org/en/prompts/ruby/session-switcher.txt) * [Lua](https://libtmux.org/en/prompts/lua/session-switcher.txt) * [PowerShell](https://libtmux.org/en/prompts/powershell/session-switcher.txt) * [Julia](https://libtmux.org/en/prompts/julia/session-switcher.txt) * [TypeScript](https://libtmux.org/en/prompts/ts/session-switcher.txt) * [Rust](https://libtmux.org/en/prompts/rs/session-switcher.txt) * [Go](https://libtmux.org/en/prompts/go/session-switcher.txt) * [Java](https://libtmux.org/en/prompts/java/session-switcher.txt) * [Kotlin](https://libtmux.org/en/prompts/kotlin/session-switcher.txt) * [Scala](https://libtmux.org/en/prompts/scala/session-switcher.txt) * [C#](https://libtmux.org/en/prompts/csharp/session-switcher.txt) * [F#](https://libtmux.org/en/prompts/fsharp/session-switcher.txt) * [C++](https://libtmux.org/en/prompts/cxx/session-switcher.txt) * [Swift](https://libtmux.org/en/prompts/swift/session-switcher.txt) ## What it reads This prompt anchors the work in these pages, and tells the agent to use them rather than guess API names. * [concepts/queries](https://libtmux.org/en/tmux/concepts/queries/) * [guides/querying-and-filtering](https://libtmux.org/en/tmux/guides/querying-and-filtering/) * [guides/attaching-to-tmux](https://libtmux.org/en/tmux/guides/attaching-to-tmux/)