mirror of
https://github.com/l0ng-ai/tty7.git
synced 2026-11-06 08:15:35 +00:00
worktree-agent-composer
382
Commits
| Author | SHA1 | Message | Date | |
|---|---|---|---|---|
 l0ng-ai
|
faca75dfbb |
refactor: carry a session's source on AgentEvent and tidy the review fixes
The Codex router reads source off the parsed event instead of parsing the hook body again. The command scan reads each real directory once rather than capping depth, labels capitalise through one helper (alias_label no longer slices bytes), the live input rows are set where Covering is decided, and the transcript is opened once per poll. |
||
|
l0ng-ai
|
da0add62e2 |
fix(core): route Codex reports past /new and codex -C, trust agent_settled only once seen
A session /new started goes to the Codex pane that had one; a report from a directory no pane runs Codex in is matched among every Codex pane instead of falling back to the app-server's. The Pi bridge no longer reads a returned function from on() as proof agent_settled will come, and the Stop hook re-reads the transcript only once it has grown. |
||
|
l0ng-ai
|
5fb15da5ef |
style(core): settle the clippy warnings the interrupt-key reader brought in
`is_interrupt_key` is only asked by the tests since the Grok Build change
went through `interrupts`, and two `let … else { return None }` read the
kitty-protocol key; the first is test-only now and the other two use `?`.
|
||
|
l0ng-ai
|
8479386892 |
test(core): keep the closed-terminal write test from racing other tests' children
`a_terminal_with_its_other_end_gone_fails_the_write_at_once` failed about one run in three alongside the other hook tests (never on its own): its pty came from `openpty`, whose descriptors are inherited, and the Qoder, CodeBuddy and Crush config tests spawn children on threads of their own. A child that took a copy of the pane's end kept it open after the test closed it, and the write went through. Open both ends close-on-exec from the start, and since a child forked a moment earlier still holds a copy until it gets to exec, retry a write that went through after a short pause; every attempt must still return within the timeout, which is what the test is for. 50 runs of the hook tests in parallel now pass, where 13 of 40 failed before. |
||
|
l0ng-ai
|
fde8a6304e |
fix(core): don't start a turn from a notification's waiting status
Before an agent's first hook, a desktop notification marks its pane
waiting. Crush raises one after every turn ("Agent's turn completed"), and
its only hook, PreToolUse, is reported as a finished tool, which moves a
waiting pane back to working: from the first tool of a session on, the
pane read as working for good, as Crush has no Stop to end it.
A status set by a notification now gives way to idle when the first hook
report arrives, so the report only records the session and its activity.
|
||
|
l0ng-ai
|
cc44269ec6 |
fix(terminal): stop a Grok Build turn with its own interrupt key
Esc in the box covering an agent's input is that agent's Esc, the key that stops a turn. Grok Build's Esc leaves a running turn running — its stop key is Ctrl+C — and the daemon, reading any Esc during a turn as an interrupt, then called the pane done while Grok still worked. The box now sends Grok Build Ctrl+C, and the daemon no longer counts an Esc as stopping a Grok Build turn. |
||
|
l0ng-ai
|
6be9dc9d5c |
fix(core): take Prime Agent's hook reports from its background daemon
Prime Agent runs each session in a detached daemon, started by the first session and outliving it, and the daemon runs tty7's bridge there with the environment of the TUI that asked for the session. The report names the right pane, but its process never runs under that pane's shell, so the daemon turned every one away and a Prime Agent pane never left idle. A report about Prime Agent is now taken by the pane it names when that pane is running Prime Agent. |
||
|
l0ng-ai
|
8db82ab48d |
fix(core): keep Pi and Oh My Pi panes working through retries and approvals
agent_end closes every attempt, so a run Pi retries after a provider error read as done while it was still retrying. The bridge now takes Pi's agent_settled as the end of a run when the build sends it, and Oh My Pi's auto_retry_start puts the pane back to working. Oh My Pi asks before running a tool through tool_approval_requested and tool_approval_resolved, not Pi's UI-prompt pair, so its pane said working while the approval dialog waited. Those now report waiting and restore the turn. |
||
|
l0ng-ai
|
d62c289377 |
fix(core): import Pi's extension types from its current package
Pi moved from @mariozechner/pi-coding-agent to @earendil-works/pi-coding-agent. Current Pi resolves both names for extensions, and the bridge's import is type-only, so it is erased before an older Pi that knows only the old name loads it. A bridge already written with the old name reads as stale and launch's refresh rewrites it. |
||
|
l0ng-ai
|
8597112fe1 |
fix(core): don't let a hook wait on a terminal whose pane has gone
An agent's session-end hook that falls back to the tty after its pane closed opened the terminal device blocking. With the pty's other end gone that open waits for a carrier that never comes, and on macOS it waits holding the lock every lookup under /dev needs: the hook never exits, the agent cannot finish exiting, and every new shell, ps and tty on the machine hangs behind them until the hook is killed. Open the device without waiting, then switch it back to blocking writes so a busy terminal still gets the whole sequence; a terminal with no other end fails the write at once. |
||
|
l0ng-ai
|
2f4d9820ff |
fix(core): show no effort level for a Claude model that takes none
A new Claude session names its model but not its effort level, so the hook fell back to the settings' level - and a session started on Haiku showed "High" until its first turn ended. The hook now checks Claude Code's own model catalog (its cache, read only) first: a model it lists without effort options is reported with an empty level. A model it does not list, or no catalog at all, falls back to the settings as before. |
||
|
l0ng-ai
|
15bcf292b2 |
fix(core): name tty7's Gemini hooks so Gemini shows "tty7" while they run
While a hook runs Gemini CLI shows "Executing Hook: <name>" above its input, and a hook without a name is shown by its whole command - the quoted path of the tty7 binary and its arguments. tty7's Gemini entries now carry "name": "tty7". An install from before reads as outdated - its hooks' names are checked along with their commands - so the launch-time refresh and the settings page's Update rewrite it in place, one entry per event as before. Other agents' entries get no name and are judged as before. |
||
|
l0ng-ai
|
857312c2a0 |
fix(core): install Gemini hooks under GEMINI_CLI_HOME when it is set
Gemini CLI roots its user-level .gemini directory at GEMINI_CLI_HOME in place of the home directory. tty7 always wrote and checked ~/.gemini/settings.json, so for such a user the hooks it installed never ran, and the state it reported described a file Gemini does not read. Local-only, like the other config-dir overrides. |
||
|
l0ng-ai
|
cdc3b47914 |
fix(core): find the pane a Codex hook reports on from the report itself
Codex runs its hooks in its app-server, one background process every Codex session on the machine talks to. The first session starts it, and it outlives that session, detached. Its hooks therefore carry the first session's $TTY7_PANE and run under that pane's shell only while that session lasts. Once it ended, the daemon refused every Codex report as coming from outside the pane -- and the tty fallback has no terminal in a detached process -- so a Codex pane never showed working, waiting or done. While the first session was still running, a second pane's reports were taken as the first pane's. A Codex report is now matched to its pane by what it says: the pane that already reported its session, else the one pane running Codex in its directory (the one yet to report a session, and the named pane on a tie). Other agents' reports are unchanged. |
||
|
l0ng-ai
|
32b9b35b64 |
fix(core): install Codex hooks into CODEX_HOME when it is set
Codex reads hooks.json from its home, which CODEX_HOME moves. tty7 always wrote and checked ~/.codex/hooks.json, so for such a user the hooks it installed never ran, and the state it reported described a file Codex does not read. Local-only, like the other config-dir overrides. |
||
|
l0ng-ai
|
87930859a9 |
fix(core): hand agent hook reports to the daemon over its socket
An agent hook reported by writing an OSC 777 sequence to the tty the agent draws on. A tty write is not atomic: on macOS the kernel parks a writer whenever the output queue is over its high-water mark, which is exactly when the agent is busy redrawing, and lets the other writer in. The agent's output then lands inside our sequence, the OSC breaks, and the rest of the JSON is printed on screen. A pty test with a busy writer next to a small one splits even 100-byte writes, at arbitrary offsets, so no size keeps the sequence whole. The hook now sends the same JSON to the daemon that owns its pane (`$TTY7_PANE`, over the pane socket `$TTY7_CONFIG_DIR` leads to), which applies it exactly as if its reader had found it in the output. The pane id comes from the environment, which a detached tmux server or the like carries out of the pane, so the daemon applies a report only from a process that runs under the pane's shell. Anything else — no daemon, one that predates the message, a refusal — falls back to the tty as before, which is still how a hook with no daemon beside it reports. |
||
|
l0ng-ai
|
8477a6c626 |
fix(core): keep agent hook sequences short
A hook reports to the pane by writing an OSC 777 sequence to the tty the agent draws on. macOS does not keep a tty write whole: under output pressure the kernel parks the writer mid-sequence and lets the other writer in, so the agent's redraw lands inside our sequence, the OSC breaks, and the rest of the JSON is printed on screen. The longer the sequence, the likelier that is. The prompt a turn starts with was the bulk of it on `prompt-submit` (up to 200 characters, three bytes each for CJK), and nothing reads it any more since the conversation outline went away. Stop sending it, and cap the agent's message at a status line's worth. |
||
|
l0ng-ai
|
ae6b83781d |
fix(core): report Claude's model and effort only when they are this turn's
The hook filled in the model from the transcript's last reply on every event. That reply is the previous turn's: after a `/model`, or a resume under another `--model` (a resumed session's SessionStart names none), the toolbar showed the old model — and at `Stop` too, since Claude Code runs the hook before the turn's reply is always on disk. The model now comes from SessionStart, or at Stop from the reply that turn wrote: found after the prompt the payload names, matching the words it carries, waited for briefly. Nothing exact means nothing reported. Effort likewise: the settings fallback only runs for a model the event names (it may be set per model), and a turn that ends without a level ran on a model that takes none, which the toolbar now shows as no level rather than the settings' general one. A level picked from the toolbar gives way to the agent's report once that changes, as a picked model does. |
||
|
l0ng-ai
|
2b3b6ebe2e | refactor(terminal): drop the composer's context gauge until there is an exact source for it | ||
|
l0ng-ai
|
8bf54d2a0f |
Revert "feat(core): send a Claude turn's context size once its transcript catches up"
This reverts commit 3544bc6b172901977749c6d6041650ae3795be37. |
||
|
l0ng-ai
|
7b92ce49be | feat(core): send a Claude turn's context size once its transcript catches up | ||
|
l0ng-ai
|
ecd41efe52 | fix(core): take the effort level Claude reports in the hook payload | ||
|
l0ng-ai
|
74dafeca48 | fix(terminal): show the effort level alone, close toolbar lists on an outside click, read per-model effort | ||
|
l0ng-ai
|
47ee8a53f2 |
feat(terminal): replace the composer's Think toggle with an effort picker
The toolbar's thinking toggle is gone; reasoning effort is what the agent actually exposes as a per-session dial. The button shows the level Claude Code is set to (CLAUDE_CODE_EFFORT_LEVEL, else effortLevel from its settings, reported by the hook) and opens a menu of low / medium / high / xhigh / max. Picking one sends the agent's own /effort command, and the label follows the pick until the next hook event confirms it. |
||
|
l0ng-ai
|
5c92972f11 |
feat(terminal): lay the composer over the agent's own input, with its toolbar
The composer now stands in for the agent's input instead of sitting under it, so the pane has one input rather than two. - For Claude Code, Codex and Gemini the box is laid over the input area it finds on the grid (Claude's ruled prompt block and the status rows under it, Codex's `›` line, Gemini's framed prompt), painted in the grid's background. When the agent puts something else there — a permission prompt, a picker — the area stops reading as an input; after a 250ms grace the box steps aside and the keyboard goes to the TUI, and both come back with the input. Other agents keep the docked layout. - Over the input, Esc is the agent's (it interrupts), Ctrl+C clears the box or reaches the agent when the box is empty, and text typed at the grid lands in the box. - The toolbar: permission mode (read off the status row the box covers, falling back to the hooks' permission_mode; click or Shift+Tab to cycle), model (click opens Claude's picker), Think (Claude's thinking toggle), and a context ring. Labels come only from what the agent reported. - Claude hooks now carry an AgentReadout — permission_mode from the hook payload, the model and context size of the last main-thread reply from the transcript, the context window (1M for a [1m] model or past 200k), and alwaysThinkingEnabled — worked out in the hook so remote panes get it too. - Visual pass against the design: 13.5px text with the design's padding (the input's own padding subtracted), a 40px toolbar of 28px buttons, a dark round send button, image chips with their own glyph. |
||
 
|
c361bd71e8 |
feat(panel): CPU% and memory per process, and a total, in Info → Processes (#1064)
* feat(panel): CPU% and memory per process, and a total, in Info → Processes The daemon adds rss, cpu_ns and a start stamp to each ProcEntry (serde default, so an old daemon or GUI skips them). The GUI turns two CPU-time samples into a ps-style % and sums both into a Total line. `tty7 procs` gains an RSS column. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(panel): no CPU% across a poll gap, and test CPU time is in ns A new poll chain starts after the panel was shut or the pane changed; comparing against the sample from before the gap showed a long-run average as the current figure. Reset the tracker so the first round shows a dash. Replace the self-usage test's cpu_ns > 0 (fails on Linux before the first 10 ms tick, passes unconverted mach ticks) with a check that the process's CPU time covers this thread's own burned CPU time. --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com> Co-authored-by: l0ng-ai <24760907+l0ng-ai@users.noreply.github.com> |
||
|
|
384a329df7 |
feat(terminal): program notifications follow the policy; read kitty OSC 99 (#1062)
* feat(terminal): program notifications follow the policy; read kitty OSC 99
OSC 9/777 notifications used to post from the reader thread regardless of
focus or the Never setting, and clicking one revealed nothing. They now queue
for the view, which applies notify_on_command_finish (Unfocused holds one back
only while its pane is focused in the key window), posts it clickable for the
pane, and titles it with the agent's name when it brings none. A pane whose
agent reports through tty7's hooks skips the copies the hooks already cover.
Kitty's OSC 99 is read too, chunked by i= with d=/p=/e=, in the client and in
the daemon sniffer, so a hookless agent's kitty notification marks it Waiting.
Claude Code's ghostty, kitty and iterm2 Notifications channels all land here;
its default, auto, sends nothing under TERM_PROGRAM=tty7.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* feat(terminal): agent hook notices follow the per-pane rule
An agent's Waiting and Done notices from tty7's hooks were only posted while
the window was in the background, so an agent in another tab of the front
window never reached you. They now share shows_notification with program
notifications: Never posts nothing, When unfocused holds a notice back only
while its pane is focused in the key window, Always always posts. A hooked
pane still skips its program's own copies, so nothing doubles.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* Revert "feat(terminal): agent hook notices follow the per-pane rule"
This reverts commit
|
||
|
|
1d76051959 |
feat(terminal): tell a pane's program when the theme turns light or dark (DEC 2031) (#1061)
* fix(terminal): tell a pane's program when the theme turns light or dark (DEC 2031) Claude Code's `theme: auto` reads OSC 11 at startup and re-reads it only when the terminal sends `CSI ? 997 ; 1|2 n`, which it asks for with `CSI ? 2031 h`. tty7 ignored 2031, so a running Claude kept its light diff colours after a flip to dark. Track 2031 per pane (and across reattach), push a 997 when the theme's background changes, and answer `CSI ? 996 n`. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * feat(terminal): report the colour scheme on reattach; review cleanups for DEC 2031 A pane reattached with 2031 on now hears the current scheme once the replay is folded, so a theme flip while it was detached still reaches the program. report() uses the presets' is_dark, watch reads view.terminal directly, TRACKED lists 2031 inline, and the gpui test moves into view.rs's gpui_tests harness with a reattach case. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * docs(changelog): drop the Unreleased entry; the release notes carry it Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(terminal): one scheme report per reattach, not one per replayed frame A replay is a modes Snapshot plus one Snapshot per ring segment, and each sent its own 997. The Snapshot arm now only folds and flags; the report goes out once, on the first frame after the replay. The tests use the harness's next_input_until_timeout instead of a reader thread, and the reattach test replays two Snapshots. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(terminal): send the reattach scheme report when the replay has been read It went out on the first frame after the replay, so an idle pane, with no live frame coming, never heard it. It is now sent once the reader's buffer drains. TRACKED keeps its one line and names `COLOR_SCHEME_UPDATES` rather than repeating 2031. The reattach test replays Snapshot, Size, Snapshot, Snapshot with nothing after. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(terminal): a shell prompt ends DEC 2031, so a dead program's mode never reports into the shell A program that switched 2031 on and died without `?2031l` left the mode on in the pane's tracked modes, its ring, and the client's fold. A reattach replay then still ended with 2031 on, so the reader sent its post-replay report, and every theme flip sent another, into the shell's command line. `TerminalModes` now drops 2031 on an OSC 133 `A`, `B` or `D` mark: the shell owns the terminal again, so whatever asked for reports is gone. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(terminal): send the reattach scheme report after the replay, not at a read boundary The reattach report went out whenever the reader drained what it had read. An 8 MiB ring arrives over many reads, so a read that ended after the ring segment holding a dead program's `?2031h` and before the one holding the shell prompt that ended it typed `CSI ? 997 ; n` into the shell. The report now waits for the first frame past the ring (the replayed Prompt, Cwd and the rest, or live Output once it is folded). --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com> Co-authored-by: l0ng-ai <24760907+l0ng-ai@users.noreply.github.com> |
||
|
l0ng-ai
|
d7dad45fa8 |
fix(gateway): reach the relay through a proxy when that is the only way out (#1058)
* fix(mobile): bump iroh to 1.3.0 so a stuck relay cannot stall direct dials iroh 1.2.0 sends a connection's first datagrams to every known path one after another inside the remote-state actor, awaiting each. When the relay is unreachable its send queue fills and the actor blocks, so handshake packets for a direct path that does work (a mesh VPN address, a public IPv6) queue behind it and the dial times out. 1.3.0 sends to all paths concurrently with a bounded wait (n0-computer/iroh#4512). The desktop workspace was already on 1.3.0; the app has its own lockfile and was left behind. * fix(gateway): reach the relay through a proxy when that is the only way out iroh dials its relay with its own resolver and its own TCP, ignoring the system proxy. On a machine whose network only works through a local proxy (Clash and the like, system-proxy or TUN mode alike) that dial never succeeds, and nothing says so: phones on the same network still connect, while a phone on cellular times out, because without a relay nothing coordinates hole punching and the home router drops unsolicited inbound packets. The gateway now lists the ways out it knows of, most likely first: tty7's own http_proxy setting, the system proxy, the environment's, then direct. It starts on the first without waiting, and when the relay stays unreachable for 10s it tries the others on a throwaway endpoint, switching to the first that reaches a relay (same key, same port, so pairing codes keep working). While none does, it looks again every minute. A pairing code now names the relay only once it is actually connected; before, it named whichever relay iroh picked by latency, reachable or not. The platform proxy readers in daemon::install::proxy now also hand back the proxy as a URL, for a client that is not ureq. Claude-Session: https://claude.ai/code/session_018wE9ZRyxgWW2f55VSy9FvZ |
||
|
l0ng-ai
|
d40233b572 |
feat(tabs): keep recently closed tabs in the machine tree, and a confirm-before-closing setting (#1037)
* feat(tree): keep each workspace's recently closed tabs in the machine tree A workspace now keeps the tabs closed from it in its machine tree (`Workspace::closed`), so reopening one no longer depends on the window that closed it still being open. - `TabCloseRemembered` closes a tab into that list: the tab leaves the workspace as a close takes it (other windows hear `TabClosed`), its panes are stopped with their last screens kept on disk, and their records stay in the pane list. Panes the client held that the tree never recorded are ended outright. - `TabReopen` takes the named or newest entry off the list and answers it with its pane records, for the client to rebuild on fresh shells that open on the old screens. The records it leaves behind are claimed by the successors' seeds instead of being refused as duplicates. - Entries last 24 hours and a workspace keeps the newest 20. The daemon's scrollback keeper expires them on its existing timer, and an entry that goes takes its records and stored screens with it. - Both requests are gated on a new `closed-tabs` hello feature, offered only by a peer that serves a tree and panes, so an older daemon or remote server is never sent them. The field is `#[serde(default)]` and skipped while empty, so older trees load unchanged and an older build reads this one's. Refs #1021 Claude-Session: https://claude.ai/code/session_011mDkkQhwx4RJJBHee3yVpq * feat(tabs): reopen closed tabs from the machine, and a setting for when closing asks Closing a tab now closes it into its workspace's recently-closed list on the machine that holds the workspace, instead of into a list that ended with the window. ⌘⇧T asks that machine for the newest entry, so a closed tab comes back after quitting and relaunching the app, from any window of the workspace, and in remote workspaces whose server keeps the list. - The explicit close (⌘W, the tab's close button, bulk closes) registers the tab with the window's next sync, which turns that tab's `TabClose` into a `TabCloseRemembered`. The machine stops the panes and keeps their screens; the window no longer kills them itself. A tab dragged to another window or never rebuilt still goes out as a plain close. - If the close cannot reach the machine (no `closed-tabs` feature, a window that has not pulled its layout, a sync that fails or is thrown away), the window falls back to what it did before: the tab goes on its own list and its panes are killed from here. - Reopening waits briefly for this window's queued edits to land, so an immediate ⌘⇧T undoes the close it means, then rebuilds the tab through the existing restore: each pane a fresh shell in its old cwd, opening on its last screen, with its shell, SSH target and agent resume facts. The tab keeps its id. The window's own list is used when the machine has nothing. - The home screen offers the next tab ⌘⇧T would reopen, read from the machine mirror, which now tracks this window's remembered closes. A new setting, `confirm_close` (General > Tabs, "Confirm before closing"), decides when closing a tab or pane asks first: `never`, `when-busy` (the default and the old behaviour) or `always`. The SSH "Warn before closing" opt-in is honoured under every mode. Under `always`, Close Other Tabs and Close Tabs to the Right ask once for the whole batch. Refs #1021 Claude-Session: https://claude.ai/code/session_011mDkkQhwx4RJJBHee3yVpq * fix(tree): a remembered close marks its panes' records as no longer live The records stay in the pane list for the reopen, but the panes are stopped right after the close. Left at live: true, `tty7 wait` on a pane of a closed tab read it as a running agentless shell and waited forever instead of reporting it exited. Claude-Session: https://claude.ai/code/session_011mDkkQhwx4RJJBHee3yVpq |
||
|
l0ng-ai
|
f0f2b83b6e |
feat(workspace): the machine's own window takes part in workspace takeover (#1042)
One workspace is driven by one window at a time, whether that window runs on the machine itself or on a remote client. The local GUI used to connect to its daemon without ever claiming a workspace, so a remote client and a local window could drive the same panes at once and fight over their size. - The local link now claims (WorkspaceAttach) every local workspace a window shows. Opening one on purpose (switcher, tty7 open, a new window onto it, switching in place) takes it over; restore, relaunch and reconnect only claim a workspace nobody else holds, and otherwise open taken over. - Preempted events for this computer put the window in the same taken-over state remote workspaces use: panes detached (processes untouched), the status strip naming the holder, the input pill, Take Back, and the switcher's 'taken over' badge. - A hydration of a local workspace another client holds does not attach its panes, so a restored window never resizes them under the holder. - A reconnect re-claims what the window held and leaves what it was pushed off alone. Nothing but Take Back or an explicit open reclaims. - The local hello carries the machine's hostname instead of the literal 'this computer', which is what a displaced remote client displays. |
||
|
l0ng-ai
|
53f661e1a1 |
feat(remote): let a remote workspace target a Windows host over SSH (#1041)
A remote workspace refused any machine that was not Linux or macOS. This
teaches the installer and the link to reach a Windows OpenSSH host:
- Detection: `uname -sm` is still asked first, unchanged. When it fails
(cmd.exe / PowerShell) or answers from Git for Windows, MSYS2 or Cygwin,
a PowerShell probe reads PROCESSOR_ARCHITECTURE. The detected platform
must match the SFTP home's shape, so a WSL DefaultShell over Windows
SFTP is refused instead of installing a Linux server at /C:/...
- Assets: tty7-server-windows-{x86_64,aarch64}.exe, verified against
checksums.txt like every other server; built by new server-windows
jobs in release.yml and nightly.yml (ARM64 leg non-blocking), and the
CI vcruntime guard now covers tty7-server.exe.
- Install: %USERPROFILE%\AppData\Local\tty7\bin\tty7-server-cXpY.exe via
SFTP (/C:/... spelling). No mode bits are required or set. A running
image is renamed aside to free its name and swept on the next install.
- Commands: every Windows command is a PowerShell script sent as
-EncodedCommand, which survives cmd.exe, PowerShell and bash as the
DefaultShell. The daemon is launched through Win32_Process.Create so
it outlives the SSH session's job object, with this session's
environment handed over; restarts use a new `tty7-server --stop`.
- Link: a Windows server is always reached by session exec with a plain
`"C:\...\tty7-server-cXpY.exe" --stdio` (no env probe, no
stream-local forward).
- Server: `--stdio` (control and --pane) now bridges on Windows to the
daemon's loopback TCP endpoints instead of refusing.
Tested against a fake Windows host in install/windows_tests.rs; not yet
run against a real Windows machine.
|
||
|
l0ng-ai
|
8efea021e3 |
feat(ssh): shell integration for Windows hosts whose default shell is PowerShell (#1040)
The remote shell probe only understood POSIX answers, so a native SSH pane on a Windows OpenSSH host always fell back to a plain shell with no prompt marks, cwd reporting or title. The probe is now a polyglot every default shell can read: POSIX shells answer as before; PowerShell answers with its edition and $PSHOME, which name the exact executable; cmd.exe echoes the line back verbatim and is recognised, then deliberately left alone. For PowerShell the bootstrap starts a second, interactive PowerShell of the same executable with the existing integration via -NoLogo -NoExit -EncodedCommand (comments stripped, about 6.5K chars total, well inside the Win32 command-line limit), and a redialled pane's start directory (/C:/..., C:/..., UNC) is restored with Set-Location -LiteralPath inside the encoded script. |
||
|
l0ng-ai
|
ab029f5ea1 |
fix(ssh): start a redialled SSH pane in the remote directory it was in (#1035)
* fix(ssh): start a redialled SSH pane in the remote directory it was in A native SSH pane dialled again (restore after a daemon restart, Reconnect, a split, ⌘T on an SSH tab, waking a sleeping tab) always landed in the login directory. The client already sent the pane's remote cwd as `SpawnNativeSsh.cwd`, but the daemon dropped it on the floor. The daemon now threads it through `Pane::spawn_native_ssh` and `SshManager::run_session` into the shell-integration bootstrap, whose first line becomes `builtin cd -- '<dir>' 2>/dev/null` (fish-quoted for fish). It is never typed at the prompt, never lands in history, and a directory that is gone leaves the shell in the login directory without a word. Sessions without integration take the plain shell request as before, so jump-host menus never see it. The per-host probe cache still holds only the shell. Only absolute paths are honoured. No wire or protocol change. Callers now say what they mean: a saved host or quick connect passes no start dir instead of the local cwd of whatever tab was in front; ⌘T and a split on an SSH pane pass that pane's remote cwd; a sleeping SSH tab keeps its remote cwd in the session layout. The daemon's replay now sends the remote context before the cwd, so a window that reattaches to an SSH pane does not wipe the remote directory it was just told. Refs #1028 Claude-Session: https://claude.ai/code/session_011mDkkQhwx4RJJBHee3yVpq * fix(ssh): a local shell standing in for a restored SSH leaf starts locally pane_to_session now keeps a native SSH leaf's far directory, so the session_to_pane fallback that brings such a leaf back as a local shell (the redial failed, or its daemon pane is gone on reattach) would hand that remote path to a local spawn. Pass no cwd there for an SSH leaf. Claude-Session: https://claude.ai/code/session_011mDkkQhwx4RJJBHee3yVpq |
||
|
l0ng-ai
|
0277ca67dc |
Centre the title-bar search box; bring back auto-hiding title-bar buttons as an Appearance option (#1036)
* feat(settings): an Appearance option to show the title-bar buttons only under the pointer 26.9.2 painted the new-tab and sidebar tiles only while the pointer was over the bar they sit in; 26.9.3 took that out so the buttons would stay discoverable. Both are fair, so it comes back as a choice: Appearance > "Show title bar buttons on hover" (`auto_hide_titlebar_buttons`), off by default, which keeps today's always-visible bar for everyone who has not asked otherwise. A config written before the key existed reads as off. With it on, the rail's two tiles follow the rail, and the collapsed rail's pair and the trailing panel toggle follow the tab strip. The window mark stays put, the tiles keep their layout slot so a reveal never shifts anything, and the title-bar search box is always drawn. The trailing toggle stays painted while the detail panel is open, as before, since the panel's own tab row beside it always is. The reveal is the hover sheet from 26.9.2 — a transparent last child over each region, because `group_hover` loses the region the moment the pointer reaches an occluding tile. Resting tiles go to zero opacity rather than `invisible()`: gpui skips a hidden element's paint pass, which is where its click and accessibility actions are registered, so a screen reader could find a hidden tile by label and then not press it. Shortcuts are actions and never depended on the tiles. Claude-Session: https://claude.ai/code/session_011mDkkQhwx4RJJBHee3yVpq * fix(titlebar): centre the search box on the window, not the bar after the traffic lights On macOS `TitleBar` leaves an 80pt lead for the traffic lights before the tab strip — whether or not the rail stands in front of them — and the Search Everywhere box was centred on the strip. So it sat 40pt right of the terminal column's middle: with the rail collapsed, 40pt right of the window's (#1033). Fullscreen added the bar's own inset on top. The band the box centres in now reaches back over that lead, so its left edge is the terminal column's on every platform (12pt elsewhere). Its right edge is unchanged: the strip's end on macOS, the terminal column's end beside a docked panel or document off it. Reaching back puts the collapsed rail's tiles inside the band, so the box now keeps an equal clearance at both ends — two springs with a minimum width either side of it. In a narrow column it shrinks instead of sliding under New Tab or the panel toggle, and stays centred while it does. The geometry is a pure `search_band`, tested for the macOS rail-collapsed, rail-open and fullscreen cases and off macOS. Claude-Session: https://claude.ai/code/session_011mDkkQhwx4RJJBHee3yVpq * fix(titlebar): clear a hover flag whose sheet is not on screen; document the key A title-bar hover flag is written only by its sheet, and only when the sheet sees the pointer cross its edge. Hide the rail from its own tile, or turn the switch off mid-hover, and the sheet leaves the tree with its flag still set: the next time it is built the tiles came back painted with nobody pointing at them, until the pointer happened to pass through and out again. Clear the flag of any sheet not built this frame. Also list auto_hide_titlebar_buttons in the configuration reference. Claude-Session: https://claude.ai/code/session_011mDkkQhwx4RJJBHee3yVpq |
||
|
l0ng-aiandClaude
|
4c8c317b91 |
feat(mobile): files, changes, a custom key bar, and a steadier connection (#1029)
The phone can now hand a pane a photo or file, read what an agent changed, answer its prompts with a tap, and keep its link across leaving a pane. Gateway and protocol: - `Open::Upload` puts a file (up to 20 MB) in the directory the desktop keeps pasted images in, under a name a shell takes unquoted, and answers with its path. Panes on this machine only for now. - `Open::Diff` answers with the working tree's changes against HEAD and its untracked files, for the directory a pane is in. - Both are one-shot streams; an older gateway drops them unanswered, which the client reports as "update tty7". App: - Attach button in the message box: the uploaded path goes into the draft. - Changes sheet from a pane's menu: a block per file, lines coloured. - Settings → Key bar: remove, reorder and add keys, from a catalog or written out (`/compact\r`, `^C`), across pages; reset to the default. - An agent's numbered choices show as buttons while it waits. - Pinch to zoom, tap a link to open it, find in the scrollback, a Copy button for text a program copies (OSC 52), and an optional Face ID lock. - Swipe from the left edge to go back; the iOS WebView has no page stack. - One workspace at a time on a machine, picked from a row of chips. - Agent avatars in their own colours. - Each screen's watch is its own: a second watch no longer ends the first, which showed as "Can't reach" and a reconnect after leaving a pane. - Dialing no longer holds the session lock, so Forget works while a machine is still connecting; its confirmation is an in-app sheet, since `window.confirm` shows nothing in the iOS WebView. - iOS 15 minimum, as App Store Connect will require from April 2027. - `scripts/testflight.sh` archives, signs for the App Store at export (the team has no devices for a development profile) and uploads. Co-authored-by: Claude <noreply@anthropic.com> |
||
|
l0ng-ai
|
8db94666f0 |
fix(remote): fast, stable remote workspaces with more than ten panes (#1034)
* fix(ssh): a connection at the server's session limit is full, not dead sshd allows ten sessions per connection by default and every remote pane is one of them. The eleventh was refused with ConnectFailed, and the connection was marked dead for it: taken out of the cache while all ten panes on it were still using it. Every pane after that dialled its own fresh link, paying a full handshake and server probe, and so did every short-lived route afterwards, because nothing held the replacement and it went away as soon as that route closed. The cache now keeps a pool per destination. A refusal marks that connection saturated for a while instead of dead; the pool hands out the first live one with room and dials another beside them only when all are full. A route or a native SSH pane that lands on a connection that turns out to be full goes back to the pool for another. * perf(remote): prove a server that is already running in one round trip Every new connection to a machine tty7 had been to before spent six sequential round trips proving what it already had: uname, a home lookup and a stat over SFTP, a control probe and a process scan. The SFTP session it opened also stayed open for the life of the connection, one of the handful of sessions the server allows it. One `sh -c` script now answers the common case: this dialect's server is installed, answers the bridge probe, and is the one running (or a build of the same dialect). Anything else falls through to the full install path unchanged. * fix(remote): don't replace a pane that could not be reached with a fresh shell Reattaching a restored pane treated every failure other than silence as "the pane is gone on its machine" and spawned a fresh shell in its place. That includes the link never opening at all — the server refusing another session, a transport error — when the pane is still running over there. The tab lost its session, and the old shell was left orphaned on the remote daemon; one workspace had accumulated 53 shells for 17 panes. Only the daemon's explicit "no such pane" now means gone. For a remote pane, any other failure leaves it pending, and a pane that stands in for a running one retries on its own a few times (2s, 4s, 8s, 16s, 16s) before leaving it to Try Again. Local panes keep their previous behavior. * perf(remote): ask a machine which panes are live over its control link The pane liveness probe opened a pane route every ten seconds, which is an SSH session channel on the remote side — one of the few the server allows per connection. Once panes had taken them all, each probe dialled a whole new connection. Ask over the control link that is already up instead: the machine tree's pane records carry the daemon's own liveness. * fix(scm): stop two windows from trading one repository watch every frame Who holds a repository open is a global, reconciled by every window every frame, but it was keyed by watcher kind alone. Two windows whose file trees or panels sat in different repositories took the hold from each other each frame, and every hand-over dropped the watch and opened it again. On a remote workspace that is four round trips per cycle — about 28 control requests a second for as long as both windows were open. Holds are now keyed by window as well, and a closed window gives back what it held. * perf(ssh): open channels on one connection concurrently The russh handle sat behind a tokio mutex held across every request on it, and each request waits a full network round trip for its reply. So every pane on a connection opened its channel after the one before it: on a link with a few hundred milliseconds of latency, a workspace of twenty tabs came back one tab at a time over about ten seconds. Every call on the handle takes `&self` and waits on a reply channel of its own, so the lock bought nothing. Drop it. Claude-Session: https://claude.ai/code/session_011mDkkQhwx4RJJBHee3yVpq |
||
|
|
802f9e0792 |
fix(agents): a Claude resume that finds no conversation starts fresh under its id (#1024)
* fix(agents): a Claude resume that finds no conversation starts fresh under its id A tab opened and never used, or run with transcript saving off, has no saved conversation, and `claude --resume` then stops at an error. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(agents): only chain the fresh Claude start where the pane's shell has || Windows PowerShell 5.1 and nu reject a line containing `||` outright, so the fallback took the resume down with it there. The restore line now chains the fresh start only for shells known to have the operator, judged by the pane's own shell: its spawn spec, else the configured or login shell for a local pane. A workspace pane with no explicit shell stays unknown and gets the plain resume, since its default lives on its host. --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com> Co-authored-by: l0ng-ai <24760907+l0ng-ai@users.noreply.github.com> |
||
|
|
f7e4101992 |
feat(daemon): panes set FORCE_HYPERLINK=1 (#1025)
* feat(daemon): panes set FORCE_HYPERLINK=1 tty7 renders OSC 8 links, but supports-hyperlinks only trusts a fixed TERM_PROGRAM list and strips them for tty7, so Claude Code's statusline PR links came out as plain text. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * docs(daemon): note that FORCE_HYPERLINK also reaches redirected output --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com> Co-authored-by: l0ng-ai <24760907+l0ng-ai@users.noreply.github.com> |
||
|
l0ng-ai
|
e66fa4d881 |
fix(ssh): never restore an SSH tab as a local shell; show a reattached one as connected
After the server restarted, a native SSH tab's old pane id was attached to, the attach failed, and the fallback spawned a local shell in its place: the tab that had been another machine was now this one, still titled and grouped like the remote. An SSH leaf is now only reattached when the server lists its pane; otherwise the host is dialled again. A window reattaching to a live SSH pane also never learned its phase, since status frames only went to whoever was attached when they were sent. The pane keeps the last one and replays it, so the tab keeps its connected dot and warn-before-closing still applies. |
||
|
l0ng-ai
|
f99fff93fd |
fix(ssh): log in as this machine's user when a host leaves User blank
The form says a blank User is resolved at connect, and the host card shows $USER, but the empty string went to the server as the user name. sshd refused it as an invalid user and tty7 reported every key as rejected. |
||
|
l0ng-ai
|
bf60899450 |
fix(cli): capture the newest segment in the modes the ones before it left on
A resize while vim was open started the newest segment inside the alternate screen. Replayed from the ground state its redraws landed on the main screen, so capture still showed vim's ~ column after vim had exited. |
||
|
l0ng-ai
|
186d715ca7 |
fix(cli): don't take the prompt still being drawn for a refused exec line
The daemon reports a pane at its prompt from the D precmd writes first, before the user's own hooks have drawn the prompt. A line exec sent in that window was followed by that prompt's A and only then read and run, and exec reported 'came back to its prompt without running the line' with exit 1. Back-to-back exec calls failed that way under any prompt theme slow enough, as did exec_returns_the_commands_output_and_exit_code. A prompt with no command started before it now has to stay that way for a moment before the line counts as refused. |
||
|
l0ng-ai
|
a35800b96d |
fix(config): read a shell entry with no program as the login shell
`shell` was the one structured field still read strictly, so a hand-edited
{"args": [...]} without a program failed the whole file. It was
quarantined and every other setting fell back to its default, and changes
made in Settings afterwards were never saved.
|
||
|
l0ng-ai
|
1aa6e1e35b |
fix(daemon): set up integration for the shell a pane actually runs
Launched from a terminal, the daemon spawns the shell it was started from rather than the login shell. The name handed to shell integration still came from get_shell(), which is always the login shell, so tty7 started from bash with zsh as the login shell ran bash with zsh's ZDOTDIR and no rcfile: no prompt marks, no prompt editor, no completion. |
||
|
l0ng-ai
|
5ba588f6d2 |
fix(mobile): let Settings renew a pairing code, and say when one is spent (#1019)
While a code was on screen the Show code button was disabled, so the only way to a fresh code was Cancel then Show code. Worse, any attempt at a code closes the offer, so after a mistyped paste or a dropped connection the page kept showing a dead code for up to ten minutes with no hint. - The button reads "New code" while a code is up, and replaces it. - A code that can no longer pair stays on screen faded, saying why (expired, tried, or replaced by a newer offer), with New code beside it. - The validity note counts down instead of saying "10 minutes". - Cancel, and switching phone access off, now withdraw the offer on disk; before, a dismissed code could still pair until it expired. Only our own offer is withdrawn, never one opened elsewhere since. The gateway's pair_code now returns the offer's secret alongside the code, and State gains pairing_is_open / has_open_pairing / close_pairing. Claude-Session: https://claude.ai/code/session_01BDVpJ78s7RQVcj57vjTcfA |
||
|
l0ng-aiandClaude
|
24cf458e3b |
feat(mobile): a phone app to watch and drive tty7 panes (#983)
* feat(mobile): a gateway that lets a paired phone reach this machine over iroh
The first half of the mobile app: everything on the desktop side, plus the
client library the app will link.
- tty7-mobile-proto: the phone<->gateway wire protocol. One stream per purpose
(pair, control, pane), framed like the daemon's frames, with raw terminal
bytes kept out of JSON. No tty7-core, so it cross-compiles for iOS/Android.
- tty7-gateway: dials nothing, accepts phones over iroh (hole punching, relay
fallback, end-to-end encrypted), checks the peer's key against the paired
device list, and bridges to the daemon. Panes are observed, not attached,
and keystrokes go in through SendInput, so a phone never resizes a pane or
takes it away from the desktop window. `pair` prints a one-time QR code.
- tty7-mobile-client: the phone side (pair, tree, pane streams, direct/relay
and RTT for the link), plus a `probe` example that stands in for a phone.
Verified against a real, isolated daemon: pair, tree, and typing into a pane
over a direct path, ~0.8 ms median echo on loopback.
* feat(mobile): the Tauri app — pair, browse the machine, drive a pane
The phone half, as a Tauri 2 app in mobile/ (its own cargo workspace, so the
desktop build and CI never compile a WebView stack).
- Rust side: the phone's iroh endpoint and key, paired machines, and every
live stream, behind eight commands. Terminal output crosses to the WebView
as raw ArrayBuffers on a Tauri channel, batched per frame, in order with the
pane's JSON events.
- Frontend: vanilla TS + xterm.js. Paired machines and pairing; one machine's
workspaces, tabs and panes with agents that need you pinned on top and the
link's direct/relay path and RTT in the header; a terminal that fits the
desktop pane's width, with an esc/tab/ctrl/arrows key bar. Coming back from
the background re-watches and re-opens, relying on the daemon's replay.
Verified as a macOS build against a live gateway and an isolated daemon:
paired from the app, tree rendered on a direct path, keystrokes and key-bar
arrows reached the pane. iOS/Android builds need Xcode / the Android NDK,
neither of which is on this machine; mobile/README.md has the steps.
* fix(gateway): one serve per machine, and say how to start a missing server
- `serve` takes an exclusive lock on <config dir>/mobile/serve.lock. A second
gateway on the same key is a second endpoint answering to one address, so a
phone reached whichever the network picked. It is now refused, naming the
pid that holds the lock.
- With no tty7 server running, phones and the terminal both hear "tty7 isn't
running on <host> — open tty7 there, or run `tty7 server start`" instead of
"lost the tty7 server: No such file or directory". `serve` checks once at
startup, and still starts, since tty7 may be opened after it.
* feat(mobile): redesign the app as a native-feeling, minimal UI
The first cut read as a web page of bordered boxes. This rebuilds it the way a
phone app moves and reads, in the desktop tty7's own look:
- Screens push and pop with View Transitions; large titles fold into the bar.
- Grouped inset lists on a tinted canvas, following the system Light/Dark with
the desktop presets, accent and ANSI palettes. Hack for code and terminal.
- Panes are listed by tab, one card per workspace, with the desktop's agent
avatars and status badges (Waiting hollow, Working blinking) and its words.
- Pairing is its own screen, with steps, a Paste button and inline errors.
- A machine that stays silent for 10 s says so and offers to pair again; an
offline notice says what to check.
- The terminal header shows live/offline in words. A pane too wide to read is
shown at a readable size and pans to follow the cursor, with a toggle to fit
the whole width. The key bar has drawn icons, puts left/right first, and
has a keyboard toggle.
PRODUCT.md and DESIGN.md record the product facts and the design system.
* feat(mobile): open a new tab from the phone
Each workspace on a machine's screen gets a "New tab" action. It starts a
shell at the end of that workspace, in the directory its last tab is in, and
opens it straight away.
- Protocol: a one-shot `Open::NewTab { workspace_id, cwd, size }` stream,
answered with `Ok` and a `TabCreated { tab_id, pane_id }`, or `Denied`.
It is additive, so the protocol version stays. A gateway from before this
drops the stream unanswered, and the app says to update it.
- Gateway: takes the same two steps as `tty7 tab new`, spawning a shell owned
by the workspace and then TabCreate. The shell starts at the grid the phone
asked for, because no desktop window is showing it yet. Sizes are clamped.
- App: a `tab_new` command, with the size worked out from the screen at the
readable font size.
- probe: `newtab <workspace-id> [cwd]`.
* feat(mobile): reach the machines the desktop is linked to over SSH
A machine's screen now lists, under its own workspaces, every machine its
tty7 holds an SSH link to, with that machine's workspaces. Panes there open,
take input and get new tabs like local ones. "Needs you" gathers panes from
all of them.
- The gateway routes through the local server over links it already holds,
the same way `tty7 -m <machine>` does. It never dials a down link, because
that would guess at credentials the phone does not have. A down link
shows as "Link down", with a note to reconnect it on the desktop.
- Protocol, additive: `Tree.remotes`, and an optional `machine` (the link
key) on `Open::Pane` and `Open::NewTab`. A local pane is asked for exactly
as before, so older gateways still understand it.
- Rebuilding a route target from a link key moves from the CLI into
tty7-core as `RouteInfo::target` / `RouteInfo::host`, so the CLI and the
gateway share one rule. The CLI now calls it.
* perf(gateway): read linked machines in parallel, never waiting on a slow one
Linked machines were read one after another on every tree poll. One slow
SSH link, whose requests can take 10 s, stalled the whole tree for every
phone, local workspaces included. It also held a lock that queued pane
opens, input and new tabs on every other link.
- Each linked machine is read on its own thread (`poller::Poller`). A poll
waits at most 250 ms. A machine that has not answered is reported as it
last was, and its read lands for the next poll. Only one read is in flight
per machine, however many phones are watching. A machine that drops off and
comes back cannot receive a stale read, because each slot has a generation.
- Routed control connections are locked per machine, not all together.
- A link that is up but has not answered its first read is sent as
`RemoteView.pending` (additive). The app shows "Reading…" with skeleton
rows instead of claiming the machine has no workspaces.
* fix(mobile): keep reaching the computer after the gateway restarts
Every `serve` bound a random port, so a restart left each phone holding
addresses that no longer answered. Where the n0 relays are unreachable, which
is common behind the Great Firewall, the phone had no other way to find the
gateway until it was paired again.
- `serve` listens on the same UDP port every time. It picks one on first run,
keeps it in `<config dir>/mobile/port`, and moves only if the port is taken.
IPv6 binding may fail, as in iroh's own defaults.
- Both ends add mDNS lookup (`iroh-mdns-address-lookup`, service `_tty7._udp`).
On the same network a phone finds the gateway by key when its addresses are
stale, such as after a new DHCP lease or a new IPv6 prefix. The gateway
advertises and the phone only listens. If multicast is refused, each side
starts without it and says so, rather than failing.
- iOS: `Info.ios.plist` declares the local-network use and the Bonjour
service, without which iOS blocks multicast.
- An ignored test (`--test mdns`) connects by key alone over mDNS, for a
machine that allows multicast.
* feat(mobile): run the gateway in the desktop daemon, paired from Settings
Phone access no longer needs `tty7-gateway serve` in a terminal.
Settings → Mobile switches it on, and the local daemon runs the gateway from
then on, with every window closed as well. That is where the panes a phone
reaches live anyway.
- Settings → Mobile, in all three locales:
- an "Allow phone access" switch;
- a status line (running, starting, off, or why it failed);
- "Show code", which draws the QR code and the tty7pair: code with a
Copy button, and closes on its own once a phone uses it;
- the paired phones, each with Unpair.
The section is in search, including by its config key `mobile_access`.
- The daemon (`tty7-app --daemon`) runs a supervisor (`core::mobile`). It
watches `mobile_access` in config.json, re-reading only when the file
changes, and starts or stops the gateway. A failed start is retried every
30 s and logged once.
- tty7-gateway grows a `service` module: `start()` returns a stoppable
handle, and `pair_code()` makes a code. The CLI's `serve` and `pair` are
thin wrappers over them now. The gateway logs through `log`, so the
daemon's output lands in its log file, and it reports itself in
`mobile/status.json`. `State::serving()` checks the lock, which a crash
cannot leave stale. A gateway that cannot take the lock leaves the
status alone, because it belongs to the one holding the lock.
- iroh is linked into the GUI binary only. tty7-server stays the lean static
binary pushed to remote machines.
* feat(mobile): serve phones whichever daemon is running
A daemon started by `tty7 server start` is the lean tty7-server, which
carries no gateway. With phone access on, the Settings status stayed on
"Starting…" and no phone could connect.
The GUI now checks, 5 s after it starts and whenever phone access is
switched on. If nothing is serving, it starts `tty7-app --mobile-gateway`,
detached the same way as the daemon (`spawn::detach_helper`). The helper
serves until the switch goes off, and exits at once if another process
already holds the gateway lock. When the daemon's own gateway is up, no
helper is started. The helper logs under its own role, "mobile".
* refactor(mobile): the daemon owns the gateway, as a child, whoever started it
There were two ways of running the gateway: a thread inside `tty7-app
--daemon`, and a detached helper the GUI started when the daemon could not.
That is now one way.
Every daemon, whether `tty7-app --daemon` or `tty7-server`, runs
`tty7_core::daemon::mobile::supervise` from `run_with`. While
`mobile_access` is on it keeps the gateway running as a child process, and
stops it when the switch goes off.
- Which program: `tty7-app` runs itself as `--mobile-gateway`. `tty7-server`
runs a `tty7-gateway serve --exit-with-stdin` from beside it or on PATH,
and links nothing new. Without one, it writes the reason into
`mobile/status.json` for Settings to show, instead of "Starting…" forever.
- Lifetime: the child's stdin is a pipe from the daemon, and the gateway
exits when it closes. A stopped, crashed or handed-off daemon (the pipe
is close-on-exec) takes its gateway with it, and the next daemon starts
one from its own binary. No gateway from an older build survives an
update.
- Isolation: iroh no longer runs inside the process that holds every pane.
- `Status` moves to tty7-core, the one definition that the daemon, the
gateway and the GUI all share.
- Gone: the GUI's helper check (`core::mobile` in the app) and the in-daemon
gateway thread.
* fix(mobile): stop and reap the gateway before a daemon handoff
Found by running a real `tty7 server restart`. The old gateway did exit,
because the new image's supervisor started its own gateway and the old one
lost the lock. But it was left as a zombie: the image after the exec never
reaps a child it did not start, so each handoff leaked a process entry.
`hand_over` now calls `daemon::mobile::stop_for_handoff` before the exec,
which closes the gateway's stdin and waits for it. A flag keeps the
supervisor from starting another in the moments before the exec, and
`handoff_failed` clears the flag if the exec never happens, so the daemon
goes on serving.
Checked with two handoffs in a row (tty7-app → tty7-server → tty7-server):
- each old gateway was reaped, with no zombies system-wide;
- exactly one fresh gateway was running after each handoff;
- the pane's shell and its environment survived;
- the probe phone kept working.
* feat(mobile): the switch shows whether phones can reach you, not a status row
Settings → Mobile had an "Allow phone access" switch that showed intent and a
separate Status row that showed reality. That is one thing shown twice, and
the switch could sit on while nothing was running.
- The switch is the state. Switching on holds it at "Starting…", disabled,
until a gateway is actually serving. If the daemon reports a failure, or
nothing comes up within 15 s, the switch goes back off, `mobile_access`
is reverted, and a notification says why.
- If the page opens on a failure the daemon is still retrying, the switch
shows off with the reason in its description, and switching it on
retries.
- The Status row is removed, with its four strings. There are two new
strings for the failure, in en, zh and ja.
Also fixes the Settings window never showing notifications. It is a `Root`
like the workspace window but did not draw the notification layer, so any
toast pushed from Settings was queued and never shown. That included the
existing "Set as Default Terminal" result.
Checked in a dev instance. On a tty7-server daemon with no tty7-gateway:
Starting… first, then off, with "Phone access could not start: … no
tty7-gateway beside it or on PATH". On a tty7-app daemon: on, with Show
code enabled and no toast.
* feat(mobile): drop the "Needs you" section
The machine screen gathered every pane whose agent was waiting or done into
a "Needs you" section above the workspaces. Done lasts until the next prompt,
so the section grew with every finished agent and mostly held panes that
needed nothing.
Panes now appear once, in their own workspace. Each keeps its status badge
and words ("Needs input", "Working", "Done") and the agent's message.
PRODUCT.md and the design sidecar are updated to match.
* fix(mobile): say when typing doesn't reach the pane
The gateway's input thread gave up silently on a failed send_input, and
the app's input task did the same on a failed write, so the phone kept
showing a live pane while keystrokes went nowhere. Both now report the
failure as a pane error. Keys after it are dropped rather than ending
the stream, which the phone would read as the pane closing.
* feat(mobile): a compose box, paste and Shift+Tab on the terminal
Replying to an agent meant typing into xterm a character at a time,
without autocorrect, dictation or a usable IME. The compose box is a
real text field: Send types the text and then Enter, as its own write,
and several lines go in as one bracketed paste when the program asked
for it. Drafts survive leaving the pane and a send that failed. An
agent's pane opens on the box with the keyboard down.
The key bar gains Shift+Tab (Claude Code's mode switch) and a paste key.
A failed keystroke now takes the pane offline with a Reconnect banner
instead of being swallowed.
* feat(mobile): reconnect on its own, and select text to copy
A dropped pane or machine stream is retried with backoff (1s, 2s, 4s …
15s) and at once when the network comes back, rather than waiting for a
tap on Reconnect. The pane keeps its last screen up until the new
replay starts, and output or errors from a replaced stream are ignored.
Touch selection does not work in xterm, so a copy key lays the whole
buffer out as plain text over the pane, wrapped to the phone and joined
where the terminal wrapped, for the phone's own selection and Copy.
* feat(daemon): size leases, and Take Back on the desktop
An observer can now run a pane at its own size (ClientMsg::Lease, feature
size-lease). The pty and every observer go to that size. The controller
keeps its grid, its resizes are remembered rather than applied, and the
pane goes back to the last of them when the lease ends: the observer lets
go, its connection closes, or the controller takes it back.
A controller hears about leases only after asking (Watch), since an older
client cannot decode DaemonMsg::Lease. The desktop asks on every attach,
spawn and relink where the daemon advertises the feature, locally or
through the host hello for remote workspaces, and shows the pane as in
use on the phone with a Take Back button.
* feat(mobile): take a pane over at the phone's size
The terminal's phone button asks the gateway to run the pane at the
phone's grid (PaneRequest::TakeOver), which it turns into a size lease on
the observer connection, named after the paired device. The grid follows
the keyboard and rotation; leaving the pane, or the connection dropping,
gives it back. When the desktop takes it back the app says so and offers
to take it over again, never doing it on its own. A daemon too old for
leases is reported, and the pane keeps working.
* fix(mobile): link SystemConfiguration and install a rustls provider on iOS
The first iOS build failed to link: netdev and system-configuration, pulled
in by iroh, need SystemConfiguration.framework, which the generated Xcode
project does not list. bundle.iOS.frameworks adds it on `tauri ios init`.
Once linked, the app panicked at launch: iroh builds its reqwest client with
`rustls-no-provider`, so a process-wide crypto provider must be installed
before any client is built. Install ring's, which is already in the tree.
Co-Authored-By: Claude <noreply@anthropic.com>
* fix(mobile): keep the terminal's scrollbar on screen while panning
Panning a pane wider than the phone scrolled xterm's own box sideways with
the text. The box was only the view's width, so its vertical scrollbar
panned off with the columns and its scrollback stopped taking touches past
the first screen. The box now spans every column, and the bar is shifted
to the visible right edge as the view pans.
The bar is also drawn like the indicator WebKit shows for the pan, thin,
rounded and translucent, instead of VS Code's 14px square slider, so the
two axes match.
Co-Authored-By: Claude <noreply@anthropic.com>
* feat(mobile): pair by scanning the QR code, and Enter and quick-answer keys
Pairing took a pasted `tty7pair:` code, which on a real phone means getting
text off the desktop somehow. A Scan button next to Paste now reads the QR
code tty7 shows, through tauri-plugin-barcode-scanner, and pairs straight
away. The camera runs behind the WebView with our own viewfinder and Cancel,
since the plugin's full-screen view has no way out. The plugin is registered
on phones only, so the desktop dev build is unchanged.
The key bar gains Enter, so an agent's highlighted choice can be confirmed
without raising the keyboard, and 1 2 3 y n for numbered choices and y/n
prompts.
Co-Authored-By: Claude <noreply@anthropic.com>
* chore(mobile): sign for the App Store and declare exempt encryption
Sets the development team so `tauri ios init` writes it into the Xcode
project, and marks the app's encryption (standard TLS/QUIC only) as exempt
so TestFlight uploads skip the export-compliance question.
Co-Authored-By: Claude <noreply@anthropic.com>
* fix(mobile): count the iOS safe areas once
The WKWebView's scroll view inset its content by the safe areas, and the
page, laid out with viewport-fit=cover, padded by env(safe-area-inset-*)
as well. The viewport came out 778pt tall on an 874pt screen: everything
sat a status bar's height too low, with a blank band under it. The scroll
view's automatic inset adjustment is now off, so the page runs edge to
edge and its CSS alone keeps clear of the status bar and home indicator.
Co-Authored-By: Claude <noreply@anthropic.com>
* feat(mobile): the Terminal Mobile redesign
The app takes the desktop's neutral greys, light and dark, with ink rather
than a system blue for what is pressed or chosen.
- Machines: pairing's "+" moves to a floating bar at the bottom beside a
search field. Each machine shows its link, round trip and tab count as
last seen.
- A machine: tabs grouped by workspace with a count; round agent glyphs;
a dot on the right for running or waiting on you. The per-group New tab
buttons give way to one "+" in the same floating bar, beside tab search.
- New tab: a sheet to pick Claude Code, Codex or a shell, and the
workspace. An agent's command is typed into the new tab once it is live.
- A pane: the bar keeps only back, the title with its state, and a menu
for selecting text, the fit and the phone's size. Under it, one row of
equal keys, a page at a time, and a message box that is always there;
its round button sends, or when empty hands the keyboard to the
terminal.
Co-Authored-By: Claude <noreply@anthropic.com>
* fix(mobile): the tty7 mark as the iOS app icon
The phone showed Tauri's default icon: `tauri ios init` filled the Xcode
project with it. The committed icons/ios set was drawn on the macOS grid,
a rounded tile inset on transparency, which iOS would shrink inside its own
mask with a pale border. icons/app-icon-ios.svg is the same Duo mark full
bleed, rendered without alpha as the App Store requires.
Claude-Session: https://claude.ai/code/session_01HVosmYyVSH3BrsLYx3tcSS
* fix(mobile): typing, scrolling and pairing on a real phone
- Typing into a pane: an input method's text never reached it, since iOS
never commits a candidate into xterm's hidden textarea. Tapping the
terminal now focuses a plain field of our own, whose committed text goes
to the pane as it is committed. Backspace on the empty field, Enter, Tab
and the arrows go as the terminal's keys.
- xterm sends nothing itself any more (disableStdin). That also stops the
phone answering a program's colour and device queries: the desktop
answers those, and the phone's late second answer landed in the shell as
typed text.
- Scrolling the scrollback: xterm 6 has no working touch scrolling. A
mostly vertical swipe now scrolls the buffer a row at a time and coasts;
a sideways one is left to the native pan.
- Pairing: the steps name the desktop's Settings -> Mobile, Allow phone
access and Show code, not a command-line gateway, and so do the notices
when a machine cannot be reached.
Claude-Session: https://claude.ai/code/session_01HVosmYyVSH3BrsLYx3tcSS
* fix(mobile): room for the keyboard, and smoother vertical scrolling
- The keyboard: the WebView runs edge to edge and is not resized for it,
so it covered the dock and the pane's last lines. The app now takes the
size of the visual viewport, drops the home indicator's gap while the
keyboard is up, and keeps the cursor's line in sight.
- Scrolling: the terminal draws with xterm's WebGL renderer, which a
scroll does not make lay every row out again. A swipe is applied once a
frame, and moves the view by pixels: xterm scrolls whole rows, and the
rest of a row is a GPU shift of the drawn screen, put on together with
the rows it goes with.
Claude-Session: https://claude.ai/code/session_01HVosmYyVSH3BrsLYx3tcSS
* feat(mobile): settings, message history, and a tighter home screen
- Settings, from beside the Machines title: appearance (automatic, light,
dark; the status bar and keyboard follow through the window's interface
style), terminal text size, how a pane wider than the phone first shows,
clearing the message history, and the version.
- The message box keeps what it sends on the phone. As a message is
written, past ones that match take the key row's place; with the box
empty, a History button opens them all, searchable. A line that asks for
a password is sent but not kept.
- ^R on the third key page, for the shell's own history search.
- A top-level screen's bar floats over the list, clear until the title
scrolls under it, so the large title sits just under the status bar.
Claude-Session: https://claude.ai/code/session_01HVosmYyVSH3BrsLYx3tcSS
* fix(mobile): a fitted pane fills the view, and its scrollbar drags
- A pane shorter than the view (a wide one, fitted) no longer leaves the
bottom of the screen blank: the terminal here runs as many rows as fill
the view, the extra ones holding the pane's earlier lines, and what is
left over goes above so the prompt stays next to the keys. The pane on
the desktop keeps its size.
- A drag that starts on the scrollbar is left to xterm. The swipe handler
took it too, the other way round, and the two cancelled out.
Claude-Session: https://claude.ai/code/session_01HVosmYyVSH3BrsLYx3tcSS
* fix(mobile): errors say what to do in the app, not on the command line
The messages a phone shows, and the two Settings → Mobile can, named the
gateway process, the CLI's `tty7 server start`, the transport and a lock
file's path. They now speak of tty7 on the computer and of pairing: open
it there, update it, pair again, quit the other copy.
Claude-Session: https://claude.ai/code/session_01HVosmYyVSH3BrsLYx3tcSS
* style: rustfmt the gateway and mobile client
Claude-Session: https://claude.ai/code/session_01HVosmYyVSH3BrsLYx3tcSS
---------
Co-authored-by: Claude <noreply@anthropic.com>
|
||
|
l0ng-ai
|
eec9350ff8 |
test(git): compare repo roots in one spelling so Windows passes (#1013)
canonicalize answers \\?\C:\... on Windows while git prints C:/...; the production path already folds the first into the local spelling in probe_repo, only the test compared them raw. |
||
|
l0ng-ai
|
12ec0c92a9 |
fix(sidebar): stop ungrouping tabs when a git probe fails (#1011)
A tab's auto group comes from probing its cwd for a repository. Any failure of that probe - git failing to spawn, the macOS /usr/bin/git shim dying while Xcode is mid-switch, a remote link dropping - came back as "not a repository", overwrote the tab's remembered group, and was never re-checked while the pane sat idle. Tabs in perfectly good repositories dropped into Ungrouped and stayed there. - Read root, home and branch in-process on this machine with gix-discover instead of three git processes. Only the line counts still come from `git diff --numstat`, so they keep matching the diff views; a detached HEAD is still named by git for the same reason. - Remote hosts keep asking their own git (a new control request would force a dialect bump), but the probe now tells "not a repository" (exit 128, or the directory is gone) apart from a failure. - A failed probe leaves the cache as it was, so a tab keeps its remembered group, and an unanswered cwd is retried every 10s. |
||
|
l0ng-ai
|
8cf31c718d |
feat(worktree): setup, .worktreeinclude, agent launch, recoverable removal, and a worktree CLI (#1009)
* feat(worktree): setup script, .worktreeinclude, fresh base, recoverable removal - Start new worktrees from the remote default branch, fetched first, with --no-track; fall back to the current branch without a remote. - Carry gitignored files listed in .worktreeinclude over from the main checkout, copy-on-write (clonefile on macOS, copy_file_range elsewhere); remote hosts copy through the Host trait under a size budget. - Run .tty7/setup in the first pane before the agent, with TTY7_ROOT_PATH, TTY7_WORKTREE_PATH, TTY7_WORKTREE_NAME and a per-worktree TTY7_PORT block. The script only runs once its exact content is approved for the repo. - The New Worktree dialog picks what the first pane starts (Shell or a recent agent) and takes a task for agents that open on a first message. - Removal snapshots the checkout, uncommitted work included, under refs/tty7/trash/<name> first; the ref also retires the name. A branch git refuses to delete is reported instead of silently kept. - Hide .tty7/worktrees via info/exclude rather than a catch-all .tty7/.gitignore, so .tty7/setup can be committed. * feat(cli): tty7 worktree new/ls/rm - worktree new: the GUI dialog's worktree from the command line — create, carry .worktreeinclude, open a tab named after the branch, and type .tty7/setup && <agent> [task] into it. Prints the path first. - worktree ls: every checkout of the repo, tty7's marked, with the live panes working in each. - worktree rm: refuses while panes are inside unless --close-panes, and a dirty checkout unless --force; reports the snapshot ref and a kept branch. - Move shell_quote and the first-line builders into tty7-core so the GUI and the CLI type the same line. - Docs: CLI reference and the Worktrees page cover .worktreeinclude, .tty7/setup, TTY7_PORT and recoverable removal. * fix(worktree): run setup and the agent inside the worktree; Start is a dropdown - The first line now opens with cd into the worktree: a shell's startup files can move the pane, and setup then ran in (and wrote into) the main checkout. - The Start choice is a dropdown listing Shell and every agent this machine offers, instead of a segmented switch capped at three. |