@hanskristoffer/agentpool 0.23.0 → 0.25.0

package/README.md

@@ -74,6 +74,15 @@ An Infisical login expires after a few days and can't be renewed, so you have to
 
 To control the server from the native app over Tailscale, open the connection settings at the bottom of the sidebar, enter `http://srv.<tailnet>.ts.net:7878`, and paste the token printed by `agentgate admin-token` on the server. Remote management uses bearer authentication over Tailscale. The relay carries sync only, not remote management.
 
+## Machine dashboard
+
+Each machine can show its own health: CPU, load, memory, disk, time spent waiting for CPU, memory or disk, disk and network traffic, the agents and CI runners it is running, Docker's disk use and containers, the programs using the most CPU, and the last hour as charts. In **Machines**, turn on **Dashboard** for a machine, then **Open dashboard** opens it in your browser. The page is `/health` on the machine's address, and `agentgate dashboard on|off [--node <node>]` switches it from the CLI.
+
+- It runs on Linux machines only, since it reads `/proc`. On a Mac, opening it only says so.
+- Anyone on your tailnet can open it without signing in, as they could the server health page before. It shows program names and resource use, never command lines, credentials or accounts. Turn it off on machines you don't want it on.
+- Turning it on waits until every machine runs this release, because older releases drop the setting when they save a machine's record.
+- The history is kept in memory for the last hour, so a restart starts the charts over.
+
 ## T3 Code
 
 `agentgate setup` writes a Claude config dir (whose `settings.json` points Claude Code at the daemon) and a Codex home. In T3 Code, add one provider instance per provider:
@@ -93,7 +102,7 @@ One instance per provider covers every account; the daemon switches eligible acc
 
 ### Hand threads between machines
 
-Start a thread on your laptop, hand it to an always-on server while you are away, and hand it back to test and push. A handed-off thread moves with its Claude session and its code: unpushed commits and uncommitted and untracked files (respecting `.gitignore`), plus your changes to the repository's [env files](#env-files-between-machines). Code travels directly between the two machines over Tailscale, or end-to-end encrypted through the relay; nothing is pushed to `origin`.
+Start a thread on your laptop, hand it to an always-on server while you are away, and hand it back to test and push. A handed-off thread moves with its Claude session and its code: unpushed commits and uncommitted, untracked and gitignored files, such as plans in `.plans`. Dependency and build folders such as `node_modules`, `.venv`, `target` and `dist` stay behind, and the other machine's setup script makes them again. [Env files](#env-files-between-machines) the repository saves for every machine travel through their own store instead, so each machine keeps its own. Code travels directly between the two machines over Tailscale, or end-to-end encrypted through the relay; nothing is pushed to `origin`.
 
 Connect agentgate to the T3 Code on each machine once: on the T3 Code page open **Machines** and choose **Connect T3 Code** in that machine's row, or run `agentgate t3 connect` there (`--node srv` sets up another machine from the one you are on). T3 Code must be running on that machine; its own `t3` command creates a pairing link that agentgate redeems right away, over that machine only. Pair again the same way when agentgate asks. If that machine has no `t3` command, create a link in T3 Code under **Settings → Connections** (turn on **Network access**, then **Create link** with **Standard** permissions) and paste it into **Connect with a pasted link**, or run `agentgate t3 connect <link>`. The machines must be paired over Tailscale or in the same relay group. A handoff moves the session between the Claude homes T3 Code's Claude provider uses on each machine, whether that is `~/.claude` or the agentgate home above.
 
@@ -110,9 +119,10 @@ In the app, the **T3 Code** page shows every machine's threads with **To server*
 
 What to expect:
 
-- A working thread is stopped, moved, and continued on the other machine. On the source it is archived, and the uncommitted changes that were sent are kept in a `git stash` so the worktree is clean for the return trip. That stash is dropped when the thread comes back, because its changes come back with it.
+- A working thread is stopped, moved, and continued on the other machine. On the source it is archived, and the uncommitted changes that were sent are kept in a `git stash` so the worktree is clean for the return trip. That stash is dropped when the thread comes back, because its changes come back with it. Gitignored files stay where they are, and the versions that come back replace them.
 - The other machine reuses a worktree already on the thread's branch, or creates one and runs the project's setup script. Later trips reuse it, so setup runs once per branch and machine.
 - If the other machine's checkout has its own changes or commits, it keeps them and the handoff reports a warning. Your uncommitted changes then stay where they were.
+- If the other machine has its own version of a gitignored file the thread brings, such as a plan edited there, that version goes to a `git stash` there and the handoff reports a warning.
 - The first time a thread arrives on a machine, T3 Code fails the first message sent to it there. agentgate sends that message for you, asking the agent to reply "Ready", and sends it again when it fails, so your own first message works. A thread that was working then gets "Continue where you left off.", and messages you had queued are queued again behind it, in order. Background tasks such as a command watching a PR are stopped on the machine the thread leaves, and the agent is told which ones were running so it can start them again. Later trips to the same machine reuse the thread and skip this.
 - A thread that comes back to a machine shows the messages it got on your other machines in the meantime. T3 Code cannot add them to a thread itself, so agentgate writes them into T3 Code's own database, which T3 Code does not support. If T3 Code misbehaves after a handoff, turn this off with `agentgate t3 history off` or **Show messages from other machines** on the T3 Code page: the thread then shows only what happened on that machine, and the agent still has the whole conversation. Threads that left a machine before this release come back without them.
 - The first time a thread arrives on a machine, T3 Code's import also picks up other recent Claude sessions run in that project's main checkout, so threads that ran there can show up twice. Threads in worktrees are not affected, and later trips skip the import.
@@ -213,7 +223,7 @@ Unlike sync, this traffic is readable by the relay (your logins stay on your mac
 
 ## Commands
 
-Run `agentgate --help`. Useful ones: `status`, `accounts`, `accounts exhaust <id> [min]` (pretend an account hit its limit, for testing), `nodes`, `unpair <node>`, `relay status|reconcile|rotate|leave`, `export [--no-secrets]`, `import-backup <file>`, `service logs`.
+Run `agentgate --help`. Useful ones: `status`, `accounts`, `accounts exhaust <id> [min]` (pretend an account hit its limit, for testing), `nodes`, `dashboard on|off`, `unpair <node>`, `relay status|reconcile|rotate|leave`, `export [--no-secrets]`, `import-backup <file>`, `service logs`.
 
 ## Things to know
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hanskristoffer/agentpool",
-  "version": "0.23.0",
+  "version": "0.25.0",
   "license": "UNLICENSED",
   "repository": {
     "type": "git",
@@ -22,9 +22,9 @@
     "agentgate": "bin/agentpool.js"
   },
   "optionalDependencies": {
-    "agentpool-darwin-arm64": "0.23.0",
-    "agentpool-darwin-x64": "0.23.0",
-    "agentpool-linux-x64": "0.23.0",
-    "agentpool-linux-arm64": "0.23.0"
+    "agentpool-darwin-arm64": "0.25.0",
+    "agentpool-darwin-x64": "0.25.0",
+    "agentpool-linux-x64": "0.25.0",
+    "agentpool-linux-arm64": "0.25.0"
   }
 }