Ethica/Termix
1
0 Fork 0
mirror of https://github.com/Termix-SSH/Termix.git synced 2026-11-01 08:05:23 +00:00
Code Issues Packages Projects Releases Wiki Activity

release-2.9.0 (#1532)

Browse Source 
* fix(macos): skip single-instance lock in Mac App Store builds (#1454)

fix(macos): skip single-instance lock in Mac App Store builds

* Fix/backend optional sharp (#1455)

Fix/backend optional sharp

* feat: issue #1218 (#1218)

https://github.com/Termix-SSH/Support/issues/1218

* feat: Add option to use saved global custom theme under Connection Defaults (#1209)

https://github.com/Termix-SSH/Support/issues/1209

* feat: Add Fleet Sharing functionality to the UI (#1228)

https://github.com/Termix-SSH/Support/issues/1228

* feat: Add a list view to the Docker management page (#1237)

https://github.com/Termix-SSH/Support/issues/1237

* feat: issue #1264 (#1264)

https://github.com/Termix-SSH/Support/issues/1264

* feat: 2FA With FortiToken (#1288)

https://github.com/Termix-SSH/Support/issues/1288

* feat: Allow to disable showing paths to folders (#1274)

https://github.com/Termix-SSH/Support/issues/1274

* feat: Sync Network Graph between Desktop and Remote Server (#1245)

https://github.com/Termix-SSH/Support/issues/1245

* feat: Version Number on offline servers (#1291)

https://github.com/Termix-SSH/Support/issues/1291

* feat: Support OrbStack Docker socket path on macOS / Fix "Docker is not installed" on mac... (#1302)

https://github.com/Termix-SSH/Support/issues/1302

* feat: Sidebar host click should focus existing tab instead of opening a new connection (#1289)

https://github.com/Termix-SSH/Support/issues/1289

* fix: Search in side bar shows overlapping hosts when grouped by tags (#1303)

https://github.com/Termix-SSH/Support/issues/1303

* fix: I can't send a file on its own. (#1304)

https://github.com/Termix-SSH/Support/issues/1304

* fix: sudo password not autofilling (#1248)

https://github.com/Termix-SSH/Support/issues/1248

* fix: node-MainThread (#1300)

https://github.com/Termix-SSH/Support/issues/1300

* fix: Tunnel authentication with shared credentials (#1295)

https://github.com/Termix-SSH/Support/issues/1295

* fix: host key updates not syncing, metrics 404 race on first connect

Host key writes never bumped updatedAt so sync never picked them up.
Also retry the first metrics fetch briefly instead of failing right away.

* chore: increment ver

* feat: add category and icon fields to plugin manifest schema

* ci(deps): bump the github-actions group with 2 updates (#1458)

Bumps the github-actions group with 2 updates: [crowdin/github-action](https://github.com/crowdin/github-action) and [actions/github-script](https://github.com/actions/github-script).


Updates `crowdin/github-action` from 2 to 3
- [Release notes](https://github.com/crowdin/github-action/releases)
- [Commits](https://github.com/crowdin/github-action/compare/v2...v3)

Updates `actions/github-script` from 7 to 9
- [Release notes](https://github.com/actions/github-script/releases)
- [Commits](https://github.com/actions/github-script/compare/v7...v9)

---
updated-dependencies:
- dependency-name: crowdin/github-action
  dependency-version: '3'
  dependency-type: direct:production
  update-type: version-update:semver-major
  dependency-group: github-actions
- dependency-name: actions/github-script
  dependency-version: '9'
  dependency-type: direct:production
  update-type: version-update:semver-major
  dependency-group: github-actions
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

* chore(deps-dev): bump the dev-patch-updates group with 13 updates (#1459)

Bumps the dev-patch-updates group with 13 updates:

| Package | From | To |
| --- | --- | --- |
| [@codemirror/commands](https://github.com/codemirror/commands) | `6.11.0` | `6.11.1` |
| [@codemirror/search](https://github.com/codemirror/search) | `6.7.1` | `6.7.2` |
| [@codemirror/view](https://github.com/codemirror/view) | `6.43.9` | `6.43.12` |
| [@testing-library/dom](https://github.com/testing-library/dom-testing-library) | `10.4.1` | `10.4.2` |
| [@testing-library/react](https://github.com/testing-library/react-testing-library) | `16.3.2` | `16.3.3` |
| [@testing-library/user-event](https://github.com/testing-library/user-event) | `14.6.5` | `14.6.7` |
| [@types/ssh2](https://github.com/DefinitelyTyped/DefinitelyTyped/tree/HEAD/types/ssh2) | `1.15.5` | `1.15.6` |
| [@vitejs/plugin-react](https://github.com/vitejs/vite-plugin-react/tree/HEAD/packages/plugin-react) | `6.1.0` | `6.1.1` |
| [cytoscape](https://github.com/cytoscape/cytoscape.js) | `3.34.1` | `3.34.3` |
| [eslint-plugin-react-refresh](https://github.com/ArnaudBarre/eslint-plugin-react-refresh) | `0.5.4` | `0.5.7` |
| [i18next](https://github.com/i18next/i18next) | `26.4.0` | `26.4.2` |
| [prettier](https://github.com/prettier/prettier) | `3.9.6` | `3.9.8` |
| [react-i18next](https://github.com/i18next/react-i18next) | `17.0.12` | `17.0.14` |


Updates `@codemirror/commands` from 6.11.0 to 6.11.1
- [Changelog](https://github.com/codemirror/commands/blob/main/CHANGELOG.md)
- [Commits](https://github.com/codemirror/commands/commits)

Updates `@codemirror/search` from 6.7.1 to 6.7.2
- [Changelog](https://github.com/codemirror/search/blob/main/CHANGELOG.md)
- [Commits](https://github.com/codemirror/search/commits)

Updates `@codemirror/view` from 6.43.9 to 6.43.12
- [Changelog](https://github.com/codemirror/view/blob/main/CHANGELOG.md)
- [Commits](https://github.com/codemirror/view/commits)

Updates `@testing-library/dom` from 10.4.1 to 10.4.2
- [Release notes](https://github.com/testing-library/dom-testing-library/releases)
- [Changelog](https://github.com/testing-library/dom-testing-library/blob/main/CHANGELOG.md)
- [Commits](https://github.com/testing-library/dom-testing-library/compare/v10.4.1...v10.4.2)

Updates `@testing-library/react` from 16.3.2 to 16.3.3
- [Release notes](https://github.com/testing-library/react-testing-library/releases)
- [Changelog](https://github.com/testing-library/react-testing-library/blob/main/CHANGELOG.md)
- [Commits](https://github.com/testing-library/react-testing-library/compare/v16.3.2...v16.3.3)

Updates `@testing-library/user-event` from 14.6.5 to 14.6.7
- [Release notes](https://github.com/testing-library/user-event/releases)
- [Changelog](https://github.com/testing-library/user-event/blob/main/CHANGELOG.md)
- [Commits](https://github.com/testing-library/user-event/compare/v14.6.5...v14.6.7)

Updates `@types/ssh2` from 1.15.5 to 1.15.6
- [Release notes](https://github.com/DefinitelyTyped/DefinitelyTyped/releases)
- [Commits](https://github.com/DefinitelyTyped/DefinitelyTyped/commits/HEAD/types/ssh2)

Updates `@vitejs/plugin-react` from 6.1.0 to 6.1.1
- [Release notes](https://github.com/vitejs/vite-plugin-react/releases)
- [Changelog](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react/CHANGELOG.md)
- [Commits](https://github.com/vitejs/vite-plugin-react/commits/plugin-react@6.1.1/packages/plugin-react)

Updates `cytoscape` from 3.34.1 to 3.34.3
- [Release notes](https://github.com/cytoscape/cytoscape.js/releases)
- [Commits](https://github.com/cytoscape/cytoscape.js/compare/v3.34.1...v3.34.3)

Updates `eslint-plugin-react-refresh` from 0.5.4 to 0.5.7
- [Release notes](https://github.com/ArnaudBarre/eslint-plugin-react-refresh/releases)
- [Changelog](https://github.com/ArnaudBarre/eslint-plugin-react-refresh/blob/main/CHANGELOG.md)
- [Commits](https://github.com/ArnaudBarre/eslint-plugin-react-refresh/compare/v0.5.4...v0.5.7)

Updates `i18next` from 26.4.0 to 26.4.2
- [Release notes](https://github.com/i18next/i18next/releases)
- [Changelog](https://github.com/i18next/i18next/blob/master/CHANGELOG.md)
- [Commits](https://github.com/i18next/i18next/compare/v26.4.0...v26.4.2)

Updates `prettier` from 3.9.6 to 3.9.8
- [Release notes](https://github.com/prettier/prettier/releases)
- [Changelog](https://github.com/prettier/prettier/blob/main/CHANGELOG.md)
- [Commits](https://github.com/prettier/prettier/compare/3.9.6...3.9.8)

Updates `react-i18next` from 17.0.12 to 17.0.14
- [Changelog](https://github.com/i18next/react-i18next/blob/master/CHANGELOG.md)
- [Commits](https://github.com/i18next/react-i18next/compare/v17.0.12...v17.0.14)

---
updated-dependencies:
- dependency-name: "@codemirror/commands"
  dependency-version: 6.11.1
  dependency-type: direct:development
  update-type: version-update:semver-patch
  dependency-group: dev-patch-updates
- dependency-name: "@codemirror/search"
  dependency-version: 6.7.2
  dependency-type: direct:development
  update-type: version-update:semver-patch
  dependency-group: dev-patch-updates
- dependency-name: "@codemirror/view"
  dependency-version: 6.43.12
  dependency-type: direct:development
  update-type: version-update:semver-patch
  dependency-group: dev-patch-updates
- dependency-name: "@testing-library/dom"
  dependency-version: 10.4.2
  dependency-type: direct:development
  update-type: version-update:semver-patch
  dependency-group: dev-patch-updates
- dependency-name: "@testing-library/react"
  dependency-version: 16.3.3
  dependency-type: direct:development
  update-type: version-update:semver-patch
  dependency-group: dev-patch-updates
- dependency-name: "@testing-library/user-event"
  dependency-version: 14.6.7
  dependency-type: direct:development
  update-type: version-update:semver-patch
  dependency-group: dev-patch-updates
- dependency-name: "@types/ssh2"
  dependency-version: 1.15.6
  dependency-type: direct:development
  update-type: version-update:semver-patch
  dependency-group: dev-patch-updates
- dependency-name: "@vitejs/plugin-react"
  dependency-version: 6.1.1
  dependency-type: direct:development
  update-type: version-update:semver-patch
  dependency-group: dev-patch-updates
- dependency-name: cytoscape
  dependency-version: 3.34.3
  dependency-type: direct:development
  update-type: version-update:semver-patch
  dependency-group: dev-patch-updates
- dependency-name: eslint-plugin-react-refresh
  dependency-version: 0.5.7
  dependency-type: direct:development
  update-type: version-update:semver-patch
  dependency-group: dev-patch-updates
- dependency-name: i18next
  dependency-version: 26.4.2
  dependency-type: direct:development
  update-type: version-update:semver-patch
  dependency-group: dev-patch-updates
- dependency-name: prettier
  dependency-version: 3.9.8
  dependency-type: direct:development
  update-type: version-update:semver-patch
  dependency-group: dev-patch-updates
- dependency-name: react-i18next
  dependency-version: 17.0.14
  dependency-type: direct:development
  update-type: version-update:semver-patch
  dependency-group: dev-patch-updates
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

* chore(deps): bump the prod-patch-updates group with 6 updates (#1461)

Bumps the prod-patch-updates group with 6 updates:

| Package | From | To |
| --- | --- | --- |
| [@tanstack/react-virtual](https://github.com/TanStack/virtual/tree/HEAD/packages/react-virtual) | `3.14.10` | `3.14.13` |
| [compression](https://github.com/expressjs/compression) | `1.8.1` | `1.8.2` |
| [jose](https://github.com/panva/jose) | `6.2.9` | `6.2.12` |
| [jszip](https://github.com/Stuk/jszip) | `3.10.1` | `3.10.2` |
| [socks](https://github.com/JoshGlazebrook/socks) | `2.8.9` | `2.8.10` |
| [undici](https://github.com/nodejs/undici) | `8.10.0` | `8.10.2` |


Updates `@tanstack/react-virtual` from 3.14.10 to 3.14.13
- [Release notes](https://github.com/TanStack/virtual/releases)
- [Changelog](https://github.com/TanStack/virtual/blob/main/packages/react-virtual/CHANGELOG.md)
- [Commits](https://github.com/TanStack/virtual/commits/@tanstack/react-virtual@3.14.13/packages/react-virtual)

Updates `compression` from 1.8.1 to 1.8.2
- [Release notes](https://github.com/expressjs/compression/releases)
- [Changelog](https://github.com/expressjs/compression/blob/master/HISTORY.md)
- [Commits](https://github.com/expressjs/compression/compare/v1.8.1...v1.8.2)

Updates `jose` from 6.2.9 to 6.2.12
- [Release notes](https://github.com/panva/jose/releases)
- [Changelog](https://github.com/panva/jose/blob/main/CHANGELOG.md)
- [Commits](https://github.com/panva/jose/compare/v6.2.9...v6.2.12)

Updates `jszip` from 3.10.1 to 3.10.2
- [Changelog](https://github.com/Stuk/jszip/blob/main/CHANGES.md)
- [Commits](https://github.com/Stuk/jszip/compare/v3.10.1...v3.10.2)

Updates `socks` from 2.8.9 to 2.8.10
- [Release notes](https://github.com/JoshGlazebrook/socks/releases)
- [Commits](https://github.com/JoshGlazebrook/socks/compare/2.8.9...2.8.10)

Updates `undici` from 8.10.0 to 8.10.2
- [Release notes](https://github.com/nodejs/undici/releases)
- [Commits](https://github.com/nodejs/undici/compare/v8.10.0...v8.10.2)

---
updated-dependencies:
- dependency-name: "@tanstack/react-virtual"
  dependency-version: 3.14.13
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: prod-patch-updates
- dependency-name: compression
  dependency-version: 1.8.2
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: prod-patch-updates
- dependency-name: jose
  dependency-version: 6.2.12
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: prod-patch-updates
- dependency-name: jszip
  dependency-version: 3.10.2
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: prod-patch-updates
- dependency-name: socks
  dependency-version: 2.8.10
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: prod-patch-updates
- dependency-name: undici
  dependency-version: 8.10.2
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: prod-patch-updates
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

* feat: add plugin worker protocol, bootstrap and plugin_storage table

Worker-side ctx proxy plus the message envelope it talks over, and the
per-plugin key/value table behind ctx.storage with migrations for all
three dialects. Rows cascade with the plugin so uninstalling leaves
nothing behind.

* feat: add allowlisted host view for plugins

An allowlist rather than a list of fields to strip. A blocklist rots:
the moment a new secret-bearing column lands on SSHHost it starts
leaking silently. With an allowlist a new field stays invisible to
plugins until someone adds it here on purpose.

* feat: add plugin loader with manifest validation and crash restart

Validates an unpacked plugin, spawns a worker_threads worker and manages
activate/deactivate/crash-restart with backoff, disabling after three
tries.

The crash counter clears only after a plugin stays up past a stability
window, not on activation. Clearing it on activation let a plugin that
activates cleanly and then dies restart forever, because every attempt
looked like the first.

loader.ts documents what the worker boundary does and does not buy you.
Node's permission model is process-wide, not per-worker, so it cannot be
enabled for plugin workers alone and is not claimed here.

* feat: route internal events through a shared plugin event bus

Formalises three ad-hoc publish paths that already existed:
automation-events.ts, metrics/automation-bridge.ts and the
hostSessionStatus singleton, now the host.session.status topic.

Both invariants the old code relied on are preserved. Publishing stays
fire-and-forget, so a failing subscriber cannot disturb a metrics poll or
a host delete. The automations engine subscribes to the bus at scheduler
start instead of being imported ad hoc, which keeps the edge
one-directional: automations may import repositories, hosts modules must
not import automations.

* feat: add plugin ctx broker with permission gate and audit

Every ctx call a plugin makes is checked against its granted
capabilities, performed by the main thread, then audited. A capability
must be both declared in the manifest and granted in the database, so
widening a plugin's reach always needs a new manifest the user can see,
never just a database row.

Audit attribution is set by the broker, not the plugin. The plugin
supplies only the details, so it cannot forge the actor.

fix: stop plugin workers seeing plaintext credentials in error messages

A failing ctx.ssh.connect handed the worker the raw error from deep in
the SSH stack, which embeds the connect config. The worker received, in
full:

  Authentication failed for root using password <SECRET>

where <SECRET> was the host's real plaintext password. Any plugin with
ssh.exec could read it by catching the error, defeating the whole point
of the handle-based ssh API.

Errors crossing the boundary are now sanitised. Only PluginFacingError
and PluginPermissionError, both authored here, reach a plugin verbatim;
anything else becomes a generic message and the real one goes to the
log. This uses a marker class rather than matching on message text,
because matching would start leaking again the moment an upstream error
happened to contain a familiar phrase.

Covered by credential-isolation.test.ts, which plants a sentinel in
every secret-bearing field and asserts it appears in no message the
worker ever receives.

* feat: dispatch plugin HTTP routes and wire the runtime into startup

ctx.http.route now registers a real router on the /plugin-api/:pluginId
dispatcher, replacing its stub 404. A plugin never touches the Express
req/res: it gets a plain summary and returns a plain object, so sockets
and session cookies stay on this side of the boundary. Authorization and
cookie headers are not forwarded.

Plugins load last in the start-up sequence, after the server is fully
wired, and are terminated before the database on shutdown so none can
outlive it. A plugin that fails to load cannot stop the backend.

fix: correct the nginx plugin-api location regex

The pattern was ^/plugin-api/(/.*)?$, which needs a double slash and so
never matched /plugin-api/<id>/<route>. Every other block in the file
uses ^/prefix(/.*)?$. Left alone, plugin routes would work in dev and
404 only behind Docker.

* fix: update stale SFTP transfer test for single file destination paths

The test still asserted transferToHost was called with the destination
directory "/srv". Commit 7727fa09 (#1304) deliberately changed a single
file transfer to send the full destination path including the filename,
so the correct expectation is "/srv/remote-1.txt". The code was right
and the test was left behind.

* feat: ship the ssh terminal as a first-party in-process plugin

Adds a hardcoded process:transport-owner tier so the terminal can own its
WebSocket server and ssh2 clients, which cannot cross the worker boundary.

* feat: ship docker as a first-party in-process plugin

Moves docker backend and frontend into plugins/docker/, alongside
ssh-terminal. Adds a host editor tab seam, a dashboard card registry,
and a build step to compile plugin backends into dist.

* feat: ship host metrics as a first-party in-process plugin

* fix: harden plugin auth and add per-request identity for ctx calls

Require auth on /plugin-api, gate plugin enable/grant/revoke routes
behind admin.plugins.manage, and thread the calling user through
worker ctx.hosts/ctx.ssh calls instead of always using the install
owner. Also adds the plugin permissions grant/revoke UI.

* feat: ship the AI assistant as a first-party in-process plugin

Moves src/backend/ai and its routes into plugins/ai, mounted through a
small /ai dispatcher instead of its own port. Moves the ai-enabled and
ai-private-endpoints settings routes out of user-settings-routes.ts
into the plugin too, so it has no leftover core dependents.

* fix: remove compiled plugin JS left behind in plugins/ after build

copy-bundled-plugins.cjs compiled and rewrote plugin backend TS in
place, copied it to dist/plugins, but never deleted the .js it had
just emitted next to the .ts sources. Those files shadowed the real
source for vitest/tsx and had import paths rewritten for the dist
layout, so tests failed with "Cannot find module" once a local build
had run. Affects docker, host-metrics and ai, not just this one.

* feat: add a permission-gated backend service registry for plugins

* feat: add a permission-gated UI action registry and action slots for plugins

Moves the terminal toolbar's hardwired AI button into a slot the ssh-terminal
plugin offers and the ai plugin fills, gated on ai.services.use.

* feat: add cross-plugin secret references gated by the provider's RBAC permission

* feat: move proxmox discovery/import/sync into a first-party plugin

* feat: move remote desktop (RDP/VNC/Telnet) into a first-party plugin

Relocates guacamole backend/frontend source and tests into
plugins/remote-desktop, following the ssh-terminal/docker pattern.

* feat: wire remote-desktop plugin into core and rename i18n keys

Repoints core consumers (dispatcher, collab, session-sharing, tab
utils) at the plugin, adds isTabTypeAvailable gating for rdp/vnc/
telnet, widens hostCapability to accept an array, and renames the
guacamole i18n namespace to remoteDesktop.

* feat: move fleets into a first-party plugin

* feat: move automations into a first-party plugin

* feat: remove legacy alert rules, superseded by automations

Alert rules already auto-migrate into automations on boot and the old
engine stands down after. Deletes the rule/firing tables, routes, UI,
and AI tools; keeps notification channels since automations still use
them. Also fixes automations' notify step, which still called the
deleted repository.

* feat: move network topology into a first-party plugin

* feat: move tailscale device discovery and settings into a plugin

Adds plugins/tailscale/ with a devices sidebar tab, admin settings
section, and re-auth dialog. Host Metrics tailscale manager card and
SSH re-auth banner parsing stay in core.

* feat: move workspaces into a first-party plugin

* feat: move web endpoint into a first-party plugin

* feat: collapse plugin runtime to one tier behind a plugin SDK

* feat: make each plugin an npm workspace built by a termix-plugin CLI

* feat: give plugins their own tables, migrations and sync entities

* feat: serve plugin http and websockets from one mount instead of ports

* feat: namespace plugin permissions and keep them valid when a plugin is off

* feat: give plugins their own settings and one settings screen

* feat: load plugin frontends at runtime and remove plugin ids from the shell

* fix: mock the ai status fetch in its activate test

* feat: add auth extension points and one ssh connect pipeline

* feat: rebuild workspaces as the reference plugin

* fix: gate second factors after SSO/LDAP behind an admin setting

* feat: convert network-topology to a full plugin (B1)

* feat: move snippets backend and tables into a plugin (B2)

* feat: point core frontend snippets pickers at the plugin (B2)

* feat: add the snippets plugin (B2)

* feat: wire ai, automations, fleets and ssh-terminal to snippets (B2)

* feat: finish the tailscale plugin, including SSH auth (B3)

* feat: finish the fleets plugin, add ctx.hosts and host-commands SDK (B4)

* chore: update proxmox and host-metrics locale files for B5

* chore: regenerate drizzle migration journals for B5

* feat: add ctx.hosts create/update to the SDK, host-metrics drops proxmox

* feat: move proxmox node stats and collectors into the proxmox plugin

* feat: drop proxmox host columns, use plugin settings instead

* feat: finish the fleets plugin, add ctx.hosts and host-commands SDK (B4)

* feat: convert file manager into a plugin

* feat: convert ssh tunnels into a plugin

* feat: finish the web-endpoint plugin, add ctx.desktop (B8)

* feat: move the terminal fully into the ssh-terminal plugin (B9)

* feat: convert tmux monitoring into a plugin (B10)

* feat: convert serial console into the serial plugin

* feat: move session sharing and collab rooms into a plugin (B12)

* feat: turn session recording into a plugin (B13)

* feat: finish the remote-desktop plugin (B14)

* feat: finish the host-metrics plugin, move host status into core (B16)

* feat: finish the docker plugin (B15)

* feat: finish the automations plugin (B17)

* feat: finish the ai plugin (B18)

* feat: finish the homepage plugin, move service links and canvas out of core (B19)

* feat: convert wake-on-lan into a plugin (B20)

* feat: convert secret-sources into a plugin (B20)

* feat: move totp and passkeys into plugins (C1)

* feat: move sso and ldap logins into plugins (C2)

* feat: move opkssh and warpgate into plugins (C3)

* feat: move step-ca into a plugin (C4)

* feat: move vault ssh signing into a plugin (C5)

* feat: move termix identity into a plugin (C6)

* feat: move acme certificate automation into a plugin (C7)

* fix: finish 2.9.0 plugin moves and get every check green

* chore: lock the plugin boundary and remove 2.9.0 leftovers

* fix: harden the plugin runtime after the 2.9.0 security review

* feat: add plugin packing, signing, pinned trust and tmxplug bundling

* test: prove 2.8 to 2.9.0 upgrade is lossless and fix what it caught

* fix: give bundled plugin backends a real require for CJS deps

* feat: improve UI loading time and jitter

* feat: show credential sharing inline in the sidebar like host sharing

* feat: tailscale add host and copy ip, fix outbound fetch hang and plugin ESM warning

* feat: unify alerts into one plugin, channels, rules and inbox

* feat: rebuild desktop sync as linked server accounts, fix packaged plugin bundles and UI scaling

* fix: set blacksmith builder cache-key to stop broken gha cache fallback

* fix: link plugin-sdk workspace before npm ci in docker deps stage

* fix: link every plugin workspace before npm ci in docker deps stage

* fix(host-metrics): exclude image and firmware filesystems (#1469)

* fix(host-metrics): exclude image and firmware filesystems

* fix(ci): build plugin SDK before dependent checks

* fix(mysql): keep plugin settings scope indexes within limits

* test(mysql): refresh reviewed plugin upgrade SQL

* fix(hosts): normalize imported jump host references (#1470)

* fix(hosts): normalize imported jump host references

* fix(ci): build plugin SDK before dependent checks

* fix(mysql): keep plugin settings scope indexes within limits

* test(mysql): refresh reviewed plugin upgrade SQL

* fix(ci): build plugin SDK and repair MySQL settings migration (#1471)

* fix(ci): build plugin SDK before dependent checks

* fix(mysql): keep plugin settings scope indexes within limits

* test(mysql): refresh reviewed plugin upgrade SQL

* fix(file-manager): keep inline rename consistent (#1476)

* fix(ci): build plugin SDK before dependent checks

* fix(mysql): keep plugin settings scope indexes within limits

* test(mysql): refresh reviewed plugin upgrade SQL

* fix(file-manager): keep inline rename consistent

* fix(dashboard): reuse translated host status labels (#1475)

* fix(ci): build plugin SDK before dependent checks

* fix(mysql): keep plugin settings scope indexes within limits

* test(mysql): refresh reviewed plugin upgrade SQL

* fix(dashboard): reuse translated host status labels

* docs(api): clarify local and remote version fields (#1474)

* fix(ci): build plugin SDK before dependent checks

* fix(mysql): keep plugin settings scope indexes within limits

* test(mysql): refresh reviewed plugin upgrade SQL

* docs(api): clarify local and remote version fields

* fix(file-manager): preserve selected backgrounds on hover (#1473)

* fix(ci): build plugin SDK before dependent checks

* fix(mysql): keep plugin settings scope indexes within limits

* test(mysql): refresh reviewed plugin upgrade SQL

* fix(file-manager): preserve selection feedback on hover

* test(ui): await dialog focus cleanup before teardown

* fix(file-manager): restore Ctrl/Cmd+F file search (#1472)

* fix(ci): build plugin SDK before dependent checks

* fix(mysql): keep plugin settings scope indexes within limits

* test(mysql): refresh reviewed plugin upgrade SQL

* fix(file-manager): focus file search with Ctrl or Cmd F

* fix: keep rounded-full circular in production builds

* fix(file-manager): cancel uploads and stop remote writes (#1477)

* fix(file-manager): cancel uploads and stop remote writes

* test(css): exercise the configured PostCSS plugin chain

* fix(file-manager): apply compact density to directory tree (#1478)

* fix(file-manager): apply compact density to directory tree

* test(css): exercise the configured PostCSS plugin chain

* fix(file-manager): preserve font sizes in compact mode (#1480)

* fix(file-manager): preserve font sizes in compact mode

* test(css): exercise the configured PostCSS plugin chain

* fix(file-manager): prioritize file names in narrow lists (#1483)

* fix(file-manager): prioritize file names in narrow lists

* test(css): exercise the configured PostCSS plugin chain

* test(identity): preserve full Ed25519 public keys in fixtures

* test(remote-desktop): always mutate ciphertext in tamper test

* fix(remote-desktop): probe the saved host guacd endpoint (#1481)

* fix(remote-desktop): probe the saved host guacd endpoint

* test(css): exercise the configured PostCSS plugin chain

* test(identity): preserve full Ed25519 public keys in fixtures

* fix(homepage): check allowlisted private service reachability (#1479)

* fix(homepage): check allowlisted private service reachability

* test(css): exercise the configured PostCSS plugin chain

* fix(remote-desktop): stop unsolicited clipboard read prompts (#1482)

* fix(remote-desktop): read clipboard only on explicit paste

* test(css): exercise the configured PostCSS plugin chain

* test(identity): preserve full Ed25519 public keys in fixtures

* test(remote-desktop): always mutate ciphertext in tamper test

* chore: simplify plugin readmes, changelogs and manifest descriptions

* fix: keep plugins loaded after signing in from the login screen

* fix(file-manager): accept OS file drops over existing rows (#1484)

* fix(file-manager): accept OS file drops over existing rows

* test(file-manager): target the file label in drop tests

* test(css): exercise the configured PostCSS plugin chain

* test(identity): preserve full Ed25519 public keys in fixtures

* test(remote-desktop): always mutate ciphertext in tamper test

* fix(file-manager): pipeline SFTP download reads (#1485)

* feat: add plugin sdk build to beta release

* fix: make link-store secret check immune to random base64 matches

* fix(ldap): preserve the directory-provided bind DN (#1486)

* fix: compute beta changes across dev branches and move the beta tag

* chore: untrack plugin sdk ARCHITECTURE.md

* chore: remove references to plugin sdk ARCHITECTURE.md

* feat: merge host editor terminal tabs into one owned by ssh-terminal

* feat: add descriptions to plugin host enable toggles

* fix(file-manager): show download progress in file viewers (#1487)

* fix(electron): signal backend readiness over IPC (#1488)

* fix(split-screen): allow layout creation without randomUUID (#1490)

* fix(split-screen): allow layout creation without randomUUID

* test(credentials): avoid flaky Ed25519 key generation

* fix(sidebar): remeasure visible rows after density changes (#1489)

* fix(sidebar): remeasure visible rows after density changes

* test(credentials): avoid flaky Ed25519 key generation

* feat(split-screen): redesign split screen with free-form panes and pane picker

* feat(sidebar): add host click behavior setting, default to always opening a new tab

* feat(snippets): redesign panel to match the host list

* fix(session-recording): stop session logs panel from refetching in a loop

* feat(snippets): bring back sharing, target hosts and drag reorder

* feat(ssh-terminal): add toolbar position, start state, display and fade host settings

* feat(ssh-terminal): add host setting to turn off password prompt auto-fill

* fix(ai): stop streams getting cut off and keep tool steps across messages

* feat: improve quick connect system using plugin api

* fix: proxmox guest sync, startup snippet sync, drop dead cloudflare ssh transport

* feat: move terminal settings, look and ssh tools into ssh-terminal plugin

* feat: move snippets, keybinding actions and macros out of core into plugins

* feat: store rdp, vnc and telnet logins in a generic per-protocol table

* feat: type the plugin host record, move plugin strings out of core and add lint checks

* feat: replace core homepage widget registry with generic extension points

* feat: plugins only see their own host settings in the browser

* feat: harden plugin api for separate repos, signed updates and generic external login

* fix: keep plugin css below core utilities and version plugin assets by their css

* fix: load and save plugin host settings in the editor and tighten settings row spacing

* feat: redesign user host defaults system

* fix(remote-desktop): release held keys on focus loss (#1498)

* fix(session-sharing): replace local presentation after takeover (#1500)

* fix(file-manager): refresh disk usage with directory listing (#1503)

* fix(ssh-terminal): preserve input order during local echo reconciliation (#1505)

* feat(remote-desktop): expose display zoom controls for RDP (#1514)

* fix(file-manager): restore text selection and copying in Markdown previews (#1518)

* fix(sidebar): keep compact host addresses visible (#1524)

* fix(hosts): preserve plugin settings when reopening the editor (#1499)

* fix(ssh-terminal): close owner sockets when presentations unmount (#1501)

* fix(session-sharing): synchronize shared SSH terminal dimensions (#1502)

* fix(session-sharing): show participant presence in member terminals (#1504)

* fix(ai): sync provider configuration and keys across linked devices (#1506)

* feat(ssh-terminal): add a duplicate tab action (#1510)

* feat(file-manager): allow disabling move-to-trash confirmation (#1511)

* feat(file-manager): default to the remote login directory (#1512)

* feat(homepage): synchronize canvas layouts across devices (#1515)

* fix(shortcuts): prevent accidental double-Shift palette activation (#1519)

* feat(tmux-monitor): add a unified multi-host view (#1520)

* fix(electron): allow explicit quit with active connections (#1522)

* feat: reconnect all disconnected terminal tabs (#1523)

* fix(hosts): preserve recording and sharing settings in the dev editor (#1509)

* fix(database): preserve RDP domain during startup backfill (#1497)

* feat(sidebar): add keyboard type-ahead search for hosts (#1516)

* feat(automations): add per-host maintenance mode and recurring schedules (#1521)

* feat(tmux): add a per-host mouse toggle and preserve remote configuration (#1513)

* fix(session-sharing): use the linked server for desktop meetings and links (#1507)

* fix(tunnels): support TOTP for client tunnels and jump hosts (#1508)

* fix: type errors and lint failures from merged plugin prs

* feat(installer): make the Windows desktop shortcut optional (#1517)

* fix: ship the plugin sdk and serialport in desktop builds

* fix: prefer ipv4 when resolving ssh host names (#1365)

* fix: readable terminal selection with the light theme (#1319)

* fix: build desktop session share links on the linked server (#1350)

* fix: show meeting guests to members and hide the roster from guests (#1353)

* fix: reliable file manager saves with sudo prompt and no base64 guessing (#1335)

* fix: show disk usage for the mount being browsed (#1347)

* fix: load the linux tray icon reliably and log tray failures (#1332)

* fix: cover the gnome close path in the desktop quit test (#1332)

* fix: prompt for jump host TOTP in terminal, file manager and metrics (#1312)

* feat: optional auto reconnect for dropped ssh sessions (#1321)

* feat: tighter compact host rows with inline tags (#1325)

* feat: bring back the alert feed homepage widget

* feat: pick target terminals for snippets again

* feat: share button on connection tabs again

* feat: recent servers list when linking the desktop app

* feat: list the fixed app shortcuts in keyboard shortcuts

* fix: translate hardcoded toasts and drop em dashes from ui text

* fix: translate leftover hardcoded ui text

* fix: toolbar files button opens at the shell directory again

* fix: show the remote desktop note under connection origin again

* chore: openapi docs for host metrics manager routes

* chore: openapi docs for undocumented routes and fix two broken doc blocks

* fix: declare terminal.listSessions use for snippet targets

* revert: drop the alert feed widget, the notification center replaces it

* feat: restore the alert feed homepage widget

* fix: quick connect fills the host address from plugin auth editors like tailscale

* fix: docker container logs use the base background color

* chore: fix dependabot alerts and apply safe npm upgrades

* fix: proxmox stats tab reads its switch from plugin host settings

* fix: count plugin ssh logins toward host status and stop showing reachable as a warning

* fix: hide the built-in source pill in the host editor

* fix: host status shows online when the port answers and only warns on a failed login

* fix: drop the top border on the split layout menu

* fix: host defaults tabs sit where the host editor puts them and skip plugins with nothing to default

* fix: remote desktop auth method labels and notes for vnc and telnet

* fix: add description to the web endpoint enable switch

* fix: crowdin sync and pretranslate for plugin locales, run plugin tests on release

* feat: move telemetry out of core into a usage statistics plugin

* fix: recent activity card no longer cuts off host names early

* fix: remove duplicate top border on split screen menu

* fix: redesign session log player controls, fix tooltip overlap and drop dot separators

* fix: file manager and sftp text showing raw i18n keys

* fix: onboarding rerunning for existing users after upgrading

* fix: fleet detail buttons overflowing the sidebar

* fix: session log player scrolling off screen horizontally

* fix: network graph lag when adding hosts and on every render

* fix: maintenance index name, shared host read only view and badge polling

* fix: meeting tabs, workspace tab merging, rail panels as tabs and general ui lag

* chore: update release notes

* fix: remote desktop tabs reconnecting on every tab switch

* fix: build plugin sdk before linting in release workflow

* chore: lint, format, and bump version to 2.9.0

* chore: skip crowdin pre-translate in release for now

* chore: sync Crowdin translations for 2.9.0

---------

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: Koi <38512047+datlt4@users.noreply.github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: ZacharyZcR <zacharyzcr1984@gmail.com>
This commit is contained in:
Luke GustafsonKoidependabot[bot]ZacharyZcR
 authored and GitHub committed 2026-10-01 16:20:16 -05:00
1 parent 49fa488093
commit 3643e7af97
4405 files changed
+1341026 -289722
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

plugins/tmux-monitor/src/backend/index.ts
+23
View File
@@ -0,0 +1,23 @@
import type { Router } from "express";
import type { PluginContext } from "@termix/plugin-sdk/backend";
import { sessionTags } from "./tables.js";
import { createSessionTagRepository } from "./repository.js";
import { createTmuxMonitorRoutes } from "./routes.js";
import { createTmuxSessionsService } from "./service.js";
export type { TmuxDetection, TmuxSessionsV1 } from "./service.js";
export async function activate(ctx: PluginContext) {
const table = await ctx.db.define(sessionTags);
const tags = createSessionTagRepository(ctx.db, table);
ctx.http.router<Router>().use(createTmuxMonitorRoutes(ctx, tags));
ctx.services.provide("tmux.sessions", createTmuxSessionsService(ctx));
ctx.log.info("Tmux Monitor routes mounted at /plugin-api/tmux-monitor");
}
export async function deactivate() {
// Everything above was registered through ctx and is disposed by core.
}
plugins/tmux-monitor/src/backend/monitor-helpers.ts
+250
View File
@@ -0,0 +1,250 @@
// Pure parsing/aggregation helpers for the tmux monitor module.
// Kept free of SSH/Express dependencies so they can be unit-tested.
// Field separator used in tmux -F format strings. Session names, pane titles
// and paths may contain "|", and tmux sanitizes control characters (and, under
// non-UTF-8 locales, multibyte characters) in format output to "_", so a
// printable ASCII token is the only separator that survives everywhere.
export const SEP = "<<TMX>>";
export interface TmuxPane {
id: string;
index: number;
pid: number;
active: boolean;
width: number;
height: number;
command: string;
path: string;
title: string;
}
export interface TmuxWindow {
index: number;
name: string;
active: boolean;
panes: TmuxPane[];
}
export interface TmuxSessionSummary {
name: string;
created: number;
lastActivity: number;
attachedClients: number;
}
export interface RawPane extends TmuxPane {
sessionName: string;
windowIndex: number;
}
export interface ProcessInfo {
pid: number;
ppid: number;
cpu: number;
mem: number;
rss: number;
comm: string;
}
export interface PaneMetrics {
paneId: string;
sessionName: string;
pid: number;
processCount: number;
cpuPercent: number;
memRssKb: number;
gpuMemMb: number;
topCommand: string | null;
}
export function parseSessions(output: string): TmuxSessionSummary[] {
return output
.split("\n")
.filter(Boolean)
.map((line) => {
const [name, created, activity, attached] = line.split(SEP);
return {
name,
created: parseInt(created, 10) || 0,
lastActivity: parseInt(activity, 10) || 0,
attachedClients: parseInt(attached, 10) || 0,
};
});
}
export function parseWindows(output: string): Map<string, TmuxWindow[]> {
const bySession = new Map<string, TmuxWindow[]>();
for (const line of output.split("\n").filter(Boolean)) {
const [session, index, active, name] = line.split(SEP);
if (!bySession.has(session)) bySession.set(session, []);
bySession.get(session)!.push({
index: parseInt(index, 10) || 0,
name: name || "",
active: active === "1",
panes: [],
});
}
return bySession;
}
export function parsePanes(output: string): RawPane[] {
return output
.split("\n")
.filter(Boolean)
.map((line) => {
const [
sessionName,
windowIndex,
id,
index,
pid,
active,
width,
height,
command,
path,
title,
] = line.split(SEP);
return {
sessionName,
windowIndex: parseInt(windowIndex, 10) || 0,
id,
index: parseInt(index, 10) || 0,
pid: parseInt(pid, 10) || 0,
active: active === "1",
width: parseInt(width, 10) || 0,
height: parseInt(height, 10) || 0,
command: command || "",
path: path || "",
title: title || "",
};
});
}
export function parsePsOutput(output: string): ProcessInfo[] {
const processes: ProcessInfo[] = [];
for (const line of output.split("\n")) {
const parts = line.trim().split(/\s+/);
if (parts.length < 6) continue;
const pid = parseInt(parts[0], 10);
const ppid = parseInt(parts[1], 10);
if (isNaN(pid) || isNaN(ppid)) continue;
processes.push({
pid,
ppid,
cpu: parseFloat(parts[2]) || 0,
mem: parseFloat(parts[3]) || 0,
rss: parseInt(parts[4], 10) || 0,
comm: parts.slice(5).join(" "),
});
}
return processes;
}
export function parseGpuOutput(output: string): Map<number, number> {
const gpuByPid = new Map<number, number>();
for (const line of output.split("\n").filter(Boolean)) {
const [pid, mem] = line.split(",").map((s) => s.trim());
const pidNum = parseInt(pid, 10);
const memNum = parseInt(mem, 10);
if (!isNaN(pidNum) && !isNaN(memNum)) {
gpuByPid.set(pidNum, (gpuByPid.get(pidNum) || 0) + memNum);
}
}
return gpuByPid;
}
/**
* Map each pane's shell pid to its descendant process tree and aggregate
* CPU/RAM/GPU usage per pane.
*/
export function buildPaneMetrics(
panes: RawPane[],
processes: ProcessInfo[],
gpuByPid: Map<number, number>,
): PaneMetrics[] {
const byPid = new Map<number, ProcessInfo>();
const childrenOf = new Map<number, number[]>();
for (const p of processes) {
byPid.set(p.pid, p);
if (!childrenOf.has(p.ppid)) childrenOf.set(p.ppid, []);
childrenOf.get(p.ppid)!.push(p.pid);
}
return panes.map((pane) => {
// Walk the descendant tree starting at (and including) the pane's shell
const treePids: number[] = [];
const queue = [pane.pid];
const seen = new Set<number>();
for (let cursor = 0; cursor < queue.length; cursor++) {
const pid = queue[cursor];
if (seen.has(pid)) continue;
seen.add(pid);
if (byPid.has(pid)) treePids.push(pid);
for (const child of childrenOf.get(pid) || []) queue.push(child);
}
let cpuPercent = 0;
let memRssKb = 0;
let gpuMemMb = 0;
let topCommand: string | null = null;
let topCpu = -1;
for (const pid of treePids) {
const p = byPid.get(pid)!;
cpuPercent += p.cpu;
memRssKb += p.rss;
gpuMemMb += gpuByPid.get(pid) || 0;
// The pane shell itself is rarely the interesting process
if (p.cpu > topCpu && pid !== pane.pid) {
topCpu = p.cpu;
topCommand = p.comm;
}
}
if (topCommand === null && treePids.length > 0) {
topCommand = byPid.get(treePids[0])!.comm;
}
return {
paneId: pane.id,
sessionName: pane.sessionName,
pid: pane.pid,
processCount: treePids.length,
cpuPercent: Math.round(cpuPercent * 10) / 10,
memRssKb,
gpuMemMb,
topCommand,
};
});
}
/**
* Group panes into their windows (mutates the window objects' pane arrays).
*/
export function attachPanesToWindows(
windows: Map<string, TmuxWindow[]>,
panes: RawPane[],
): void {
const windowsBySessionAndIndex = new Map<string, Map<number, TmuxWindow>>();
for (const [sessionName, sessionWindows] of windows) {
const byIndex = new Map<number, TmuxWindow>();
for (const window of sessionWindows) {
if (!byIndex.has(window.index)) byIndex.set(window.index, window);
}
windowsBySessionAndIndex.set(sessionName, byIndex);
}
for (const pane of panes) {
const window = windowsBySessionAndIndex
.get(pane.sessionName)
?.get(pane.windowIndex);
if (window) {
const { sessionName: _s, windowIndex: _w, ...paneFields } = pane;
window.panes.push(paneFields);
}
}
}
export function shellEscape(s: string): string {
return "'" + s.replace(/'/g, "'\\''") + "'";
}
plugins/tmux-monitor/src/backend/repository.ts
+95
View File
@@ -0,0 +1,95 @@
import { and, eq } from "drizzle-orm";
import type { PluginDatabase } from "@termix/plugin-sdk/backend";
/* eslint-disable @typescript-eslint/no-explicit-any */
// The table comes from ctx.db.define, which the SDK hands back untyped, and
// the drizzle handle is the server's own. Typed at this module's edge instead.
type Table = any;
type Drizzle = any;
/* eslint-enable @typescript-eslint/no-explicit-any */
export type SessionTagRepository = ReturnType<
typeof createSessionTagRepository
>;
/**
* A user's tags on a tmux session, per host. Sessions are shared on the host
* (any user monitoring it sees the same tmux sessions), but tags are per
* user.
*/
export function createSessionTagRepository(db: PluginDatabase, table: Table) {
const client = () => db.client<Drizzle>();
return {
async listByUserAndHost(
userId: string,
hostId: number,
): Promise<Map<string, string[]>> {
const drizzle = await client();
const rows = await drizzle
.select()
.from(table)
.where(and(eq(table.userId, userId), eq(table.hostId, hostId)));
const bySession = new Map<string, string[]>();
for (const row of rows as { sessionName: string; tag: string }[]) {
const tags = bySession.get(row.sessionName) ?? [];
tags.push(row.tag);
bySession.set(row.sessionName, tags);
}
return bySession;
},
async renameSessionForHost(
hostId: number,
sessionName: string,
newSessionName: string,
): Promise<void> {
const drizzle = await client();
await drizzle
.update(table)
.set({ sessionName: newSessionName })
.where(
and(eq(table.hostId, hostId), eq(table.sessionName, sessionName)),
);
await db.persist();
},
async deleteSessionForHost(
hostId: number,
sessionName: string,
): Promise<void> {
const drizzle = await client();
await drizzle
.delete(table)
.where(
and(eq(table.hostId, hostId), eq(table.sessionName, sessionName)),
);
await db.persist();
},
async replaceForUserHostSession(
userId: string,
hostId: number,
sessionName: string,
tags: string[],
): Promise<void> {
const drizzle = await client();
await drizzle
.delete(table)
.where(
and(
eq(table.userId, userId),
eq(table.hostId, hostId),
eq(table.sessionName, sessionName),
),
);
if (tags.length > 0) {
await drizzle
.insert(table)
.values(tags.map((tag) => ({ userId, hostId, sessionName, tag })));
}
await db.persist();
},
};
}
plugins/tmux-monitor/src/backend/routes.ts
+872
View File
@@ -0,0 +1,872 @@
import express, { type Router } from "express";
import type { Client } from "ssh2";
import type {
PluginContext,
PluginHostSummary,
} from "@termix/plugin-sdk/backend";
import { execCommand, tmuxCommand } from "./tmux-commands.js";
import {
SEP,
parseSessions,
parseWindows,
parsePanes,
parsePsOutput,
parseGpuOutput,
buildPaneMetrics,
attachPanesToWindows,
shellEscape,
type RawPane,
type TmuxSessionSummary,
type TmuxWindow,
type PaneMetrics,
} from "./monitor-helpers.js";
import type { SessionTagRepository } from "./repository.js";
const PANE_ID_RE = /^%\d+$/;
// tmux session names cannot contain ":" or "."; keep to a conservative
// printable subset so the name is safe as a tmux target everywhere.
const SESSION_NAME_RE = /^[A-Za-z0-9_@%+=-]{1,64}$/;
const MAX_SEARCH_PANES = 100;
const MAX_MATCHES_PER_PANE = 50;
const SEARCH_HISTORY_LINES = 2000;
const SEARCH_CONCURRENCY = 4;
const POOL = "tmux-monitor";
interface TmuxSessionOverview extends TmuxSessionSummary {
windows: TmuxWindow[];
tags: string[];
}
function toErrorMessage(err: unknown): string {
return err instanceof Error ? err.message : String(err);
}
type TmuxErrorCode =
"TMUX_NOT_INSTALLED" | "TMUX_NO_SERVER" | "HOST_UNREACHABLE" | "TMUX_ERROR";
function classifyTmuxError(err: unknown): TmuxErrorCode {
const msg = toErrorMessage(err);
if (/command not found|exited with code 127/i.test(msg))
return "TMUX_NOT_INSTALLED";
if (/no server running|lost server/i.test(msg)) return "TMUX_NO_SERVER";
if (
/timeout|timed out|econnrefused|ehostunreach|enotfound|enetunreach|econnreset|authentication|handshake|keepalive/i.test(
msg,
)
)
return "HOST_UNREACHABLE";
return "TMUX_ERROR";
}
function sendTmuxError(
ctx: PluginContext,
res: express.Response,
err: unknown,
context: string,
hostId: number,
): void {
const code = classifyTmuxError(err);
const status = code === "TMUX_ERROR" ? 500 : 503;
const error =
code === "TMUX_NOT_INSTALLED"
? "tmux is not installed on this host"
: code === "TMUX_NO_SERVER"
? "No tmux server is running on this host"
: code === "HOST_UNREACHABLE"
? "Could not connect to the host"
: toErrorMessage(err);
ctx.log.error(`tmux ${context} failed for host ${hostId}`, err as Error);
res.status(status).json({ error, code });
}
/**
* Resolves the host for the acting user and checks the monitor is enabled for
* it. Sends the error response and returns null when access is denied.
*/
async function requireHost(
ctx: PluginContext,
req: express.Request,
res: express.Response,
): Promise<PluginHostSummary | null> {
const hostId = parseInt(String(req.params.hostId), 10);
if (isNaN(hostId)) {
res.status(400).json({ error: "Invalid host ID" });
return null;
}
const host = await ctx.hosts.get(hostId);
if (!host) {
res.status(403).json({ error: "Host not found or access denied" });
return null;
}
// The monitor is opt-in per host: hiding the UI is not enough, the API
// must refuse too.
const enabled = await ctx.settings.getHost<boolean>(
hostId,
"enableTmuxMonitor",
);
if (!enabled) {
res
.status(403)
.json({ error: "Tmux Monitor is not enabled for this host" });
return null;
}
return host;
}
async function withHostConnection<T>(
ctx: PluginContext,
host: PluginHostSummary,
fn: (client: Client) => Promise<T>,
): Promise<T> {
return ctx.ssh.withConnection<T, Client>(
host.id,
{ pool: POOL, purpose: "tmux", overrides: { readyTimeout: 60000 } },
fn,
);
}
async function tmuxAvailable(conn: Client): Promise<boolean> {
try {
await execCommand(conn, tmuxCommand("-V"));
return true;
} catch {
return false;
}
}
async function runTmuxList(conn: Client, command: string): Promise<string> {
try {
return await execCommand(conn, command);
} catch {
return ""; // tmux server not running -- no sessions
}
}
function listSessionsCmd(): string {
return tmuxCommand(
`list-sessions -F "#{session_name}${SEP}#{session_created}${SEP}#{session_activity}${SEP}#{session_attached}" 2>/dev/null`,
);
}
function listWindowsCmd(): string {
return tmuxCommand(
`list-windows -a -F "#{session_name}${SEP}#{window_index}${SEP}#{window_active}${SEP}#{window_name}" 2>/dev/null`,
);
}
function listPanesCmd(): string {
return tmuxCommand(
`list-panes -a -F "#{session_name}${SEP}#{window_index}${SEP}#{pane_id}${SEP}#{pane_index}${SEP}#{pane_pid}${SEP}#{pane_active}${SEP}#{pane_width}${SEP}#{pane_height}${SEP}#{pane_current_command}${SEP}#{pane_current_path}${SEP}#{pane_title}" 2>/dev/null`,
);
}
async function listPanesRaw(conn: Client): Promise<RawPane[]> {
return parsePanes(await runTmuxList(conn, listPanesCmd()));
}
async function collectPaneMetrics(
conn: Client,
panes: RawPane[],
): Promise<PaneMetrics[]> {
let psOutput = "";
try {
psOutput = await execCommand(
conn,
"ps -eo pid=,ppid=,pcpu=,pmem=,rss=,comm= 2>/dev/null",
);
} catch {
return [];
}
let gpuOutput = "";
try {
gpuOutput = await execCommand(
conn,
"command -v nvidia-smi >/dev/null 2>&1 && nvidia-smi --query-compute-apps=pid,used_gpu_memory --format=csv,noheader,nounits 2>/dev/null || true",
);
} catch {
// no GPU on host
}
return buildPaneMetrics(
panes,
parsePsOutput(psOutput),
parseGpuOutput(gpuOutput),
);
}
export function createTmuxMonitorRoutes(
ctx: PluginContext,
tags: SessionTagRepository,
): Router {
const router = express.Router();
router.use(ctx.rbac.require("use") as never);
/**
* @openapi
* /plugin-api/tmux-monitor/{hostId}/overview:
* get:
* summary: Get a host's tmux sessions, windows and panes
* tags:
* - Tmux Monitor
* parameters:
* - in: path
* name: hostId
* required: true
* schema:
* type: integer
* responses:
* 200:
* description: The tmux overview for this host.
* 403:
* description: Host not found, not accessible, or the monitor is disabled for it.
*/
router.get("/:hostId/overview", async (req, res) => {
const userId = ctx.currentActor();
const host = await requireHost(ctx, req, res);
if (!host || !userId) return;
try {
const result = await withHostConnection(ctx, host, async (conn) => {
if (!(await tmuxAvailable(conn))) {
return { available: false, sessions: [] as TmuxSessionOverview[] };
}
const [sessionsOut, windowsOut, panesOut] = await Promise.all([
runTmuxList(conn, listSessionsCmd()),
runTmuxList(conn, listWindowsCmd()),
runTmuxList(conn, listPanesCmd()),
]);
const sessions = parseSessions(sessionsOut);
const windows = parseWindows(windowsOut);
attachPanesToWindows(windows, parsePanes(panesOut));
const sessionTags = await tags.listByUserAndHost(userId, host.id);
const full: TmuxSessionOverview[] = sessions.map((s) => ({
...s,
windows: windows.get(s.name) || [],
tags: sessionTags.get(s.name) || [],
}));
return { available: true, sessions: full };
});
res.json(result);
} catch (err) {
sendTmuxError(ctx, res, err, "overview", host.id);
}
});
/**
* @openapi
* /plugin-api/tmux-monitor/{hostId}/focus:
* post:
* summary: Focus a pane
* description: Selects the pane's window and pane on the server, so every attached client switches to it.
* tags:
* - Tmux Monitor
* parameters:
* - in: path
* name: hostId
* required: true
* schema:
* type: integer
* responses:
* 200:
* description: Focused.
*/
router.post("/:hostId/focus", async (req, res) => {
const host = await requireHost(ctx, req, res);
if (!host) return;
const paneId = String((req.body as { paneId?: string })?.paneId || "");
if (!PANE_ID_RE.test(paneId)) {
return res.status(400).json({ error: "Invalid pane ID" });
}
try {
await withHostConnection(ctx, host, (conn) =>
execCommand(
conn,
tmuxCommand(
`select-window -t ${shellEscape(paneId)} \\; select-pane -t ${shellEscape(paneId)}`,
),
),
);
res.json({ ok: true });
} catch (err) {
sendTmuxError(ctx, res, err, "focus", host.id);
}
});
/**
* @openapi
* /plugin-api/tmux-monitor/{hostId}/sessions:
* post:
* summary: Create a detached tmux session
* description: Starts the tmux server if none is running.
* tags:
* - Tmux Monitor
* parameters:
* - in: path
* name: hostId
* required: true
* schema:
* type: integer
* responses:
* 200:
* description: Session created.
* 409:
* description: A session with this name already exists.
*/
router.post("/:hostId/sessions", async (req, res) => {
const host = await requireHost(ctx, req, res);
if (!host) return;
const name = String((req.body as { name?: string })?.name || "").trim();
if (!SESSION_NAME_RE.test(name)) {
return res.status(400).json({ error: "Invalid session name" });
}
try {
await withHostConnection(ctx, host, (conn) =>
execCommand(
conn,
tmuxCommand(`new-session -d -s ${shellEscape(name)}`),
),
);
ctx.log.info(`tmux session created: ${name} on host ${host.id}`);
res.json({ ok: true, name });
} catch (err) {
if (/duplicate session/i.test(toErrorMessage(err))) {
return res
.status(409)
.json({ error: "A session with this name already exists" });
}
sendTmuxError(ctx, res, err, "create session", host.id);
}
});
/**
* @openapi
* /plugin-api/tmux-monitor/{hostId}/windows:
* post:
* summary: Create a window in an existing session
* tags:
* - Tmux Monitor
* parameters:
* - in: path
* name: hostId
* required: true
* schema:
* type: integer
* responses:
* 200:
* description: Window created.
* 404:
* description: Session not found.
*/
router.post("/:hostId/windows", async (req, res) => {
const host = await requireHost(ctx, req, res);
if (!host) return;
const sessionName = String(
(req.body as { sessionName?: string })?.sessionName || "",
).trim();
if (!sessionName || /[:.\n]/.test(sessionName)) {
return res.status(400).json({ error: "Invalid session name" });
}
try {
await withHostConnection(ctx, host, (conn) =>
execCommand(
conn,
tmuxCommand(`new-window -t ${shellEscape(`=${sessionName}`)}`),
),
);
ctx.log.info(
`tmux window created in session ${sessionName} on host ${host.id}`,
);
res.json({ ok: true });
} catch (err) {
if (/can't find session|no such session/i.test(toErrorMessage(err))) {
return res.status(404).json({ error: "Session not found" });
}
sendTmuxError(ctx, res, err, "create window", host.id);
}
});
/**
* @openapi
* /plugin-api/tmux-monitor/{hostId}/rename:
* post:
* summary: Rename a session
* description: Saved tags follow the session to its new name, for every user monitoring this host.
* tags:
* - Tmux Monitor
* parameters:
* - in: path
* name: hostId
* required: true
* schema:
* type: integer
* responses:
* 200:
* description: Session renamed.
* 404:
* description: Session not found.
* 409:
* description: A session with this name already exists.
*/
router.post("/:hostId/rename", async (req, res) => {
const host = await requireHost(ctx, req, res);
if (!host) return;
const body = req.body as { sessionName?: string; newName?: string };
const sessionName = String(body?.sessionName || "").trim();
const newName = String(body?.newName || "").trim();
if (!sessionName || /[:.\n]/.test(sessionName)) {
return res.status(400).json({ error: "Invalid session name" });
}
if (!SESSION_NAME_RE.test(newName)) {
return res.status(400).json({ error: "Invalid new session name" });
}
try {
await withHostConnection(ctx, host, (conn) =>
execCommand(
conn,
tmuxCommand(
`rename-session -t ${shellEscape(`=${sessionName}`)} ${shellEscape(newName)}`,
),
),
);
await tags.renameSessionForHost(host.id, sessionName, newName);
ctx.log.info(
`tmux session renamed on host ${host.id}: ${sessionName} -> ${newName}`,
);
await ctx.audit.record({
action: "tmux_session_rename",
resourceType: "host",
resourceId: String(host.id),
resourceName: sessionName,
details: JSON.stringify({ newName }),
success: true,
});
res.json({ ok: true, name: newName });
} catch (err) {
if (/can't find session|no such session/i.test(toErrorMessage(err))) {
return res.status(404).json({ error: "Session not found" });
}
if (/duplicate session/i.test(toErrorMessage(err))) {
return res
.status(409)
.json({ error: "A session with this name already exists" });
}
sendTmuxError(ctx, res, err, "rename session", host.id);
}
});
/**
* @openapi
* /plugin-api/tmux-monitor/{hostId}/kill:
* post:
* summary: Kill a session and drop its saved tags
* tags:
* - Tmux Monitor
* parameters:
* - in: path
* name: hostId
* required: true
* schema:
* type: integer
* responses:
* 200:
* description: Session killed.
* 404:
* description: Session not found.
*/
router.post("/:hostId/kill", async (req, res) => {
const host = await requireHost(ctx, req, res);
if (!host) return;
const sessionName = String(
(req.body as { sessionName?: string })?.sessionName || "",
).trim();
if (!sessionName || /[:.\n]/.test(sessionName)) {
return res.status(400).json({ error: "Invalid session name" });
}
try {
await withHostConnection(ctx, host, (conn) =>
execCommand(
conn,
tmuxCommand(`kill-session -t ${shellEscape(`=${sessionName}`)}`),
),
);
await tags.deleteSessionForHost(host.id, sessionName);
ctx.log.info(`tmux session killed on host ${host.id}: ${sessionName}`);
await ctx.audit.record({
action: "tmux_session_kill",
resourceType: "host",
resourceId: String(host.id),
resourceName: sessionName,
success: true,
});
res.json({ ok: true });
} catch (err) {
if (/can't find session|no such session/i.test(toErrorMessage(err))) {
return res.status(404).json({ error: "Session not found" });
}
sendTmuxError(ctx, res, err, "kill session", host.id);
}
});
/**
* @openapi
* /plugin-api/tmux-monitor/{hostId}/kill-window:
* post:
* summary: Kill a window and every pane in it
* description: Killing the last window of a session ends the session (tmux semantics).
* tags:
* - Tmux Monitor
* parameters:
* - in: path
* name: hostId
* required: true
* schema:
* type: integer
* responses:
* 200:
* description: Window killed.
* 404:
* description: Window not found.
*/
router.post("/:hostId/kill-window", async (req, res) => {
const host = await requireHost(ctx, req, res);
if (!host) return;
const body = req.body as { sessionName?: string; windowIndex?: number };
const sessionName = String(body?.sessionName || "").trim();
const windowIndex = Number(body?.windowIndex);
if (!sessionName || /[:.\n]/.test(sessionName)) {
return res.status(400).json({ error: "Invalid session name" });
}
if (!Number.isInteger(windowIndex) || windowIndex < 0) {
return res.status(400).json({ error: "Invalid window index" });
}
try {
await withHostConnection(ctx, host, (conn) =>
execCommand(
conn,
tmuxCommand(
`kill-window -t ${shellEscape(`=${sessionName}:${windowIndex}`)}`,
),
),
);
ctx.log.info(
`tmux window killed on host ${host.id}: ${sessionName}:${windowIndex}`,
);
await ctx.audit.record({
action: "tmux_window_kill",
resourceType: "host",
resourceId: String(host.id),
resourceName: sessionName,
details: JSON.stringify({ windowIndex }),
success: true,
});
res.json({ ok: true });
} catch (err) {
if (
/can't find window|no such window|can't find session/i.test(
toErrorMessage(err),
)
) {
return res.status(404).json({ error: "Window not found" });
}
sendTmuxError(ctx, res, err, "kill window", host.id);
}
});
/**
* @openapi
* /plugin-api/tmux-monitor/{hostId}/kill-pane:
* post:
* summary: Kill a single pane
* description: Killing the last pane of a window closes the window, and the last window of a session ends the session (tmux semantics).
* tags:
* - Tmux Monitor
* parameters:
* - in: path
* name: hostId
* required: true
* schema:
* type: integer
* responses:
* 200:
* description: Pane killed.
* 404:
* description: Pane not found.
*/
router.post("/:hostId/kill-pane", async (req, res) => {
const host = await requireHost(ctx, req, res);
if (!host) return;
const paneId = String((req.body as { paneId?: string })?.paneId || "");
if (!PANE_ID_RE.test(paneId)) {
return res.status(400).json({ error: "Invalid pane ID" });
}
try {
await withHostConnection(ctx, host, (conn) =>
execCommand(conn, tmuxCommand(`kill-pane -t ${shellEscape(paneId)}`)),
);
ctx.log.info(`tmux pane killed on host ${host.id}: ${paneId}`);
await ctx.audit.record({
action: "tmux_pane_kill",
resourceType: "host",
resourceId: String(host.id),
resourceName: paneId,
success: true,
});
res.json({ ok: true });
} catch (err) {
if (/can't find pane|no such pane/i.test(toErrorMessage(err))) {
return res.status(404).json({ error: "Pane not found" });
}
sendTmuxError(ctx, res, err, "kill pane", host.id);
}
});
/**
* @openapi
* /plugin-api/tmux-monitor/{hostId}/split:
* post:
* summary: Split the window containing a pane
* description: "\"h\" places the new pane to the right, \"v\" below, matching tmux's own -h/-v semantics. The new pane starts in the source pane's working directory."
* tags:
* - Tmux Monitor
* parameters:
* - in: path
* name: hostId
* required: true
* schema:
* type: integer
* responses:
* 200:
* description: Pane split.
*/
router.post("/:hostId/split", async (req, res) => {
const host = await requireHost(ctx, req, res);
if (!host) return;
const body = req.body as { paneId?: string; direction?: string };
const paneId = String(body?.paneId || "");
const direction = body?.direction === "v" ? "-v" : "-h";
if (!PANE_ID_RE.test(paneId)) {
return res.status(400).json({ error: "Invalid pane ID" });
}
if (body?.direction !== "h" && body?.direction !== "v") {
return res.status(400).json({ error: "Invalid split direction" });
}
try {
await withHostConnection(ctx, host, (conn) =>
execCommand(
conn,
tmuxCommand(
`split-window ${direction} -t ${shellEscape(paneId)} -c ${shellEscape("#{pane_current_path}")}`,
),
),
);
ctx.log.info(
`tmux pane split on host ${host.id}: ${paneId} (${body.direction})`,
);
res.json({ ok: true });
} catch (err) {
sendTmuxError(ctx, res, err, "split", host.id);
}
});
/**
* @openapi
* /plugin-api/tmux-monitor/{hostId}/search:
* get:
* summary: Search pane output across a host's tmux sessions
* tags:
* - Tmux Monitor
* parameters:
* - in: path
* name: hostId
* required: true
* schema:
* type: integer
* - in: query
* name: q
* required: true
* schema:
* type: string
* responses:
* 200:
* description: Matching lines, capped per pane and across panes.
*/
router.get("/:hostId/search", async (req, res) => {
const host = await requireHost(ctx, req, res);
if (!host) return;
const query = String(req.query.q || "").trim();
if (!query) {
return res.status(400).json({ error: "Missing search query" });
}
try {
const results = await withHostConnection(ctx, host, async (conn) => {
const allPanes = await listPanesRaw(conn);
const panes = allPanes.slice(0, MAX_SEARCH_PANES);
// Flips to true whenever a limit was hit, so the UI can tell the user
// the results are partial instead of silently truncating.
let truncated = allPanes.length > MAX_SEARCH_PANES;
const matches: Array<{
paneId: string;
sessionName: string;
windowIndex: number;
line: number;
text: string;
}> = [];
// Bounded concurrency; each search runs capture+grep remotely so only
// matching lines travel back over the wire.
for (let i = 0; i < panes.length; i += SEARCH_CONCURRENCY) {
const batch = panes.slice(i, i + SEARCH_CONCURRENCY);
await Promise.all(
batch.map(async (pane) => {
try {
const output = await execCommand(
conn,
tmuxCommand(
`capture-pane -p -J -t ${shellEscape(pane.id)} -S -${SEARCH_HISTORY_LINES} 2>/dev/null | grep -n -i -F -- ${shellEscape(query)} | head -${MAX_MATCHES_PER_PANE}`,
),
);
const lines = output.split("\n").filter(Boolean);
if (lines.length >= MAX_MATCHES_PER_PANE) truncated = true;
for (const line of lines) {
const sep = line.indexOf(":");
if (sep === -1) continue;
matches.push({
paneId: pane.id,
sessionName: pane.sessionName,
windowIndex: pane.windowIndex,
line: parseInt(line.slice(0, sep), 10) || 0,
text: line.slice(sep + 1).slice(0, 500),
});
}
} catch {
// grep exits non-zero when there are no matches -- not an error
}
}),
);
}
return { matches, truncated };
});
res.json({
query,
matches: results.matches,
truncated: results.truncated,
searchedLines: SEARCH_HISTORY_LINES,
maxPanes: MAX_SEARCH_PANES,
});
} catch (err) {
sendTmuxError(ctx, res, err, "search", host.id);
}
});
/**
* @openapi
* /plugin-api/tmux-monitor/{hostId}/metrics:
* get:
* summary: Per-pane CPU, memory and GPU usage
* tags:
* - Tmux Monitor
* parameters:
* - in: path
* name: hostId
* required: true
* schema:
* type: integer
* responses:
* 200:
* description: Metrics for every pane tmux reports.
*/
router.get("/:hostId/metrics", async (req, res) => {
const host = await requireHost(ctx, req, res);
if (!host) return;
try {
const metrics = await withHostConnection(ctx, host, async (conn) => {
const panes = await listPanesRaw(conn);
if (panes.length === 0) return [];
return collectPaneMetrics(conn, panes);
});
res.json({ panes: metrics });
} catch (err) {
sendTmuxError(ctx, res, err, "metrics", host.id);
}
});
/**
* @openapi
* /plugin-api/tmux-monitor/{hostId}/tags:
* put:
* summary: Replace the acting user's tags on a session
* tags:
* - Tmux Monitor
* parameters:
* - in: path
* name: hostId
* required: true
* schema:
* type: integer
* responses:
* 200:
* description: Tags saved.
*/
router.put("/:hostId/tags", async (req, res) => {
const userId = ctx.currentActor();
const host = await requireHost(ctx, req, res);
if (!host || !userId) return;
const { sessionName, tags: rawTags } = req.body as {
sessionName?: string;
tags?: string[];
};
if (!sessionName || typeof sessionName !== "string") {
return res.status(400).json({ error: "Missing session name" });
}
if (!Array.isArray(rawTags) || rawTags.some((t) => typeof t !== "string")) {
return res
.status(400)
.json({ error: "Tags must be an array of strings" });
}
const cleanTags = [
...new Set(rawTags.map((t) => t.trim().slice(0, 64)).filter(Boolean)),
].slice(0, 20);
try {
await tags.replaceForUserHostSession(
userId,
host.id,
sessionName,
cleanTags,
);
res.json({ sessionName, tags: cleanTags });
} catch (err) {
ctx.log.error(
`Failed to save tmux session tags for host ${host.id}`,
err as Error,
);
res.status(500).json({ error: toErrorMessage(err) });
}
});
return router;
}
plugins/tmux-monitor/src/backend/service.ts
+63
View File
@@ -0,0 +1,63 @@
import type { Client, ClientChannel } from "ssh2";
import type { PluginContext } from "@termix/plugin-sdk/backend";
import {
attachOrCreateTmuxSession,
detectTmux,
waitForTmuxSession,
} from "./tmux-commands.js";
export interface TmuxDetection {
available: boolean;
sessions: string[];
}
/**
* What the terminal (ssh-terminal's optional "tmux.sessions" consumer) asks
* of this plugin. Clients and streams cross the service boundary as
* `unknown`, since the SDK types services without an ssh2 dependency.
*/
export interface TmuxSessionsV1 {
detect: (client: unknown) => Promise<TmuxDetection>;
attachOrCreate: (
stream: unknown,
name?: string,
newName?: string,
hostId?: number,
) => Promise<void>;
waitForSession: (client: unknown, name: string) => Promise<string>;
}
export function createTmuxSessionsService(ctx: PluginContext): TmuxSessionsV1 {
return {
async detect(client) {
const result = await detectTmux(client as Client);
return {
available: result.available,
sessions: result.sessions.map((s) => s.name),
};
},
async attachOrCreate(stream, name, newName, hostId) {
const mouseEnabled =
hostId === undefined ||
(await ctx.settings.getHost<boolean>(hostId, "mouseEnabled")) !== false;
attachOrCreateTmuxSession(
stream as ClientChannel,
name,
newName,
mouseEnabled,
);
},
async waitForSession(client, name) {
const confirmed = await waitForTmuxSession(client as Client, name);
if (!confirmed) {
ctx.log.warn(
`Timed out waiting for a new tmux session to appear: ${name}`,
);
return name;
}
return confirmed;
},
};
}
plugins/tmux-monitor/src/backend/tables.ts
+32
View File
@@ -0,0 +1,32 @@
import {
adoptLegacyTable,
defineTable,
id,
refHost,
refUser,
text,
timestamp,
} from "@termix/plugin-sdk/db";
/**
* A user's tags on a tmux session, per host. Sessions are shared on the host
* itself, but tags are per user: everyone who monitors the same host can tag
* the same session differently.
*
* Adopted from core's tmux_session_tags, so the column names are the legacy
* ones and the rename carries every existing row across. Core never indexed
* it, so there is no legacy index to keep.
*/
export const sessionTags = adoptLegacyTable(
"tmux_session_tags",
defineTable("session_tags", {
id: id(),
userId: refUser(),
hostId: refHost(),
sessionName: text().notNull(),
tag: text().notNull(),
createdAt: timestamp().notNull().defaultNow(),
}),
);
export const tables = [sessionTags];
plugins/tmux-monitor/src/backend/tmux-commands.ts
+164
View File
@@ -0,0 +1,164 @@
import { randomUUID } from "node:crypto";
import type { Client, ClientChannel } from "ssh2";
const TMUX_PATH_DIRS = [
"/opt/homebrew/bin",
"/usr/local/bin",
"/opt/bin",
"/usr/pkg/bin",
];
export function withTmuxPath(command: string): string {
const script = `PATH=${TMUX_PATH_DIRS.join(":")}:"$PATH"; export PATH; ${command}`;
return `/bin/sh -c ${shellEscape(script)}`;
}
export function tmuxCommand(args: string): string {
return withTmuxPath(`tmux -u ${args}`);
}
/**
* Run a command on the remote host via a separate exec channel.
* Returns stdout as a string. Does not pollute the interactive shell.
*/
export function execCommand(conn: Client, command: string): Promise<string> {
return new Promise((resolve, reject) => {
conn.exec(command, (err, stream) => {
if (err) {
reject(err);
return;
}
let stdout = "";
let stderr = "";
stream.on("data", (data: Buffer) => {
stdout += data.toString("utf-8");
});
stream.stderr.on("data", (data: Buffer) => {
stderr += data.toString("utf-8");
});
stream.on("error", (err: Error) => {
reject(err);
});
stream.on("close", (code: number) => {
if (code !== 0 && stdout === "") {
reject(
new Error(stderr.trim() || `Command exited with code ${code}`),
);
} else {
resolve(stdout.trim());
}
});
});
});
}
export interface TmuxSessionInfo {
name: string;
created: number;
lastActivity: number;
windows: number;
attachedClients: number;
}
export interface TmuxDetectionResult {
available: boolean;
sessions: TmuxSessionInfo[];
}
/**
* Detect whether tmux is installed and list all existing sessions with details.
*/
export async function detectTmux(conn: Client): Promise<TmuxDetectionResult> {
try {
await execCommand(conn, tmuxCommand("-V"));
} catch {
return { available: false, sessions: [] };
}
let sessions: TmuxSessionInfo[] = [];
try {
const output = await execCommand(
conn,
tmuxCommand(
`list-sessions -F "#{session_name}|#{session_created}|#{session_activity}|#{session_windows}|#{session_attached}" 2>/dev/null`,
),
);
if (output) {
sessions = output
.split("\n")
.filter((line) => line.length > 0)
.map((line) => {
const [name, created, activity, windows, attached] = line.split("|");
return {
name,
created: parseInt(created, 10) || 0,
lastActivity: parseInt(activity, 10) || 0,
windows: parseInt(windows, 10) || 0,
attachedClients: parseInt(attached, 10) || 0,
};
});
}
} catch {
// tmux server not running yet -- no sessions exist
}
return { available: true, sessions };
}
/**
* Wait for a tmux session to appear by polling via exec channel.
* Returns the session name once found, or null on timeout.
*/
export async function waitForTmuxSession(
conn: Client,
sessionName: string,
timeoutMs = 5000,
intervalMs = 100,
): Promise<string | null> {
const deadline = Date.now() + timeoutMs;
while (Date.now() < deadline) {
try {
await execCommand(
conn,
tmuxCommand(`has-session -t ${shellEscape(sessionName)} 2>/dev/null`),
);
return sessionName;
} catch {
// session not ready yet
}
await new Promise((resolve) => setTimeout(resolve, intervalMs));
}
return null;
}
/**
* Write tmux attach or new-session command to the interactive shell stream.
* Uses && exit so the shell only closes if tmux started successfully.
*
* Options are set on this session only so the user's own tmux config stays
* untouched. -q keeps an older tmux that lacks an option from aborting the
* attach.
*/
export function attachOrCreateTmuxSession(
stream: ClientChannel,
existingSessionName?: string,
newSessionName?: string,
mouseEnabled = true,
): void {
const name =
existingSessionName || newSessionName || `termix-${randomUUID()}`;
const target = shellEscape(`=${name}`);
const commands = existingSessionName
? []
: [`new-session -d -s ${shellEscape(name)}`];
commands.push(
`set-option -q -t ${target} mouse ${mouseEnabled ? "on" : "off"}`,
`set-option -q -t ${target} history-limit 50000`,
`attach-session -t ${target}`,
);
stream.write(`${tmuxCommand(commands.join(" \\; "))} && exit\r`);
}
export function shellEscape(s: string): string {
return "'" + s.replace(/'/g, "'\\''") + "'";
}
plugins/tmux-monitor/src/frontend/HostOverview.tsx
+108
View File
@@ -0,0 +1,108 @@
import {
useCallback,
useEffect,
useRef,
useState,
type ReactNode,
} from "react";
import { useTranslation } from "@termix/plugin-sdk/frontend";
import { Button, Skeleton } from "@termix/plugin-sdk/ui";
import {
getTmuxOverview,
getTmuxMetrics,
type TmuxOverview,
type TmuxPaneMetrics,
} from "./api";
import { pollBackgroundHost } from "./poll-queue";
import { useAdaptivePolling } from "./use-adaptive-polling";
/** Each background host owns its response, error and adaptive polling cycle. */
export function HostOverview({
hostId,
children,
}: {
hostId: number;
children: (overview: TmuxOverview, metrics: TmuxPaneMetrics[]) => ReactNode;
}) {
const { t } = useTranslation();
const [overview, setOverview] = useState<TmuxOverview | null>(null);
const [metrics, setMetrics] = useState<TmuxPaneMetrics[]>([]);
const [error, setError] = useState(false);
const inFlight = useRef(false);
const mounted = useRef(true);
const signature = useRef("");
useEffect(() => {
mounted.current = true;
return () => {
mounted.current = false;
};
}, []);
const load = useCallback(async () => {
if (inFlight.current) return;
inFlight.current = true;
try {
const snapshot = await pollBackgroundHost(async () => {
if (!mounted.current) return null;
const next = await getTmuxOverview(hostId);
const values =
next.available && mounted.current
? await getTmuxMetrics(hostId).catch(() => [])
: [];
return { next, values };
});
if (!snapshot) return;
const { next, values } = snapshot;
if (!mounted.current) return;
setOverview(next);
setError(false);
setMetrics(values);
const nextSignature = JSON.stringify([next, values]);
const changed = signature.current !== nextSignature;
signature.current = nextSignature;
return changed;
} catch (err) {
if (mounted.current) {
setError(true);
setMetrics([]);
}
throw err;
} finally {
inFlight.current = false;
}
}, [hostId]);
useAdaptivePolling(
load,
{ minIntervalMs: 10_000, maxIntervalMs: 60_000, stablePollsPerStep: 3 },
true,
{ runImmediately: true },
);
if (error)
return (
<div className="px-3 py-2 text-xs text-destructive" role="status">
{t("tmuxMonitor.failedToLoad")}
<Button
variant="ghost"
size="sm"
onClick={() => {
void load().catch(() => {});
}}
>
{t("tmuxMonitor.retry")}
</Button>
</div>
);
if (!overview) return <Skeleton className="m-2 h-8" />;
if (!overview.available)
return (
<p className="px-3 py-2 text-xs text-muted-foreground">
{t("tmuxMonitor.tmuxUnavailable")}
</p>
);
if (!overview.sessions.length)
return (
<p className="px-3 py-2 text-xs text-muted-foreground">
{t("tmuxMonitor.noSessions")}
</p>
);
return children(overview, metrics);
}
plugins/tmux-monitor/src/frontend/HostTmuxMonitorSection.tsx
+78
View File
@@ -0,0 +1,78 @@
import { Layers } from "lucide-react";
import {
useTranslation,
type HostEditorSectionProps,
} from "@termix/plugin-sdk/frontend";
import { FakeSwitch, SectionCard, SettingRow } from "@termix/plugin-sdk/ui";
type PluginSettingsForm = Record<string, Record<string, unknown>>;
/**
* The host editor's tmux monitor toggle. Writes into the form's
* pluginSettings for this plugin, which the editor saves through the
* plugin's host settings route after the host itself.
*/
export function HostTmuxMonitorSection({
form,
updateForm,
}: HostEditorSectionProps) {
const { t } = useTranslation();
const settings = ((form?.pluginSettings as PluginSettingsForm | undefined)?.[
"tmux-monitor"
] ?? {}) as Record<string, unknown>;
const enabled = settings.enableTmuxMonitor === true;
const setSetting = (key: string, value: boolean) =>
updateForm((current) => {
const all = (current.pluginSettings ?? {}) as PluginSettingsForm;
return {
...current,
pluginSettings: {
...all,
"tmux-monitor": { ...all["tmux-monitor"], [key]: value },
},
};
});
return (
<SectionCard
title={t("tmuxMonitor.title")}
icon={<Layers className="size-3.5" />}
>
<div className="flex flex-col gap-4 py-3">
<SettingRow
label={t("hosts.enableTmuxMonitor")}
defaultKey="enableTmuxMonitor"
description={
<>
{t("hosts.enableTmuxMonitorDesc")}{" "}
<a
href="https://docs.termix.site/features/terminal/tmux"
target="_blank"
rel="noreferrer"
className="text-accent-brand hover:underline"
>
{t("hosts.docsLink")}
</a>
</>
}
>
<FakeSwitch
checked={enabled}
onChange={(value) => setSetting("enableTmuxMonitor", value)}
/>
</SettingRow>
<SettingRow
label={t("settings.host.mouseEnabled.label")}
description={t("settings.host.mouseEnabled.description")}
>
<FakeSwitch
checked={settings.mouseEnabled !== false}
onChange={(value) => setSetting("mouseEnabled", value)}
/>
</SettingRow>
</div>
</SectionCard>
);
}
plugins/tmux-monitor/src/frontend/PanePreview.tsx
+169
View File
@@ -0,0 +1,169 @@
// Interactive view of a tmux pane. Embeds the real SSH terminal (through the
// terminal.view component ssh-terminal registers) and attaches to the
// selected session via the native tmux_attach flow, so the pane is fully
// usable: typing, mouse scrolling and tmux copy-mode all behave exactly like
// a normal terminal tab.
import { useRef, useState } from "react";
import { useTranslation } from "@termix/plugin-sdk/frontend";
import {
Activity,
Cpu,
MemoryStick,
RotateCw,
SquareSplitHorizontal,
SquareSplitVertical,
Trash2,
X,
} from "lucide-react";
import { PluginComponent } from "@termix/plugin-sdk/ui";
import type { PluginHostRecord, TabHandle } from "@termix/plugin-sdk/frontend";
import type { TmuxPaneMetrics } from "./api";
import { formatMem } from "./format";
import type { SelectedPane } from "./types";
interface PanePreviewProps {
host: PluginHostRecord;
pane: SelectedPane;
metrics?: TmuxPaneMetrics;
/** Imperative handle of the embedded terminal, used by the parent to nudge
* a refit/redraw after layout-changing tmux actions. */
terminalRef?: React.RefObject<TabHandle | null>;
/** Split the window containing this pane ("h" = new pane to the right,
* "v" = below — tmux -h/-v semantics). */
onSplit: (direction: "h" | "v") => void;
/** Ask for confirmation and kill this pane. */
onKillPane: () => void;
onClose: () => void;
}
function newInstanceId(): string {
return typeof crypto.randomUUID === "function"
? crypto.randomUUID()
: `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
}
export function PanePreview({
host,
pane,
metrics,
terminalRef,
onSplit,
onKillPane,
onClose,
}: PanePreviewProps) {
const { t } = useTranslation();
// One PTY per mount; the parent remounts this component (via key) when the
// host or session changes. Pane switches within a session go through the
// focus endpoint instead, so the connection is reused.
const instanceIdRef = useRef<string>(newInstanceId());
// Bumping this remounts the embedded terminal with a fresh PTY — the rescue
// hatch when the attached client's rendering gets out of sync.
const [attachNonce, setAttachNonce] = useState(0);
function reattach() {
instanceIdRef.current = newInstanceId();
setAttachNonce((n) => n + 1);
}
// The host's own authType travels in the spread, so a Tailscale host still
// gets the Tailscale-aware PTY path. The SSH port may be non-standard.
const resolvedPort = host.sshPort ?? host.port;
const terminalHostConfig = {
...host,
port: resolvedPort,
sshPort: resolvedPort,
instanceId: instanceIdRef.current,
};
return (
<>
<div className="flex items-center gap-3 border-b border-border px-3 py-1.5 text-xs text-muted-foreground">
<span className="flex gap-2 font-medium text-foreground">
<span>{pane.sessionName}</span>
<span className="text-muted-foreground">{pane.paneId}</span>
</span>
{metrics && (
<>
<span className="flex items-center gap-1">
<Cpu className="size-3" />
{metrics.cpuPercent.toFixed(1)}%
</span>
<span className="flex items-center gap-1">
<MemoryStick className="size-3" />
{formatMem(metrics.memRssKb)}
</span>
{metrics.gpuMemMb > 0 && (
<span className="flex items-center gap-1">
<Activity className="size-3" />
{metrics.gpuMemMb} MB GPU
</span>
)}
{metrics.topCommand && (
<span className="truncate">
{metrics.topCommand} ({metrics.processCount})
</span>
)}
</>
)}
<div className="ml-auto flex items-center gap-2">
<button
className="text-muted-foreground hover:text-foreground"
title={t("tmuxMonitor.splitRight")}
aria-label={t("tmuxMonitor.splitRight")}
onClick={() => onSplit("h")}
>
<SquareSplitHorizontal className="size-3.5" />
</button>
<button
className="text-muted-foreground hover:text-foreground"
title={t("tmuxMonitor.splitDown")}
aria-label={t("tmuxMonitor.splitDown")}
onClick={() => onSplit("v")}
>
<SquareSplitVertical className="size-3.5" />
</button>
<button
className="text-muted-foreground hover:text-destructive"
title={t("tmuxMonitor.killPane")}
aria-label={t("tmuxMonitor.killPane")}
onClick={onKillPane}
>
<Trash2 className="size-3.5" />
</button>
<div className="h-3.5 border-l border-border" />
<button
className="text-muted-foreground hover:text-foreground"
title={t("tmuxMonitor.reattach")}
aria-label={t("tmuxMonitor.reattach")}
onClick={reattach}
>
<RotateCw className="size-3.5" />
</button>
<button
className="text-muted-foreground hover:text-foreground"
title={t("tmuxMonitor.closePreview")}
aria-label={t("tmuxMonitor.closePreview")}
onClick={onClose}
>
<X className="size-3.5" />
</button>
</div>
</div>
<div className="min-h-0 flex-1 overflow-hidden">
<PluginComponent
id="terminal.view"
key={attachNonce}
handleRef={terminalRef}
hostConfig={terminalHostConfig}
isVisible={true}
title={pane.sessionName}
showTitle={false}
splitScreen={false}
tmuxAttachSession={pane.sessionName}
onClose={onClose}
/>
</div>
</>
);
}
plugins/tmux-monitor/src/frontend/SearchResults.tsx
+86
View File
@@ -0,0 +1,86 @@
import type { ReactNode } from "react";
import { useTranslation } from "@termix/plugin-sdk/frontend";
import { X } from "lucide-react";
import type { TmuxSearchMatch, TmuxSearchResult } from "./api";
interface SearchResultsProps {
results: TmuxSearchMatch[];
searching: boolean;
/** The query that produced these results, used to highlight matches. */
query: string;
/** Search-limit info; renders a "partial results" note when truncated. */
limits: Pick<
TmuxSearchResult,
"truncated" | "searchedLines" | "maxPanes"
> | null;
onSelect: (match: TmuxSearchMatch) => void;
onClose: () => void;
}
function highlightMatch(text: string, query: string): ReactNode {
if (!query) return text;
const index = text.toLowerCase().indexOf(query.toLowerCase());
if (index === -1) return text;
return (
<>
{text.slice(0, index)}
<mark className="bg-accent-brand/30 px-0 text-foreground">
{text.slice(index, index + query.length)}
</mark>
{text.slice(index + query.length)}
</>
);
}
export function SearchResults({
results,
searching,
query,
limits,
onSelect,
onClose,
}: SearchResultsProps) {
const { t } = useTranslation();
return (
<div className="max-h-56 overflow-y-auto border-b border-border bg-card">
<div className="flex items-center justify-between gap-2 px-3 py-1.5">
<span className="truncate text-xs text-muted-foreground">
{searching
? t("common.loading")
: t("tmuxMonitor.searchResults", { count: results.length })}
{!searching && limits?.truncated && (
<span className="ml-2 text-muted-foreground/70">
{t("tmuxMonitor.searchTruncated", {
lines: limits.searchedLines,
panes: limits.maxPanes,
})}
</span>
)}
</span>
<button
className="text-muted-foreground hover:text-foreground"
title={t("tmuxMonitor.closeSearchResults")}
onClick={onClose}
>
<X className="size-3.5" />
</button>
</div>
{results.map((match, i) => (
<div
key={`${match.paneId}-${match.line}-${i}`}
className="flex cursor-pointer items-baseline gap-2 px-3 py-1 text-xs hover:bg-muted/40"
onClick={() => onSelect(match)}
>
<span className="flex shrink-0 gap-1.5 font-medium text-primary">
<span>{match.sessionName}</span>
<span className="text-primary/60">{match.paneId}</span>
</span>
<span className="truncate font-mono text-muted-foreground">
{highlightMatch(match.text, query)}
</span>
</div>
))}
</div>
);
}
plugins/tmux-monitor/src/frontend/SessionTree.tsx
+473
View File
@@ -0,0 +1,473 @@
// Session/window/pane tree styled after the VSCode "tmux manager" view.
// Each session is a single row: status dot, name, inline tag badges, and a
// right-aligned meta label (relative time, cpu, mem) that is overlaid by
// the hover actions (attach, new window, …-menu). The overlay uses a grid
// stack with opacity so rows never shift and the actions stay reachable via
// keyboard focus.
import { useState } from "react";
import { useTranslation } from "@termix/plugin-sdk/frontend";
import {
AppWindow,
BarChart2,
ChevronDown,
ChevronRight,
MoreHorizontal,
Pencil,
Play,
Plus,
SquareSplitHorizontal,
SquareSplitVertical,
SquareTerminal,
Tag,
Trash2,
X,
} from "lucide-react";
import {
Badge,
DropdownMenu,
DropdownMenuContent,
DropdownMenuItem,
DropdownMenuTrigger,
Popover,
PopoverContent,
PopoverTrigger,
} from "@termix/plugin-sdk/ui";
import type { TmuxPaneMetrics, TmuxSessionOverview } from "./api";
import { formatMem, formatRelativeTime } from "./format";
import type { SelectedPane } from "./types";
export interface SessionMetricsAgg {
cpu: number;
memKb: number;
gpuMb: number;
}
const MAX_INLINE_TAGS = 2;
interface SessionTreeProps {
sessions: TmuxSessionOverview[];
expandedSessions: Set<string>;
onToggleSession: (name: string) => void;
selectedPaneId: string | null;
onSelectPane: (pane: SelectedPane) => void;
metricsByPane: Map<string, TmuxPaneMetrics>;
metricsBySession: Map<string, SessionMetricsAgg>;
/** Open the tag editor for a session (… menu). */
onEditTags: (sessionName: string) => void;
/** Open a terminal attached to the session (the ▷ hover action). */
onAttachSession: (sessionName: string) => void;
onSelectSession?: (sessionName: string) => void;
/** Create a new window in the session (the + hover action). */
onNewWindow: (sessionName: string) => void;
/** Open the rename dialog for a session (… menu). */
onRenameSession: (sessionName: string) => void;
/** Open the kill confirmation for a session (… menu). */
onKillSession: (sessionName: string) => void;
/** Open the kill confirmation for a single pane (hover ✕ on pane rows). */
onKillPane: (paneId: string) => void;
/** Split the window containing a pane (hover actions on pane rows). */
onSplitPane: (paneId: string, direction: "h" | "v") => void;
/** Open the kill confirmation for a window (hover ✕ on window rows). */
onKillWindow: (sessionName: string, windowIndex: number) => void;
/** Narrow tree panel: the inline time/cpu/mem label is hidden (the hover
* tooltip still carries the full status). */
compact: boolean;
/** Timestamp used to render relative times; bumped periodically by the
* parent so "Xm ago" labels do not go stale. */
now: number;
}
export function SessionTree({
sessions,
expandedSessions,
onToggleSession,
selectedPaneId,
onSelectPane,
metricsByPane,
metricsBySession,
onEditTags,
onAttachSession,
onSelectSession,
onNewWindow,
onRenameSession,
onKillSession,
onKillPane,
onSplitPane,
onKillWindow,
compact,
now,
}: SessionTreeProps) {
const { t } = useTranslation();
// Collapsed windows, keyed "session windowIndex". Windows default to
// expanded (panes visible) like the VSCode tmux manager.
const [collapsedWindows, setCollapsedWindows] = useState<Set<string>>(
new Set(),
);
function windowKey(sessionName: string, windowIndex: number): string {
return `${sessionName} ${windowIndex}`;
}
function toggleWindow(sessionName: string, windowIndex: number) {
setCollapsedWindows((prev) => {
const next = new Set(prev);
const key = windowKey(sessionName, windowIndex);
if (next.has(key)) next.delete(key);
else next.add(key);
return next;
});
}
function metaLabel(session: TmuxSessionOverview) {
const time = formatRelativeTime(session.lastActivity, now, t);
const agg = metricsBySession.get(session.name);
if (!agg) return time;
return (
<span className="flex gap-2">
<span>{time}</span>
<span>{agg.cpu.toFixed(0)}%</span>
<span>{formatMem(agg.memKb)}</span>
</span>
);
}
return (
<>
{sessions.map((session) => {
const expanded = expandedSessions.has(session.name);
const agg = metricsBySession.get(session.name);
const paneCount = session.windows.reduce(
(sum, w) => sum + w.panes.length,
0,
);
return (
<div key={session.name} className="mb-0.5">
<div
className="group flex cursor-pointer items-center gap-1.5 px-2 py-1 hover:bg-muted/40"
onClick={() =>
onSelectSession
? onSelectSession(session.name)
: onToggleSession(session.name)
}
>
<button
aria-label={t("tmuxMonitor.toggleSession", {
session: session.name,
})}
aria-expanded={expanded}
onClick={(event) => {
event.stopPropagation();
onToggleSession(session.name);
}}
>
{expanded ? (
<ChevronDown className="size-3.5 shrink-0" />
) : (
<ChevronRight className="size-3.5 shrink-0" />
)}
</button>
<span
className={`size-2 shrink-0 rounded-full ${session.attachedClients > 0 ? "bg-accent-brand" : "bg-muted-foreground/40"}`}
title={
session.attachedClients > 0
? t("tmuxMonitor.attached")
: t("tmuxMonitor.detached")
}
/>
<span className="truncate text-sm font-medium">
{session.name}
</span>
{session.tags.slice(0, MAX_INLINE_TAGS).map((tag) => (
<Badge
key={tag}
variant="secondary"
className="h-4 shrink-0 px-1.5 text-[10px]"
>
{tag}
</Badge>
))}
{session.tags.length > MAX_INLINE_TAGS && (
<Badge
variant="secondary"
className="h-4 shrink-0 px-1.5 text-[10px]"
title={session.tags.join(", ")}
>
+{session.tags.length - MAX_INLINE_TAGS}
</Badge>
)}
{/* Meta label and hover actions stacked in one grid cell */}
<span className="ml-auto grid shrink-0">
{!compact && (
<span className="pointer-events-none col-start-1 row-start-1 justify-self-end self-center text-xs text-muted-foreground transition-opacity group-hover:opacity-0 group-focus-within:opacity-0">
{metaLabel(session)}
</span>
)}
<span className="pointer-events-none z-10 col-start-1 row-start-1 flex items-center gap-1.5 justify-self-end opacity-0 transition-opacity group-focus-within:pointer-events-auto group-focus-within:opacity-100 group-hover:pointer-events-auto group-hover:opacity-100">
<button
className="-m-1 p-1 text-muted-foreground hover:text-foreground"
title={t("tmuxMonitor.attachSessionTooltip", {
session: session.name,
})}
aria-label={t("tmuxMonitor.attachSessionTooltip", {
session: session.name,
})}
onClick={(e) => {
e.stopPropagation();
onAttachSession(session.name);
}}
>
<Play className="size-3.5" />
</button>
<button
className="-m-1 p-1 text-muted-foreground hover:text-foreground"
title={t("tmuxMonitor.newWindow")}
aria-label={t("tmuxMonitor.newWindow")}
onClick={(e) => {
e.stopPropagation();
onNewWindow(session.name);
}}
>
<Plus className="size-3.5" />
</button>
<Popover>
<PopoverTrigger asChild>
<button
className="-m-1 p-1 text-muted-foreground hover:text-foreground data-[state=open]:text-foreground"
title={t("tmuxMonitor.sessionStats")}
aria-label={t("tmuxMonitor.sessionStats")}
onClick={(e) => e.stopPropagation()}
>
<BarChart2 className="size-3.5" />
</button>
</PopoverTrigger>
<PopoverContent
side="right"
align="start"
sideOffset={8}
className="w-56 rounded-none border border-border p-0 shadow-md"
onClick={(e) => e.stopPropagation()}
>
<div className="w-full px-3 py-2">
<div className="mb-1 flex items-center gap-1.5">
<span
className={`size-2 rounded-full ${session.attachedClients > 0 ? "bg-accent-brand" : "bg-muted-foreground/40"}`}
/>
<span className="text-xs font-semibold">
{session.name}
</span>
<span className="ml-auto text-[10px] text-muted-foreground">
{session.attachedClients > 0
? t("tmuxMonitor.attached")
: t("tmuxMonitor.detached")}
</span>
</div>
<dl className="grid grid-cols-[auto_1fr] gap-x-3 gap-y-0.5 text-[11px]">
<dt className="text-muted-foreground">
{t("tmuxMonitor.statusActivity")}
</dt>
<dd className="text-right">
{formatRelativeTime(session.lastActivity, now, t)}
</dd>
<dt className="text-muted-foreground">
{t("tmuxMonitor.statusWindows")}
</dt>
<dd className="text-right">
{session.windows.length} / {paneCount}{" "}
{t("tmuxMonitor.statusPanes")}
</dd>
<dt className="text-muted-foreground">CPU</dt>
<dd className="text-right">
{agg ? `${agg.cpu.toFixed(1)}%` : "—"}
</dd>
<dt className="text-muted-foreground">RAM</dt>
<dd className="text-right">
{agg ? formatMem(agg.memKb) : "—"}
</dd>
{agg && agg.gpuMb > 0 && (
<>
<dt className="text-muted-foreground">GPU</dt>
<dd className="text-right">{agg.gpuMb} MB</dd>
</>
)}
{session.tags.length > 0 && (
<>
<dt className="text-muted-foreground">
{t("tmuxMonitor.statusTags")}
</dt>
<dd className="truncate text-right">
{session.tags.join(", ")}
</dd>
</>
)}
</dl>
</div>
</PopoverContent>
</Popover>
<DropdownMenu>
<DropdownMenuTrigger asChild>
<button
className="-m-1 p-1 text-muted-foreground hover:text-foreground data-[state=open]:text-foreground"
title={t("tmuxMonitor.moreActions")}
aria-label={t("tmuxMonitor.moreActions")}
onClick={(e) => e.stopPropagation()}
>
<MoreHorizontal className="size-3.5" />
</button>
</DropdownMenuTrigger>
<DropdownMenuContent
align="end"
className="min-w-36"
onClick={(e) => e.stopPropagation()}
>
<DropdownMenuItem
className="whitespace-nowrap"
onSelect={() =>
setTimeout(() => onRenameSession(session.name), 0)
}
>
<Pencil className="size-3.5" />
{t("tmuxMonitor.rename")}
</DropdownMenuItem>
<DropdownMenuItem
className="whitespace-nowrap"
onSelect={() =>
setTimeout(() => onEditTags(session.name), 0)
}
>
<Tag className="size-3.5" />
{t("tmuxMonitor.editTags")}
</DropdownMenuItem>
<DropdownMenuItem
variant="destructive"
className="whitespace-nowrap"
onSelect={() =>
setTimeout(() => onKillSession(session.name), 0)
}
>
<Trash2 className="size-3.5" />
{t("tmuxMonitor.kill")}
</DropdownMenuItem>
</DropdownMenuContent>
</DropdownMenu>
</span>
</span>
</div>
{expanded &&
session.windows.map((win) => {
const winCollapsed = collapsedWindows.has(
windowKey(session.name, win.index),
);
return (
<div key={win.index} className="ml-4">
<div
className="group flex cursor-pointer items-center gap-1 px-2 py-0.5 text-xs text-muted-foreground hover:bg-muted/40"
onClick={() => toggleWindow(session.name, win.index)}
>
{winCollapsed ? (
<ChevronRight className="size-3 shrink-0" />
) : (
<ChevronDown className="size-3 shrink-0" />
)}
<AppWindow className="size-3 shrink-0" />
<span className="truncate">
{win.index}: {win.name}
</span>
<button
className="-m-1 ml-auto shrink-0 p-1 text-muted-foreground opacity-0 transition-opacity hover:text-destructive focus-visible:opacity-100 group-hover:opacity-100"
title={t("tmuxMonitor.killWindow")}
aria-label={t("tmuxMonitor.killWindow")}
onClick={(e) => {
e.stopPropagation();
onKillWindow(session.name, win.index);
}}
>
<X className="size-3" />
</button>
</div>
{!winCollapsed &&
win.panes.map((pane) => {
const m = metricsByPane.get(pane.id);
const isSelected = selectedPaneId === pane.id;
return (
<div
key={pane.id}
className={`group ml-5 flex cursor-pointer items-center gap-1.5 px-2 py-1 text-xs hover:bg-muted/40 ${isSelected ? "bg-accent-brand/10" : ""}`}
onClick={() =>
onSelectPane({
paneId: pane.id,
sessionName: session.name,
windowIndex: win.index,
})
}
>
<SquareTerminal className="size-3 shrink-0" />
<span className="truncate">
{pane.index}: {pane.command}
</span>
<span
className="min-w-0 flex-1 truncate text-muted-foreground/70"
title={pane.path}
>
{pane.path}
</span>
{/* Same overlay stack as the session rows: cpu
label and hover actions share one grid cell so the
buttons never widen the row (they would get
clipped on a narrow panel). */}
<span className="ml-auto grid shrink-0">
{m && m.cpuPercent > 0 && (
<span className="pointer-events-none col-start-1 row-start-1 justify-self-end self-center text-[10px] text-muted-foreground transition-opacity group-hover:opacity-0 group-focus-within:opacity-0">
{m.cpuPercent.toFixed(0)}%
</span>
)}
<span className="pointer-events-none z-10 col-start-1 row-start-1 flex items-center gap-1 justify-self-end opacity-0 transition-opacity group-focus-within:pointer-events-auto group-focus-within:opacity-100 group-hover:pointer-events-auto group-hover:opacity-100">
<button
className="-m-1 p-1 text-muted-foreground hover:text-foreground"
title={t("tmuxMonitor.splitRight")}
aria-label={t("tmuxMonitor.splitRight")}
onClick={(e) => {
e.stopPropagation();
onSplitPane(pane.id, "h");
}}
>
<SquareSplitHorizontal className="size-3" />
</button>
<button
className="-m-1 p-1 text-muted-foreground hover:text-foreground"
title={t("tmuxMonitor.splitDown")}
aria-label={t("tmuxMonitor.splitDown")}
onClick={(e) => {
e.stopPropagation();
onSplitPane(pane.id, "v");
}}
>
<SquareSplitVertical className="size-3" />
</button>
<button
className="-m-1 p-1 text-muted-foreground hover:text-destructive"
title={t("tmuxMonitor.killPane")}
aria-label={t("tmuxMonitor.killPane")}
onClick={(e) => {
e.stopPropagation();
onKillPane(pane.id);
}}
>
<X className="size-3" />
</button>
</span>
</span>
</div>
);
})}
</div>
);
})}
</div>
);
})}
</>
);
}
plugins/tmux-monitor/src/frontend/TmuxMonitor.tsx
+1687
View File
File diff suppressed because it is too large. Load diff
plugins/tmux-monitor/src/frontend/TmuxMonitorApp.tsx
+16
View File
@@ -0,0 +1,16 @@
import type { StandaloneViewProps } from "@termix/plugin-sdk/frontend";
import { TmuxMonitor } from "./TmuxMonitor";
/** `?view=tmux_monitor` full-screen links. */
function TmuxMonitorApp({ hostId }: StandaloneViewProps) {
const parsed = hostId ? parseInt(hostId, 10) : NaN;
return (
<div className="h-screen w-screen overflow-hidden">
<TmuxMonitor
initialHostId={Number.isFinite(parsed) ? parsed : undefined}
/>
</div>
);
}
export default TmuxMonitorApp;
plugins/tmux-monitor/src/frontend/api.ts
+185
View File
@@ -0,0 +1,185 @@
import type { PluginApiClient } from "@termix/plugin-sdk/frontend";
let client: PluginApiClient | null = null;
/** Set from activate with app.api, cleared on deactivate. */
export function setTmuxMonitorApi(api: PluginApiClient | null): void {
client = api;
}
function api(): PluginApiClient {
if (!client) throw new Error("The Tmux Monitor plugin is not active");
return client;
}
export interface TmuxPane {
id: string;
index: number;
pid: number;
active: boolean;
width: number;
height: number;
command: string;
path: string;
title: string;
}
export interface TmuxWindow {
index: number;
name: string;
active: boolean;
panes: TmuxPane[];
}
export interface TmuxSessionOverview {
name: string;
created: number;
lastActivity: number;
attachedClients: number;
windows: TmuxWindow[];
tags: string[];
}
export interface TmuxOverview {
available: boolean;
sessions: TmuxSessionOverview[];
}
export interface TmuxSearchMatch {
paneId: string;
sessionName: string;
windowIndex: number;
line: number;
text: string;
}
export interface TmuxPaneMetrics {
paneId: string;
sessionName: string;
pid: number;
processCount: number;
cpuPercent: number;
memRssKb: number;
gpuMemMb: number;
topCommand: string | null;
}
export async function getTmuxOverview(hostId: number): Promise<TmuxOverview> {
const response = await api().get<TmuxOverview>(`/${hostId}/overview`);
return response.data;
}
/** Select a pane's window+pane on the server so the attached terminal
* (and any other attached client) switches to it. */
export async function focusTmuxPane(
hostId: number,
paneId: string,
): Promise<void> {
await api().post(`/${hostId}/focus`, { paneId });
}
/** Create a new detached session on the host. Starts the tmux server if
* none is running yet. */
export async function createTmuxSession(
hostId: number,
name: string,
): Promise<void> {
await api().post(`/${hostId}/sessions`, { name });
}
/** Create a new window in an existing session. */
export async function createTmuxWindow(
hostId: number,
sessionName: string,
): Promise<void> {
await api().post(`/${hostId}/windows`, { sessionName });
}
/** Rename a session. Saved tags follow the session to its new name. */
export async function renameTmuxSession(
hostId: number,
sessionName: string,
newName: string,
): Promise<void> {
await api().post(`/${hostId}/rename`, { sessionName, newName });
}
/** Kill a session (terminates all of its windows and processes). */
export async function killTmuxSession(
hostId: number,
sessionName: string,
): Promise<void> {
await api().post(`/${hostId}/kill`, { sessionName });
}
/** Kill a window and every pane in it. */
export async function killTmuxWindow(
hostId: number,
sessionName: string,
windowIndex: number,
): Promise<void> {
await api().post(`/${hostId}/kill-window`, { sessionName, windowIndex });
}
/** Kill a single pane (last pane of a window closes the window). */
export async function killTmuxPane(
hostId: number,
paneId: string,
): Promise<void> {
await api().post(`/${hostId}/kill-pane`, { paneId });
}
/** Split the window containing a pane: "h" adds a pane to the right,
* "v" below (tmux -h/-v semantics). */
export async function splitTmuxPane(
hostId: number,
paneId: string,
direction: "h" | "v",
): Promise<void> {
await api().post(`/${hostId}/split`, { paneId, direction });
}
export interface TmuxSearchResult {
matches: TmuxSearchMatch[];
/** True when a search limit was hit and the results are partial. */
truncated: boolean;
searchedLines: number;
maxPanes: number;
}
export async function searchTmux(
hostId: number,
query: string,
): Promise<TmuxSearchResult> {
const response = await api().get<Partial<TmuxSearchResult>>(
`/${hostId}/search`,
{ params: { q: query } },
);
return {
matches: response.data.matches ?? [],
truncated: response.data.truncated ?? false,
searchedLines: response.data.searchedLines ?? 0,
maxPanes: response.data.maxPanes ?? 0,
};
}
export async function getTmuxMetrics(
hostId: number,
): Promise<TmuxPaneMetrics[]> {
const response = await api().get<{ panes?: TmuxPaneMetrics[] }>(
`/${hostId}/metrics`,
);
return response.data.panes ?? [];
}
export async function setTmuxSessionTags(
hostId: number,
sessionName: string,
tags: string[],
): Promise<string[]> {
const response = await api().put<{ tags?: string[] }>(`/${hostId}/tags`, {
sessionName,
tags,
});
return response.data.tags ?? [];
}
plugins/tmux-monitor/src/frontend/format.ts
+22
View File
@@ -0,0 +1,22 @@
import type { TranslateFn } from "@termix/plugin-sdk/frontend";
export function formatRelativeTime(
unixSeconds: number,
nowMs: number,
t: TranslateFn,
): string {
if (!unixSeconds) return "";
const diff = Math.max(0, nowMs / 1000 - unixSeconds);
if (diff < 60) return t("tmuxMonitor.timeJustNow");
if (diff < 3600)
return t("tmuxMonitor.timeMinutes", { count: Math.floor(diff / 60) });
if (diff < 86400)
return t("tmuxMonitor.timeHours", { count: Math.floor(diff / 3600) });
return t("tmuxMonitor.timeDays", { count: Math.floor(diff / 86400) });
}
export function formatMem(kb: number): string {
if (kb >= 1024 * 1024) return `${(kb / 1024 / 1024).toFixed(1)} GB`;
if (kb >= 1024) return `${(kb / 1024).toFixed(0)} MB`;
return `${kb} KB`;
}
plugins/tmux-monitor/src/frontend/host-tmux-monitor.ts
+12
View File
@@ -0,0 +1,12 @@
import type { PluginHostRecord } from "@termix/plugin-sdk/frontend";
/** Whether the monitor is enabled for this host, as the host payload's
* pluginSettings carries it. */
export function tmuxMonitorEnabled(
host: PluginHostRecord | null | undefined,
): boolean {
const settings = (
host?.pluginSettings as Record<string, Record<string, unknown>> | undefined
)?.["tmux-monitor"];
return settings?.enableTmuxMonitor === true;
}
plugins/tmux-monitor/src/frontend/index.tsx
+69
View File
@@ -0,0 +1,69 @@
import { Layers } from "lucide-react";
import type {
StandaloneViewProps,
TabProps,
TermixApp,
} from "@termix/plugin-sdk/frontend";
import { setTmuxMonitorApi } from "./api";
import { tmuxMonitorEnabled } from "./host-tmux-monitor";
import { HostTmuxMonitorSection } from "./HostTmuxMonitorSection";
import { TmuxMonitor } from "./TmuxMonitor";
import TmuxMonitorApp from "./TmuxMonitorApp";
const VIEW_ID = "tmux_monitor";
function TmuxMonitorTab({ tab, isVisible }: TabProps) {
const hostId = (tab.data?.hostId as number | undefined) ?? undefined;
return (
<TmuxMonitor
initialHostId={hostId}
initialHostRequest={tab.data?.hostRequest as number | undefined}
isVisible={isVisible}
/>
);
}
function TmuxMonitorStandalone(props: StandaloneViewProps) {
return <TmuxMonitorApp {...props} />;
}
export function activate(app: TermixApp): void {
setTmuxMonitorApi(app.api);
app.onDispose(() => setTmuxMonitorApi(null));
// A single cross-host browser, like the old core tab: opening it from a
// host row just points the already-open (or newly opened) tab at that host.
app.registerTab(VIEW_ID, TmuxMonitorTab, {
icon: Layers,
titleKey: "nav.tmuxMonitor",
singleton: true,
hostless: true,
persistent: true,
activityTypes: ["tmux_monitor"],
standalone: TmuxMonitorStandalone,
});
app.registerHostAction({
id: "tmux_monitor",
titleKey: "nav.tmuxMonitor",
icon: Layers,
kind: "open",
order: 70,
copyUrlView: VIEW_ID,
when: (host) => !!host.enableSsh && tmuxMonitorEnabled(host),
run: (host, shell) =>
shell.openSingletonTab(VIEW_ID, {
data: { hostId: Number(host.id), hostRequest: Date.now() },
}),
});
app.registerHostEditorSection({
id: "tmux-monitor",
group: "ssh",
titleKey: "hosts.tabTmuxMonitor",
icon: Layers,
order: 45,
defaults: true,
component: HostTmuxMonitorSection,
});
}
plugins/tmux-monitor/src/frontend/monitor-storage.ts
+36
View File
@@ -0,0 +1,36 @@
import type { SelectedPane } from "./types";
const PREFIX = "termix-tmux-monitor-";
export function readMonitorValue<T>(key: string, fallback: T): T {
try {
const value = localStorage.getItem(PREFIX + key);
return value === null ? fallback : JSON.parse(value);
} catch {
return fallback;
}
}
export function saveMonitorValue(key: string, value: unknown): void {
try {
localStorage.setItem(PREFIX + key, JSON.stringify(value));
} catch {
/* unavailable */
}
}
export function readExpanded(hostId: number | string): Set<string> | null {
const value = readMonitorValue<unknown>(`expanded-${hostId}`, null);
return Array.isArray(value)
? new Set(value.filter((v): v is string => typeof v === "string"))
: null;
}
export function readSelectedPane(hostId: number | string): SelectedPane | null {
const value = readMonitorValue<Partial<SelectedPane> | null>(
`pane-${hostId}`,
null,
);
return value &&
typeof value.paneId === "string" &&
typeof value.sessionName === "string" &&
Number.isInteger(value.windowIndex)
? (value as SelectedPane)
: null;
}
plugins/tmux-monitor/src/frontend/poll-queue.ts
+19
View File
@@ -0,0 +1,19 @@
/** Bound background SSH polling when the unified view contains many hosts. */
export function createPollQueue(limit: number) {
let running = 0;
const waiting: Array<() => void> = [];
return async function run<T>(task: () => Promise<T>): Promise<T> {
if (running >= limit)
await new Promise<void>((resolve) => waiting.push(resolve));
else running++;
try {
return await task();
} finally {
const next = waiting.shift();
if (next) next();
else running--;
}
};
}
export const pollBackgroundHost = createPollQueue(4);
plugins/tmux-monitor/src/frontend/types.ts
+5
View File
@@ -0,0 +1,5 @@
export interface SelectedPane {
paneId: string;
sessionName: string;
windowIndex: number;
}
plugins/tmux-monitor/src/frontend/use-adaptive-polling.ts
+63
View File
@@ -0,0 +1,63 @@
import { useEffect, useRef } from "react";
import { runAdaptivePolling } from "@termix/plugin-sdk/ui";
type AdaptivePollResult = boolean | void;
interface AdaptivePollingPolicy {
minIntervalMs: number;
maxIntervalMs: number;
stablePollsPerStep?: number;
jitterRatio?: number;
maxRequestDutyCycle?: number;
}
export function useAdaptivePolling(
poll: () => AdaptivePollResult | Promise<AdaptivePollResult>,
policy: AdaptivePollingPolicy,
enabled = true,
options: {
runImmediately?: boolean;
onError?: (error: unknown) => void;
} = {},
): void {
const pollRef = useRef(poll);
const errorRef = useRef(options.onError);
pollRef.current = poll;
errorRef.current = options.onError;
const {
minIntervalMs,
maxIntervalMs,
stablePollsPerStep,
jitterRatio,
maxRequestDutyCycle,
} = policy;
const runImmediately = options.runImmediately;
useEffect(
() =>
runAdaptivePolling(
() => pollRef.current(),
{
minIntervalMs,
maxIntervalMs,
stablePollsPerStep,
jitterRatio,
maxRequestDutyCycle,
},
{
enabled: () => enabled,
runImmediately,
onError: (error) => errorRef.current?.(error),
},
),
[
enabled,
jitterRatio,
maxIntervalMs,
minIntervalMs,
runImmediately,
stablePollsPerStep,
maxRequestDutyCycle,
],
);
}