Commit Graph

8 Commits (345f8391edbf4b7324e2759bf251f5568cf06255)

Author SHA1 Message Date
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