@hanskristoffer/agentpool 0.18.0 → 0.19.0

package/README.md

@@ -68,6 +68,8 @@ The server now has every account, MCP instance and repo mapping, and takes over
 
 To sign every machine in to GitHub and Infisical as you, run `agentgate logins share` on the machine where you are signed in, or use **Share** under **Shared logins** on the Machines screen. It shares the `gh` login for github.com and the Infisical CLI login, skipping either one this machine doesn't use. Every paired machine, including servers that join later, then runs `gh auth login` and `gh auth setup-git` with that token (so `gh` must be installed there) and gets the same Infisical session. The machine that shared re-reads its logins every ten minutes, so if you log in again there, the others follow. Infisical must keep its login in a file: if it uses the system keychain, run `infisical vault set file` and `infisical login` first. `agentgate logins` and the Machines screen show whether this machine is signed in with each login, and `agentgate logins forget github|infisical` stops sharing; machines already signed in stay signed in.
 
+An Infisical login expires after a few days and can't be renewed, so you have to log in again. For tools that run on their own, such as servers, set an Infisical machine identity once instead: create one with Universal Auth in Infisical and give it access to your projects, then choose **Set** next to **Infisical machine identity** under **Shared logins**, or run `agentgate logins identity --client-id <id>` (it asks for the secret; `--site` defaults to the Infisical instance your CLI uses). agentgate checks it with Infisical and writes it to `~/.infisical/universal-auth.json` on every machine, including servers that join later. hanzio uses that file when a process has no `INFISICAL_CLIENT_ID` and `INFISICAL_CLIENT_SECRET`. `agentgate logins forget infisical-identity` removes it from every machine.
+
 **The relay invite never expires and is a master key.** Anyone who has it can read every account and MCP login, so share it privately. If it leaks, run `agentgate relay rotate` and have every relay machine join again with the new command. Removing a relay machine (`agentgate unpair <node>` or **Remove** in the app) rotates the same way. A rotation can't revoke Tailscale links, so also unpair the removed machine on every machine you keep. By default it uses the hosted relay at `https://agentgate-relay.hanskristoffer.dk`. To use your own instead, deploy `apps/relay` to your Cloudflare account (see [the relay](docs/operations/relay.md#deploying-and-self-hosting)) and pass `--relay-url`, or set `AGENTGATE_RELAY_URL`. `agentgate relay status` shows sync state and errors.
 
 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.
@@ -87,13 +89,15 @@ One instance per provider covers every account; the daemon switches eligible acc
 
 ### Or: your normal Claude login
 
-`agentgate setup --primary` adds `ANTHROPIC_BASE_URL` to `~/.claude/settings.json` and the agentgate MCP server to `~/.claude.json`, so the Claude Code you already use (and T3's default Claude instance) goes through agentgate while keeping its own login. Claude Desktop is not affected: it sets its own API address; see [Claude Desktop](docs/user/claude-desktop.md). For only the MCP servers, use `agentgate setup --mcp`. That, and `setup --primary`, also write `~/.cursor/mcp.json`, so Cursor and the Cursor CLI get the same servers. Start a new session to pick them up. Model requests use the pool; other requests keep your login, and your login is also the last resort when every pooled account is exhausted. Undo with `agentgate setup --primary off` (the previous base URL is restored, and later settings edits are preserved). It does the same for `~/.codex/config.toml` (or `$CODEX_HOME`): an `agentgate` model provider with `requires_openai_auth = true`, so Codex, the Codex app and T3's default Codex instance send their own ChatGPT login along as the last resort. Only do this with `agentgate service install`, or Claude Code and Codex can't reach their providers while the daemon is down.
+`agentgate setup --primary` adds `ANTHROPIC_BASE_URL` to `~/.claude/settings.json` and the agentgate MCP server to `~/.claude.json`, so the Claude Code you already use (and T3's default Claude instance) goes through agentgate while keeping its own login. Where Claude Code has never been signed in, such as on a new server, it also sets a placeholder `ANTHROPIC_AUTH_TOKEN`, because Claude Code won't start without a login; agentgate signs each request with a pooled account either way. Claude Desktop is not affected: it sets its own API address; see [Claude Desktop](docs/user/claude-desktop.md). For only the MCP servers, use `agentgate setup --mcp`. That, and `setup --primary`, also write `~/.cursor/mcp.json`, so Cursor and the Cursor CLI get the same servers. Start a new session to pick them up. Model requests use the pool; other requests keep your login, and your login is also the last resort when every pooled account is exhausted. Undo with `agentgate setup --primary off` (the previous base URL is restored, and later settings edits are preserved). It does the same for `~/.codex/config.toml` (or `$CODEX_HOME`): an `agentgate` model provider with `requires_openai_auth = true`, so Codex, the Codex app and T3's default Codex instance send their own ChatGPT login along as the last resort. Only do this with `agentgate service install`, or Claude Code and Codex can't reach their providers while the daemon is down.
 
 ### 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`). 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. In T3 Code open **Settings → Connections**, turn on **Network access** (T3 Code only offers pairing links while it is on), then under **Authorized clients** choose **Create link** with **Standard** permissions. Run `agentgate t3 connect <link>` within five minutes, then turn Network access off again if you like; agentgate connects over this machine only (on a headless server, `t3 pair` prints a token: `agentgate t3 connect --url http://127.0.0.1:3773 --token <token>`). The T3 Code page in the app has the same form under **Machines**. You can set up another machine from the one you are on: create the link in that machine's T3 Code, then paste it into its row under **Machines**, or run `agentgate t3 connect <link> --node srv`. The link travels to it over your paired connection, and that machine redeems it with its own T3 Code. 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.
+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.
+
+To connect a T3 Code app to one of your machines, for example a new server, choose **Create pairing link** in its row (or `agentgate t3 pair --node srv`) and open the link in T3 Code under **Settings → Connections**. It works once, for five minutes. **Create pairing link over Tailscale** (`--tailscale`) also makes that machine's T3 Code reachable on your tailnet through Tailscale Serve, which stays set up until you remove it.
 
 ```sh
 agentgate threads                    # active threads on every machine
@@ -110,6 +114,7 @@ What to expect:
 - 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.
 - 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.
 - Through the relay, a handoff can move up to 512 MiB of code and session; the relay sees only encrypted data, its size and timing. Pair over Tailscale for larger repositories.
 - Claude Code threads only. Attachments, including those on queued messages, and earlier turns' diffs stay behind.

package/package.json

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