Commit Graph

10 Commits (b2460d506feaf3bcbd6414b8c4da74ec4595ca41)

Author SHA1 Message Date
mula.liu bf04f2c105 The command line pays for its chrome at the same counter
Three rounds were spent on a TUI that drew several frames over each other on
a cp936 console, and the fix worked: the interface asks the console what it
charges, per character, and draws ASCII where the console charges more than
the layout paid. Meanwhile `squid status`, printed in the same window on the
same machine, still produced a Storage table whose rows were each a screen
and a half long. Nothing in `main.rs` had ever asked what a `█` costs. It
repeats that character twenty-eight times for a gauge and lets the console
do the arithmetic, and the console's arithmetic is different.

`priced` is where a line stops being text and starts being cells, and `row!`
is the one door the body of every report prints through: the eleven places
that draw this program's chrome — the status key/value rows, the volume
gauges, the process table, the tree, the history rows, the whitelist
bullets, the rule headings and their `●`, the doctor's table — all of them
now go through it. It is a macro rather than a helper so the format
arguments stay where they were written, and one door rather than twelve
`println!`s of which eleven remember the console, because the twelfth is the
bug this whole thing is about.

Two refusals are the interesting part.

Nobody is stopped from seeing what a report actually says. Point the output
at a file or a pipe and the text comes back exactly as it was, because a
file is not a console: whatever glass reads the archive tomorrow may well
afford the `█`, and an archive of `#` is a worse record for the sake of a
screen that was never looking. The gate is the same tty question the live
progress line already asked — may this line overwrite a line — so
`live_stream_is_tty` is now `human_stream_is_tty`, since the two questions
have the same answer and deserve one function that says what it is asked.
And `--json` prints data, never through this: rewriting a person's report to
flatter their terminal is a different bug with the same fingerprint.

The price is not measured, even though measuring is what the interface does,
for the reason in `console::prices_unasked`: measurement spends characters,
and a command line is a guest on the screen it is printed to, sitting in a
pipeline or in front of a shell waiting for its next prompt. So it takes the
pessimistic answer the code page implies, which costs it a plainer gauge on
a console whose code page overcharges characters its font could have
carried. `█` becomes `#` there. A table that fits is worth more than a
prettier one that does not.

`no_line_of_chrome_escapes_the_counter` reads the file, with strings,
character literals and comments blanked, and demands that every `print!`,
`println!` and `eprintln!` either go through `priced` or print JSON or print
nothing. The scan exists because this mistake cannot be seen from the
machine it was made on: `println!(" {}", plan)` standing among eleven `row!`
calls is correct on every terminal that charges one cell for everything,
including the one it was typed on, and arrives folded over in front of
somebody else. It reads character literals as literals only when they close
again promptly, because `'static` is not the start of a character literal
and blanking from a lifetime to the next quote hides half a file from an
audit whose entire job is to look at all of it.

On the box, same pseudo-console, same 100x30 window, three reports per
capture and every one of them complete to `MARK_QUIT 0`. On cp936 — the code
page the user's own window is on — the decoded stream contains no `█`, no
`░`, no `─`, no `·`, no `…`, no arrow: the gauge reads
`[#######################.....]` and the headings are underlined with `-`.
On 65001 the same report keeps 104 `█`, 120 `░`, 236 `─`, 32 `·` and both
arrows. Same bytes of intent, two currencies, and the receipt is now in
both.

`win-tui-capture.sh` takes `TUI_ARGS=` so this evidence is repeatable rather
than hand-built: the default still captures the interface and judges it
frame by frame, and `TUI_ARGS="status"` captures a report, where the judge
is simply how many `█` survived.

The architecture document tells the story as one paragraph now, because it
is one story: `console::prices` measures and hands the answers to the
interface, `console::prices_unasked` guesses from the code page and hands
them to the command line, and each side has a test that keeps the characters
it draws and the characters it priced the same list.

178 tests here, two of them this commit's, clean under clippy for the host
and for `x86_64-pc-windows-msvc`, `cargo doc -D warnings` quiet over the
platform and the command line.
2026-10-16 10:32:05 +08:00
mula.liu 687f9c6959 Say which console a frame was judged on, and stop blaming the interface for the shell
Three ways this pipeline produced a verdict that was not about the TUI.

The frame judge required every right border on a screen to land in the same
column. That was written when the widest window anyone captured was 100 columns
and the interface drew one card. At 140 columns the menu column and the panel
are two frames side by side — the menu ends at column 31, the panel at 140 — and
the rows where the panel has already finished genuinely do end at 31. A tidy
140-column screen was therefore garbled on every single capture, which is a
mistake the judge makes rather than the console, and mistakes the judge makes
should not have to be re-litigated on real hardware. The rule is now the one that
survives both layouts: the border columns of the widest rows are the picture, and
a row with a border column that appears nowhere in that picture means two
pictures of different sizes are stacked on one screen. `side_by_side` and the
narrow-card-under-wide-card case are both in `--selftest`, so whoever tightens
that rule again finds out there, in a millisecond, rather than on the box.

`win-tui-run.ps1` always ran `chcp 65001`, because UTF-8 comes back through the
capture with no decoding guess involved. It also means the probe always measured
a UTF-8 console, while the window being complained about sits on cp936 — and
which code page a console is on is exactly what decides what an unasked-for
character costs. `$SQUID_TUI_CP` picks the code page now, the runner reports it
as `MARK_CODEPAGE`, and the judge prints it on the first line of every report,
because a frame is only evidence for the console it was taken from. Both routes
are green on the box with the price list as it now stands: 140x35 on 65001, 101
settled frames, none of them overflowing, box-drawing intact; 100x32 on 936, 54
frames, same. The comments that claimed the ConPTY measures one cell because
UTF-8 is forgiving have been corrected too — it measures one cell on 936 as
well, which is a fact about a console with no font, not about a code page.

And when the runner itself fails to parse, the stream still contains a console:
a PowerShell error block, and then nothing. The judge said "no settled frame with
a border was ever drawn", which is true and useless, and it read like a rendering
regression badly enough that drawing code got changed because of it. A
`CategoryInfo` in the stream is now reported as what it is — the capture script
never started the interface — and it is a selftest case, so the excuse is on
record as belonging to the harness.
2026-10-15 22:28:49 +08:00
mula.liu dbc06c77cb The instruments that measured the two lies, on the box itself
`squid-platform::console` now refuses to trust a console's answer about its own
size or about the price of a glyph. It is entitled to that refusal only because
somebody measured both, on the machine, with scripts that could not cheat.

`win-tui-resize.py` grows the console *underneath* a running interface and reads
the screen back, then asks how many columns the right-hand borders sit in: one
column means a screen, two means two frames drawn on top of each other. That is
the resize bug made countable, and its header keeps the five facts about Windows
OpenSSH that shaped it — including that the resize has to be driven on `CONOUT$`,
because after the alternate screen went up, the process asking for the resize is
still describing the buffer nobody is looking at.

`win-tui-widths.ps1` is the same trick applied to a single character: park the
cursor on a known column, write one glyph, read the cursor back, and the cells it
travelled are that glyph's width *in this console*. It measures both write paths
separately — `WriteConsoleW` into the buffer, and encoded bytes through stdout —
because they genuinely disagree, and it reads the cell's contents back too, so a
character the code page quietly replaced cannot hide inside a width that happens
to look right. This is the measurement `symbol_cells` now performs in-process;
the script is what proved the answer was worth asking for, and it still answers
for a console the program cannot see.

`win-tui-clean.ps1` keeps the harness honest: a remote PowerShell left behind by
a dropped ssh session keeps the release binary's file handle open, so the next
build cannot overwrite it, and it later writes its `MARK_QUIT` into whichever
report file exists — a previous round testifying on behalf of this one. It kills
the tested binary and its own grower by command line, and nothing else.
2026-10-15 21:21:19 +08:00
mula.liu 8fd235b961 Judge a captured frame by what is on the screen, not by what was sent
`tui-frame-check.py` is the part of `win-tui-capture.sh` that decides whether a
run passed, taken out of the shell script so that fixing the judgement does not
require the real machine to run again — `TUI_REUSE=1` re-reads a saved byte
stream, which is how both bugs in this branch were confirmed fixed against
captures taken before the fix existed. `--selftest` feeds it six screens it made
up — two good ones and four broken ones, including a screen where every Chinese
character makes `len()` measure the frame too narrow — and fails if the judge
goes quiet on a bug or shouts at a good screen.

The four rules it encodes were each paid for with a false verdict:

* the right border is only trusted on rows whose *first* character is a border
  character, because the box-drawing bar also appears in prose and in ASCII mode
  as `|`, and reading the last one on a row found the wrong column;
* columns are counted by accumulated display width, not by `len()`, because a
  terminal emulator keeps one character for a glyph that occupies two cells;
* only a screen that was painted at least eight rows and seen twice is judged,
  so a half-drawn frame cannot be mistaken for a torn one;
* a row that ends in a border but starts with prose is a row sitting *on* a
  border — the shape the toast produced — which is how the judge caught a bug
  nobody had thought to look for.

`win-tui-run.ps1` was missing from the repository while `win-tui-capture.sh`
depended on it, so the proof the last commit described was not in fact
repeatable. It exists here, and it is the reason the captures are trustworthy:
`mode con cols=100 lines=30` fails silently on the ConPTY that Windows OpenSSH
allocates, so every earlier "capture at 100 columns" was a 120-column frame
reflowed by the emulator. It sets the size through `[Console]::WindowWidth` and
reports the size it ended up with, and the emulator replays that rather than the
one we asked for.
2026-10-15 21:20:58 +08:00
mula.liu 937d955937 Record what the Windows box proved, and keep the proof repeatable
`win-tui-capture.sh` drives the real binary over `ssh -tt`, which is the only
way to render the TUI the way a Windows console does: sshd allocates a
pseudoconsole, crossterm takes its Windows backend, and the bytes it emits are
decoded back into a frame locally. The existing smoke script cannot do this
because it forks its own pty, which is POSIX-only.

It now takes a key sequence, so the interesting case — a populated list, not an
empty panel — is the one that gets checked, and it keeps the fullest frame
rather than the last one, because quitting wipes the screen. It reports where a
replacement character appeared, since mid-stream means the console could not
draw the glyph and at the tail only means ssh truncated a frame on disconnect.

`win-hwcheck.ps1` measures the volume before and after a real deletion, counts
entries in the shell's Recycle Bin, and asserts the two agree; that is what
caught the missing undo flag. Its fixtures clean themselves up.

Windows moves from "cross-compile only" to verified on real hardware in the
roadmap. UAC elevation, the long-path manifest, and publishing stay pending.
2026-10-15 18:55:01 +08:00
mula.liu d74420f24a Ask NTFS for stored bytes, not for allocated clusters
`FileStandardInfo.AllocationSize` turned out to be the wrong question. Measured
against `fsutil` and `compact` on a real Windows 10 volume:

- it returns the cluster-rounded logical length for ordinary files, including
  1 GiB files extended by `SetEndOfFile` (NTFS does hand over the whole tail,
  and free space moves accordingly) and sub-cluster files living in `$MFT`;
- it reported the full 8 MiB for a file `compact` accounts as 1,572,864 stored
  bytes, i.e. it is blind to NTFS compression, which is the one way Windows
  really does hide size on disk;
- `FSCTL_QUERY_ALLOCATED_RANGES` reported that same compressed file as fully
  allocated, so "which clusters exist" is not "what do they weigh".

`GetCompressedFileSizeW` answers 1,572,864, matching `compact` byte for byte.
It takes the path we already hold instead of a handle, so it is one query per
file rather than a `CreateFileW` pair, and it keeps answering while another
process holds the file open exclusively — the normal state of a cache file.
That also removes the `ALLOCATION_PROBE_MIN` cutoff: it existed to avoid a
handle per small file, and small files on a compressed volume need the honest
number just as much.

Guard the zero answer behind `FILE_ATTRIBUTE_COMPRESSED`/`SPARSE_FILE` (free
from the `Metadata` we already have) so a deleted-but-still-open file cannot
zero out a total the user is about to act on, and read `GetLastError` to tell
failure from a genuine 4 GiB-minus-one length.

Tests: each platform now gets the fixture that provokes its own divergence —
POSIX holes for `st_blocks`, and a `compact`-compressed file for the Windows
path. The old Windows sparse fixture proved nothing: extending a file does not
hole out on NTFS, and `FSCTL_SET_SPARSE` is refused outright on this volume
(`ERROR_INVALID_FUNCTION`), as is `FSCTL_SET_COMPRESSION`
(`ERROR_ACCESS_DENIED`) even for a file we created ourselves.
2026-10-15 17:25:17 +08:00
mula.liu 7584811e91 Measure what NTFS actually allocated, and unbreak the /Applications test
Real Windows 10 hardware turned up two failures the macOS and cross-compile
checks could not see:

- squid-core::fs reported every file's logical length as its allocated size,
  because `allocated_bytes` returned 0 on non-Unix and `on_disk()` then fell
  back to logical. NTFS only answers the allocation question through a handle,
  so ask `GetFileInformationByHandleEx(FileStandardInfo)` for files big enough
  to distort a total. Files below the cutoff keep counting as their length,
  which is also what keeps MFT-resident entries — they report an allocation of
  0 — from shrinking a cache cleanup down to nothing.
- the "a plain user can still uninstall into /Applications" safety test hard
  coded a Unix path, so on Windows it asserted that a folder the policy never
  looked at was refused. The fixture now comes from the policy's own shared
  install folder, `/Applications` on Unix and the machine-wide program-data
  folders on Windows.

Also added:

- `a_written_file_reports_what_the_volume_gave_it`, the cross-platform
  invariant the missing backend silently violated.
- the sparse-file test now marks its file sparse via `fsutil` on Windows and
  skips when the volume will not cooperate, instead of pretending a hole
  exists.
- `scripts/win-sync.sh`, `scripts/win-check.ps1` and `scripts/win-hwcheck.ps1`
  for iterating against a LAN Windows host over SSH without git credentials.
2026-10-15 16:43:41 +08:00
mula.liu 122e81cb4d Windows: real platform layer, recycle-bin trash backend, cross-compile CI
- squid-core: trash moves behind a platform seam — Windows recycles via
  IFileOperation (shell owns $Recycle.Bin bookkeeping; ledger records no
  physical path there), Unix keeps the rename/copy path untouched
- squid-core: default cleanup anchors per platform; Unix-only helpers
  (getuid, statvfs-style trash dirs, symlink copy) gated
- squid-platform: windows.rs rewritten — installed apps from the uninstall
  registry (HKLM 64/32-bit views + HKCU, SystemComponent/patch filtering),
  BIOS/NT version keys for hardware/OS strings, sysinfo for volumes and
  running processes; winreg replaces the PowerShell stub
- squid-stats: COMPUTERNAME hostname off-unix; battery parsers gated
- CI: .gitlab-ci.yml with a Linux job that cross-checks the whole workspace
  against x86_64-pc-windows-msvc, plus a manual tagged Windows job driven by
  scripts/ci-windows.ps1 (build + test on a real machine)
- host (macOS) tests, clippy -D warnings and fmt stay green
2026-10-15 14:56:55 +08:00
mula.liu 4f1022f213 修改了README.md 2026-10-15 10:05:34 +08:00
mula.liu 54585ffc40 squid 0.1.0: macOS 磁盘清理(CLI + TUI) 2026-10-13 17:00:50 +08:00