vcswatch reports that
this package seems to have a new changelog entry (version
1.0.0-1, distribution
unstable) and new commits
in its VCS. You should consider whether it's time to make
an upload.
Here are the relevant commit messages:
commit 495e8b074900d57a88203495abc12ba0b9f0c934
Merge: 900ad05 caa6a21
Author: noturbob <bobbyanthenrao@gmail.com>
Date: Fri Nov 6 04:34:51 2026 +0530
Merge upstream version 1.0.0 archive
commit caa6a21635d2befa6723f1a053f41e78d751e8b9
Author: Bobby Anthene <bobbyanthenrao@gmail.com>
Date: Fri Nov 6 04:34:02 2026 +0530
Import upstream version 1.0.0 archive
commit 900ad05dbfca42e58614f5d2f22050daf02e76ba
Merge: 8bcae4c 88e211d
Author: noturbob <bobbyanthenrao@gmail.com>
Date: Sun Oct 11 09:13:23 2026 +0530
Merge upstream version 1.0.0
commit 8bcae4cc985545740c85f0976bcce19f1191164d
Author: noturbob <bobbyanthenrao@gmail.com>
Date: Thu Oct 8 16:40:35 2026 +0530
Package 1.0.0
New upstream release, as a source-only upload so it can migrate to
testing. Build-Depend on golang-golang-x-sys-dev, now imported
directly; copy docs/rices into the build tree for the new config test;
declare Static-Built-Using.
commit ee8c219c6345c28b3d39b573db6f657ff5c48241
Author: noturbob <bobbyanthenrao@gmail.com>
Date: Thu Oct 8 16:32:08 2026 +0530
New upstream version 1.0.0
commit 88e211da24a640865fd2853304a1f5290cb8c863
Author: Bobby Anthene <142563527+noturbob@users.noreply.github.com>
Date: Thu Oct 8 16:17:09 2026 +0530
Point Arch users at the AUR package (#15)
The README still said an AUR package was on the way. It has been there
for a while, kept by a packager of its own, so name it and drop the
promise.
commit d5a933996ef3cdc11d525730c33f20702cf9c5ac
Author: Bobby Anthene <142563527+noturbob@users.noreply.github.com>
Date: Sun Sep 27 22:32:43 2026 +0530
Play the film when it comes into view, and loop it (#14)
It sat behind a poster and a play button, which is a step most visitors
will not take for a forty-second demo.
It now starts when a third of it is on screen and pauses when it leaves,
so nobody downloads five megabytes for a section they scroll past, and a
tab left open on another part of the page is not quietly decoding video.
It loops, because the film ends on a card rather than a conclusion.
Muted, which is what browsers require of anything that starts by itself
and costs nothing here: the film has no sound. The controls stay, and
anyone who has asked for reduced motion gets the poster and decides for
themselves.
Autoplay can still be refused -- a data saver, a policy, a setting -- so
the refusal is caught rather than thrown.
commit 13833522705ebddf0e468217891240d85bb810f6
Author: Bobby Anthene <142563527+noturbob@users.noreply.github.com>
Date: Sun Sep 27 22:26:45 2026 +0530
A new demo, covering what slat can now do (#13)
* A new demo, covering what slat can now do
The film in the README was shot before mouse support, session restore,
drag-to-resize and the ten palettes existed, so it showed about half the
feature list and none of the last week's work.
This one runs the whole list: splitting, walking a pane around the layout,
tabs and workspaces named in place, search and copy over ssh, surviving a
reboot, being driven from outside, and changing palette.
The GIF is a third of the size of the one it replaces -- 3.5 MB against
8.5 -- because it is an excerpt rather than the whole 43 seconds, which is
what the video is for. The alt text says what is actually on screen now.
* Say what the new film shows, on the site too
The Watch section still described the old recording -- two commands and a
detach -- which is a third of what the film now covers. The caption and
the label now list what is on screen.
The comment beside the video claimed it cost a quarter of the GIF's bytes.
That was true of the old pair and is not of this one: the GIF is an
excerpt now and the video is the whole thing, so it is the larger of the
two. It says that instead.
commit c8a4e7b42c65990aae92f4f81eae5629e8086e93
Author: Bobby Anthene <142563527+noturbob@users.noreply.github.com>
Date: Thu Sep 24 18:55:55 2026 +0530
Point the sponsor button at GitHub Sponsors (#12)
The Ko-fi link only ever showed up inside the repository: GitHub promotes
its own sponsorship across profiles, hovercards and repository listings,
and a third-party URL nowhere but the repository page itself.
The GitHub Sponsors profile is live now, so it goes first. Ko-fi stays
under it for anyone who would rather send one coffee than a subscription.
commit 0104e98ade93cb245f32786b826a39f06d8b9a3f
Author: Bobby Anthene <142563527+noturbob@users.noreply.github.com>
Date: Thu Sep 24 18:34:36 2026 +0530
Drag borders to resize, and ten themes (#11)
* Drag a border to resize
Clicking a pane focused it and the wheel scrolled it, but the borders
between them did nothing -- which is the next thing anyone tries.
Pressing on a border now takes hold of the split it belongs to, and the
pointer moves it until the button comes up. The drag keeps the border
even when the pointer wanders off it, because a border is one cell wide
and nobody stays on it.
A ratio only means something against the space its split divides, so
DividerAt returns both, and the ratio is clamped the way the keyboard
resize already clamps it: neither side can be dragged out of existence.
Borders do not exist over a zoomed pane or in scroll mode, and a press
inside a pane is still a click.
* Ten themes, and a floor under all of them
Five more palettes, chosen because people already have opinions about
them: Catppuccin Mocha, Tokyo Night, Dracula, Solarized Dark, and
Catppuccin Latte -- which, with mono, gives a light terminal two real
options rather than one grudging one.
A palette can look lovely in a screenshot and be unreadable at 12px in
daylight, so there is now a test that measures every built-in theme:
status bar text at 4.5:1 against its background, and the dim half, the
accent and the tab chips at 3.4:1. WCAG's large-text bar, which is the
right one for short bold labels.
It found three that failed it. mono put grey 8 on silver 7 at 2.2:1,
which nobody could read; it uses white now, and the dim half has somewhere
to be dim. Solarized's own base3-on-blue tab is 3.4:1, so the tab takes
base03 instead, which is what Solarized uses on an accent anyway. Latte
sat on surface0 and is a shade lighter now.
The website's copy of the palettes is updated to match, mono included.
One casualty: a test asserted that "solarized" was not a theme name.
commit fbe441235fa4ff5b0d6ecdd1d560221acdf624e9
Author: Bobby Anthene <142563527+noturbob@users.noreply.github.com>
Date: Wed Sep 23 15:02:54 2026 +0530
Mouse support and session restore (#10)
* Read the mouse
Clicking a pane focuses it and the wheel scrolls its history, which is
what anyone who has used a terminal expects the mouse to do. Programs
that ask for the mouse themselves -- vim, htop, less -- get the events
instead, translated into their own pane's coordinates and re-encoded the
way each one asked for them.
slat requests SGR reports (1006) rather than the original encoding,
which spends one byte per coordinate and so cannot say anything past
column 223. Programs that only understand the old form still receive it;
the translation happens on the way out.
Mouse reports are intercepted before anything else reads the input, so
they cannot be typed into a prompt, dismiss the help overlay, or reach a
shell as text. The client's exit sequence turns reporting off again --
leaving it on would cost the user their terminal's selection after slat
had gone.
mouse = false gives the mouse back to the terminal.
* Bring the session back after a reboot
The daemon held everything in memory, so a session outlived a closed
window and a dropped connection but not a restart -- which is the one
interruption nobody chooses.
slat now writes the session out: the workspaces, tabs and layout tree,
each pane's working directory, and up to 2000 lines of what it had
printed. On the next start it puts them back, creating each pane at the
size it will be drawn at so the restored output is not reflowed a moment
later, and marking where the old session ended with a dim rule.
What comes back is output, not processes. Nothing portable can restore a
running program, so a pane that was in vim returns as a shell in the same
directory with what vim had drawn left behind as text. Saying that
plainly is better than pretending otherwise.
Quitting clears the saved session: ending a session has to mean ending
it. Detaching, closing the terminal and rebooting do not. The file lives
under $XDG_STATE_HOME rather than beside the socket, because
$XDG_RUNTIME_DIR is cleared on reboot -- the event this exists for -- and
is written atomically, every 15 seconds while anything changes and again
on the way out.
A saved session from another version, or a damaged one, is ignored rather
than guessed at, and slat starts clean.
Tests cover the app and the daemon, both in their own XDG_STATE_HOME so
they can never read, write or delete a real session.
* Read the app's state through its lock in tests
TestWheelEntersScrollMode read a.scroll while the render loop was reading
it too, which is a race whatever the values happen to be. It passed here
and on Windows and failed on macOS, which is how these always go.
The fields belong to the app's mutex, so the tests now go through helpers
that take it. One older test was reaching into the manager the same way
and is fixed with them.
No change to slat itself.
* Don't take the app's lock twice in TestScrollMode
The previous commit routed test reads through helpers that take the app's
mutex, and caught a line that was already inside a.mu.Lock(). Go's mutex
is not reentrant, so the test waited on itself until the suite timed out
after five minutes.
That call site was correct to begin with; it reads the manager directly
again, with a note saying why it is the exception.
Windows never saw it: the tests around it are Unix-only.
commit 18c1de365d1ab6635b749f66f075c4cf4aecafc1
Author: Bobby Anthene <142563527+noturbob@users.noreply.github.com>
Date: Tue Sep 22 21:25:19 2026 +0530
New visuals, a new demo, and a plural fix (#9)
* Dress the README in the site's colours and script the demo
The README opened with a logo and a link to an 8.9 MB GIF of a look the
program no longer has. It now opens with a banner drawn in the website's
palette — which is slat's own: canvas #08090a, xterm 252 for text, 44 for
the focused border — so the two front doors match.
The demo is a vhs tape rather than a recording nobody can reproduce:
`make demo` replays it against a freshly built binary and writes
docs/demo.gif. It records into its own XDG_RUNTIME_DIR, because the tape
ends by quitting the session and would otherwise take your own shells
down with it.
Media is down to one copy in docs/: the mp4 and its poster are gone and
the website's Watch section shows the same GIF the README does. The
source archive is untouched at 378 KB — everything added here is
export-ignored.
Also fixes what the README had outgrown: copy mode is listed as shipped
rather than as a limitation, the source layout names website/ instead of
claiming docs/ is the site, and the rice-it bullet mentions borders,
status format strings and animation easing.
* Count a line-wise yank in lines
Selecting a whole line with V and yanking it reported "copied 43
characters", which reads like the wrong thing was taken — and a
one-line selection showed "COPY 1 lines" in the status bar.
Report whatever the selection was made of: V counts lines, v counts
characters, and both are pluralised.
Found while recording the demo, where the status bar is on screen for
the whole copy beat.
* Shoot the demo again, in the colours we ended up with
The GIF in the README was recorded before the theming work: mist and
slate, a look neither the program nor the site has any more. This one is
the same idea in the colours they now share — canvas #08090a, xterm 252
for text, 44 for the focused border — and it covers the two things that
landed since: search-and-copy, and driving a detached session with
slat ls.
The session in it is real. A capture harness feeds a scripted slat
through slat's own emulator and records the cell grids, which are then
replayed in the film, so every character on screen is one the program
actually drew. It lives in the video project, out of this repository,
with the composition; docs/demo.gif is the only thing that lands here.
Drops the vhs tape added earlier the same day: two pipelines for one
GIF, and the one that ships is the other.
* Give the website the film as video again
A GIF is what the README has to use, because GitHub will not play video
in a readme. The site has no such excuse, and was paying 8.5 MB for the
privilege — and paying it again on every loop.
Same film, encoded for the web: 30fps, crf 24, faststart. 2.3 MB, which
is less than the old recording cost and a quarter of the GIF, with text
that stays sharp enough to read the status bar.
commit f334f71abb041f9e713b2dbf835c2796454398b8
Author: Bobby Anthene <142563527+noturbob@users.noreply.github.com>
Date: Tue Sep 22 12:32:45 2026 +0530
Select and copy in scroll mode (#8)
* Blink the cursors
The block after the headline is a terminal cursor, so it blinks like one:
a hard edge, no fade, on a 1.06s period. The cursors inside the mock
sessions blink with it, since a still cursor beside a blinking one reads
as a bug.
Anyone who has asked for less motion keeps a steady, visible block —
checked by sampling the computed opacity in both modes rather than by
watching it.
* Select and copy in scroll mode
Scroll mode could read a pane's history and search it, but not take
anything out of it — the most common reason someone tries a multiplexer
and goes back to the one they had.
It now has a cursor. h/j/k/l and the arrows move it and the view follows;
0 and $ go to the ends of a line; a search moves the cursor to the match,
which is how you reach a line forty screens back without pressing k forty
times. v selects characters, V selects whole lines, y copies and leaves,
and Esc steps back one level — dropping the selection first, and only
leaving scroll mode when there is nothing left to drop.
Copying goes out as OSC 52, which asks the terminal to put the text on the
system clipboard. That is the only method that works over ssh: slat runs
on the far machine, and the clipboard worth writing to is the one in front
of the person. Terminals that refuse OSC 52 can name a local command
instead, or as well:
[copy]
osc52 = true
command = "wl-copy"
Trailing blanks are dropped from every copied line, because a terminal
line is padded to the width of the pane and nobody wants eighty spaces.
The tests drive the same input path a client does, and decode the OSC 52
back out of the byte stream to check what would land on the clipboard —
including that a character selection copies exactly what is highlighted
and nothing was painted onto the screen instead.
commit 39639ececd18b5416b7568ffce3095e1b2c8f902
Author: Bobby Anthene <142563527+noturbob@users.noreply.github.com>
Date: Mon Sep 21 18:56:04 2026 +0530
Blink the cursors (#7)
The block after the headline is a terminal cursor, so it blinks like one:
a hard edge, no fade, on a 1.06s period. The cursors inside the mock
sessions blink with it, since a still cursor beside a blinking one reads
as a bug.
Anyone who has asked for less motion keeps a steady, visible block —
checked by sampling the computed opacity in both modes rather than by
watching it.
commit b80270446229faab598ea813d918544ac2a35e6c
Author: Bobby Anthene <142563527+noturbob@users.noreply.github.com>
Date: Mon Sep 21 17:15:43 2026 +0530
Publish the website, all of it this time (#6)
The squash that closed #5 captured the branch as it stood when the pull
request was opened, so the three commits after it — the spacing rhythm and
anchor landings, the glass chrome, and the fix for the terminal widening
the page on a phone — never travelled. Cherry-picking that squash brought
the same partial tree to main.
This carries the branch tip instead: the tree here is byte for byte the
website branch, deletions included.
Checked rather than assumed: the markers for each of those three commits
are present (min-h-svh, liquid, --section-gap, useFittedRows, min-w-0), the
site builds, the Go suite passes, and git archive is still 456 KB with no
website/ in it.
commit 480d851a7913ab169ea758541d4904e52f2caeca
Author: Bobby Anthene <142563527+noturbob@users.noreply.github.com>
Date: Mon Sep 21 12:41:21 2026 +0530
Keep the source archive to what builds slat (#4)
A source archive — GitHub's "Source code" download, and through it Debian's
orig tarball — should carry what it takes to build the thing and nothing
else. The demo media was already left out; the rest of the repository's
furniture wasn't, so the archive also shipped the website, the artwork, the
CI workflows, the release tooling and other distributions' packaging
recipes, including a generated .SRCINFO.
Three files were dead weight in the repository itself and are gone:
assets/logo.png and assets/social-preview.png (rasters nothing referenced —
the website serves its own copies) and assets/logo.svg, which was byte for
byte docs/logo.svg. The website needs its copy at that exact path because
Pages serves docs/ as the site root, so the README now points there and
there is one of each file instead of two.
Kept in archives on purpose: the Go source and its tests, README.md,
LICENSE, slat.1, config.example.toml, the Makefile, docs/design (how it
works) and docs/rices (example configurations — and a test reads them, so
an archive without them wouldn't build).
commit 8be58f08ca0236d21d0b601ea0211879b8b7a203
Author: Bobby Anthene <142563527+noturbob@users.noreply.github.com>
Date: Mon Sep 21 12:24:30 2026 +0530
Hand the whole look over: borders, animation and the status bar (#3)
The config was small because the ricing surface didn't exist. Themes only
recoloured what slat had decided to draw: `status_bar` was a bool, border
glyphs were a fixed map, and `animate` was one duration with a hardcoded
curtain character. None of the shape, the layout or the motion was anyone
else's to choose.
Now:
[borders] sharp, rounded, heavy, double, dashed, none —
or any of the eleven glyphs, your own
[animation] split and move durations apart, four easing
curves, the reveal style and its glyph;
animations = false turns the lot off
[status] left, right, tab and alert as format strings,
with {workspace} {tabs} {pane} {badge} {time} …
The status bar is the real change: its layout was hardcoded in DrawStatusBar
and is now written by whoever runs slat. Each placeholder carries the style
that suits it — the workspace in the accent colour, the active tab
highlighted — so a bar can be rearranged without anyone writing colour
markup by hand. The right side still wins when a terminal is too narrow,
because losing which pane you're in is worse than a truncated tab list.
Mistakes are refused at startup, not drawn: an unknown colour, a glyph two
columns wide (it would tear the layout), a placeholder or easing curve that
doesn't exist.
The older top-level `animate` still works as shorthand for both durations.
docs/rices/ holds four complete configurations — default, powerline, minimal
and a 16-colour ASCII one for a bare console — with a test that loads every
one of them, because a broken example is worse than none. Contributors have
somewhere to send theirs.
One thing slat can't give away: fonts. It draws characters, and which font
paints them belongs to the terminal emulator. Said so in the README, the man
page and the gallery, rather than leaving people to wonder.
commit 35cfb869ed1b8411de6f60e537ca80ad14929b32
Author: Bobby Anthene <142563527+noturbob@users.noreply.github.com>
Date: Mon Sep 21 11:43:32 2026 +0530
Move panes around the layout, and fix wait's exit code (#2)
* Report a closed pane as gone from wait, too
`slat wait 2 --for idle` on a pane that had been closed exited 1 with
"pane 2 is gone", while send, status and capture exited 3 for the same
thing — so a script couldn't act on the code the documentation promises.
One path had been missed.
The test now walks every command that takes a pane and asserts the same
code, instead of checking one of them and assuming the rest.
* Move a pane around the layout, with the swap animated
Panes could be selected by direction and swapped with "the next one", but
not moved — so a layout couldn't be rearranged the way a tiling window
manager rearranges windows. Now:
m move mode: h/j/k/l or the arrows walk the pane, q leaves
< > K J move it left / right / up / down, one press each
Both use the neighbour search that selection already used, then exchange
the two leaves in the layout tree; focus follows the pane that moved.
The exchange slides. The layout gives both panes their final size and
position first, exactly as it would without the animation, so each is
resized at most once and nothing reflows frame by frame — the frames in
between simply paint each pane's existing screen on its way across. The
cursor is hidden while that plays, since it would otherwise sit at the
destination detached from the pane it belongs to.
An earlier version of this only animated panes of equal size, which in
practice meant almost never: neighbours in a split differ by the border
column, so 50 and 49 was the normal case and every swap snapped.
It is worth being plain about the ceiling: a terminal is a character grid,
so this steps by whole cells and reads as a fast slide rather than the
continuous motion a compositor can do.
commit c2b9315dbc255edeefddf435286b60bd7d5fd1d7
Author: Bobby Anthene <142563527+noturbob@users.noreply.github.com>
Date: Mon Sep 21 11:18:15 2026 +0530
slat 1.0: agent control, Windows, themes, animation
* Design: agent control CLI for slat 1.0
* Add the agent control CLI
slat can now be driven from outside the terminal: scripts and AI coding
agents talk to a running session over its socket instead of pretending to
be a keyboard.
slat ls / status what every pane is doing
slat pane new / close panes, without stealing focus
slat send / run type into a pane
slat capture read a pane's text
slat wait --for … block until idle, input, exit or text=REGEX
The useful part is the status: a pane is idle when its own shell has the
terminal, working while a program runs, and input when that program has
gone quiet on a question, so an agent waiting for a build wakes up on
"overwrite? [y/N]" instead of hanging until the timeout. Detection uses
the PTY's foreground process group plus output timing, tunable under
[agent] in the config.
Control connections never attach to the session, so an agent running
commands doesn't disconnect whoever is watching the panes. Nothing leaves
the machine: slat still has no network code.
Exit codes are the contract: 0 ok, 1 error, 2 timed out, 3 the pane is
gone. Pane ids are never reused, so a vanished id reports 3 rather than
"no such pane".
Also fixes three things found while testing this:
- Foreground() compared the process *name* to the shell, so a nested sh
or a subshell read as idle while it was really running; it compares
pids now.
- Flags after a positional argument were silently ignored, because Go's
flag package stops at the first bare word — `slat wait 2 --for idle`
parsed as a wait with no condition.
- capture --lines counted the blank rows below the last output, so
`--lines 3` could return three empty lines.
- The [agent] TOML keys were kebab-case while every other setting is
snake_case, and mergeAgent looked for the kebab spelling, so those
settings were silently ignored.
* Show and announce panes that are waiting for input
A pane that has stopped on a question is the one thing a human needs to
know about while agents work in the background, so the daemon now watches
every pane's status instead of only answering when asked:
- the pane's tab is marked `2:shell ?` in the status bar, visible from
any other tab;
- the [agent] on_input / on_idle hooks run once on the change, detached,
with their output going to the daemon log rather than the screen.
Hook substitutions are shell-quoted, because %c is a line of output from
whatever is running in the pane: a prompt containing a quote or a
semicolon stays text instead of becoming part of the command. There's a
test for exactly that.
* Support Windows
Panes run on a ConPTY instead of a PTY pair, the client polls the console
for size changes instead of waiting for SIGWINCH, and the daemon socket is
an AF_UNIX socket in the user's temp directory (Windows has had those
since 1803).
All of it goes through golang.org/x/sys/windows, which slat already
depended on, so this adds no new module — which matters because every
dependency has to exist in Debian too.
The platform differences now live behind one interface, ptyProcess, rather
than scattered through pane.go: a PTY pair, a session and SIGHUP to a
process group on Unix; a pseudoconsole, pipes and a job object with
KILL_ON_JOB_CLOSE on Windows, so closing a pane still takes everything the
shell started with it.
What Windows can't do: ConPTY has no foreground process group, so a pane's
status there comes from output timing alone — idle or working, never which
program is running — and the reported directory is the one the pane started
in. The status heuristic already handled "the platform won't say", so this
needed no special case.
Hooks go through cmd.exe there, whose metacharacters can't be escaped, so
pane text is stripped rather than quoted, and every value is also exported
as $SLAT_PANE, $SLAT_TAB, $SLAT_STATUS and $SLAT_LINE for hooks that would
rather read the environment than a command line.
CI now runs the tests on windows-latest, and the Linux job cross-vets the
other two platforms. Shell-dependent tests are Unix-only; Windows runs a
smoke test that covers ConPTY, the socket and the control commands
end to end. Releases ship a windows zip.
* Add themes
Everything slat draws itself — the status bar, pane borders, the help and
banner overlays — takes its colours from a [theme] table instead of the
constants they were:
[theme]
name = "gruvbox" # default, gruvbox, nord, rose-pine, mono
accent = "#fabd2f" # or override any single colour
Colours are a name, a palette index 0-255 or #rrggbb, and a wrong one is
an error when you run slat rather than something odd on screen. Pane
contents are never restyled: the programs in them own their colours.
`slat --help` lists the built-in palettes, since a theme nobody can find
may as well not exist.
* Animate a new pane into place
A split used to snap in, which is hard to follow when a layout is already
busy. Now the new pane's area is revealed left to right (or top to bottom)
over `animate`, 90ms by default, with 0 turning it off.
Only the drawing is animated. The pane is its final size from the first
frame, so no program in a pane is resized more than once — animating real
pane rectangles would mean a SIGWINCH storm and every full-screen program
reflowing dozens of times per split.
* Fix three ways a busy pane could report itself idle
Found by running the CLI against a real session rather than only the tests:
- `read -p "Overwrite? [y/N] "` is a shell builtin, so the pane's own
shell is the foreground process and the pane looked idle while it was
waiting for a human — no status, no `?` in the bar, no hook. A shell
that has gone quiet is now checked against the input patterns too,
unless the last line ends the way prompts do ($ # % > ❯ ➜ » λ), which
is what tells "waiting for a command" from "waiting for an answer".
- A pane that had not yet printed anything had no recorded output time,
so time.Since(zero) was ~55 years and it read as idle. A pane counts
as having produced output when it starts.
- The cached foreground process could be 700ms stale, which is exactly
the window `wait --for idle` looks at, so `pane new --cmd 'sleep 3'`
followed by `wait --for idle` returned in 600ms with the command still
running. New output now invalidates that cache: output is the signal
that a program started or finished.
The last two together were one bug from an agent's point of view — wait
returning before the command it was waiting for had begun — so there's a
test for that exact sequence.
* Bring the README and the design doc up to date
* Fix the ConPTY setup the Windows CI run caught
First real run of this code on Windows. cmd.exe started, printed its
banner to the *runner's* console and exited at once, so the shell was
never attached to the pseudoconsole:
- The pseudoconsole attribute went through x/sys's typed wrapper, which
takes an unsafe.Pointer and retains it as a Go pointer. This
attribute's value *is* the handle, not a pointer to it, so the call
now goes straight to kernel32 with uintptrs — nothing fabricates a Go
pointer from a handle any more, which the race detector's checkptr
rightly objects to.
- The console's two pipe ends were closed immediately after
CreatePseudoConsole; they are now closed after the process starts, the
order Microsoft's own ConPTY sample uses, and the pipes come from
windows.CreatePipe so their lifetimes aren't also in Go's hands.
- Releasing the pseudoconsole is what unblocks a read in progress, so
reap now does that rather than only closing our end.
Also: the smallest possible Windows test, at the pane level, which prints
what the pane actually held when it fails — there's no other way to see
inside a CI runner. And TestSocketPathFitsSunPath is Unix-only:
$XDG_RUNTIME_DIR and sun_path's 104 bytes are POSIX concerns, and it was
asserting POSIX path separators.
* Read the ConPTY pipes directly, and report what the runner sees
The shell still came up empty on Windows, and from outside, "attached to
the pseudoconsole but silent" and "never attached" look identical. So:
- The pipes are read and written with ReadFile/WriteFile on the raw
handles instead of through os.File. These are synchronous pipes whose
other end belongs to the pseudoconsole, and Go's file machinery —
poller registration, finalizers, its own idea of when a handle dies —
has no business on them.
- A diagnostic test reports every step: the console handle, the pid, the
first bytes (or the silence), the child's exit code, and the process
list of the test's own console. That last one answers the actual
question: if the child appears on the test's console, it was never
attached to the pseudoconsole.
* Compare the Pane and raw ConPTY paths in one Windows test
The raw path passed on the runner while the pane came up dead, so the two
are now checked in one test, in that order: two pseudoconsoles in one
process could interfere, and "ConPTY doesn't work here" has to be told
apart from "Pane breaks it".
* Keep the console's own pipe ends open on Windows
The runner settled two questions: the shell *is* attached to the
pseudoconsole (its pid is absent from the test's console process list),
and the console's startup handshake does reach us. What actually happens
is that cmd.exe exits immediately with status 0 — what a shell does when
its input reaches EOF.
Microsoft's ConPTY sample closes the console's two pipe ends as soon as
the pseudoconsole exists, on the grounds that they have been duplicated
into the console host. Whatever is true of that on this Windows build, a
shell started that way does not survive, so slat keeps those handles
until the console itself is gone. Two handles per pane, and the shell
lives.
The test now also runs a one-shot `cmd /c echo` and drains everything a
ConPTY produces, which separates a broken output path from a shell that
won't stay alive.
* Fix the ConPTY deadlock the timeout dump caught
Keeping both of the console's pipe ends open stopped the shell exiting,
but the goroutine dump showed what it cost: ClosePseudoConsole blocked
for ever in one goroutine, a ReadFile on the output pipe blocked in
another, and everything else queued behind the sync.Once.
Holding the *write* end of the output pipe is the bug. The pipe can then
never report EOF, so the console host can't finish and the pane's read
loop waits on a shell that is already gone. Only the input end needs
keeping — that is what stops the shell seeing EOF and exiting at once —
so the output end goes back to the console host immediately.
release() now tears down in the one order that doesn't deadlock: the
input first, then the pseudoconsole (which lets the console host exit and
the output pipe break, unblocking a read in progress), and only then our
own ends.
* Bound the test timeout, and cancel superseded CI runs
A deadlock should fail in five minutes with goroutine stacks, not sit in
the queue until something else kills it — the stacks from the last one are
what found the bug. And a new push makes the previous run pointless, so it
is cancelled rather than left running.
* Probe what survives on a ConPTY: ping, /k, and a plain shell
The shell attaches (it sets the console title) and then the session tears
down before anything it writes is painted — even cmd /c echo never showed
its marker. These three probes say whether that is about the shell's input
or about any child at all: ping writes for seconds and never reads input,
/k runs a command and stays, and the third is the interactive shell slat
wants. Each reports how long it lived and its exit code.
* Give the child the pseudoconsole's standard handles
The probes on the runner separated the two symptoms: a ping child lived
its full two seconds but not one line of its output ever arrived, while
cmd /k exited in 12ms — output going nowhere and input at EOF, with the
console itself working fine (the shell set its title through it).
That is what happens when a child's standard handles are broken rather
than its console: without STARTF_USESTDHANDLES, CreateProcess copies the
parent's std handles into the child, and slat's daemon has pipes or the
null device there. With bInheritHandles false, the child gets handles it
cannot use. Setting the flag with all three handles left empty makes the
console host give the child the pseudoconsole's own instead.
This also corrects the previous commit's diagnosis: the shell was never
exiting because the console's input end had been closed — it was exiting
because its stdin was broken from the start. So the console's two ends go
back to being closed as soon as the pseudoconsole exists, the way both
Microsoft's sample and the existing Go implementations do it.
* Quote a shell path with spaces, and guard the attach
CreateProcess parses the command line itself, so a configured shell like
C:\Program Files\PowerShell\7\pwsh.exe was read as the program
"C:\Program" with arguments. Quoted now.
The ConPTY test also asserts what the first failure on the runner would
have shown immediately: the child must not be on slat's own console. And
it resizes the console once, since every split does.
commit ab47367a9410729228068ba328880ba2a421e503
Author: noturbob <bobbyanthenrao@gmail.com>
Date: Sat Sep 19 20:30:55 2026 +0530
Package 0.2.1; address sponsor review (#1148387)
- Man page now comes from upstream; drop debian/slat.1
- debian/copyright matches upstream LICENSE (noturbob), real name in Comment
- debian/watch v5, tracking upstream git tags
- Drop Depends/Static-Built-Using: debhelper compat 14 fills them in
- Add debian/salsa-ci.yml and debian/gbp.conf
- Maintainer: Debian Go Packaging Team; Vcs-* fields for salsa go-team
commit d14da2ca78e427d0329beed96df352d367965240
Author: noturbob <bobbyanthenrao@gmail.com>
Date: Sat Sep 19 20:17:33 2026 +0530
Keep demo media out of source archives
commit bd7459c12b7c5a0f85d7c2cec811f52e705399d8
Author: noturbob <bobbyanthenrao@gmail.com>
Date: Sat Sep 19 20:15:42 2026 +0530
Note that local GoReleaser dry runs need --skip=docker
commit 421504894a9ffeae7fbdf9dfe48ec0c01eacdd6a
Author: noturbob <bobbyanthenrao@gmail.com>
Date: Sat Sep 19 16:12:10 2026 +0530
Close the ITP bug #1148370
commit c058f5d33b283e3497296298c45d993012cd68b7
Author: noturbob <bobbyanthenrao@gmail.com>
Date: Sat Sep 19 15:49:51 2026 +0530
Initial Debian packaging for slat 0.2.0