Commit Graph

14 Commits (dev)

Author SHA1 Message Date
lijunjie e3eba338a7 借鉴 Mole 的 12 项安全架构与交互全部落地;修复启动项开关失效
- 空间清理:扫描实时计数(已统计 N 文件 · X,进度封顶 99%);分类算完一个亮一个;
  清理点/文件行「X 未使用」休眠标签;node_modules 可删依据面板(锁文件/安装记录/
  手改检测/Git/年龄);低风险走底部绿色内联确认条(Esc 取消),对话框新增
  「刚刚逐路径复核过」审计面板;结果页按原因分组展示未处理项并给下一步按钮;
  清理清单导出 Markdown(含依据与受保护项)。
- 存储空间:新增「隐藏的吃空间大户」(更新缓存/休眠/页面文件/WinSxS/手机备份/旧下载);
  文件夹测量缓存 10 分钟 + 新鲜度标注 + 重新测量,删除后缓存自动作废。
- 引擎:微信/QQ 聊天文件、浏览器 IndexedDB 离线数据、搜狗词库等个人文件在扫描结果
  以待解锁行呈现且删除层强制拒删;preflight 删除前逐路径复核;白名单消费审计
  (设置页标注每条规则最近是否命中)。
- 修复:权限管理开机启动项开关点击无效/弹回——StartupApproved 标记改用最小注册表
  权限写入(原 KEY_ALL_ACCESS 在安全软件驻留的机器上直接被拒),拒绝访问时自动
  UAC 提权重试并回读核实;计划任务/服务同样支持提权通道;开关失败新增红色气泡。
- 无头浏览器 29 项点击断言全过;cargo test/clippy/fmt、pnpm check/build 全绿;0.1.10 重新打包。
2026-11-20 18:54:02 +08:00
lijunjie a3253ad38f Squid 0.1.10:升级安装包清理、CPU 面板、回收站文案与桌面小工具降占用
- 清理新增「升级安装包」分类:已知应用精确规则(微信/企微/WPS/网易邮箱等)+ AppData 启发式扫描;只匹配安装包形态、≥7 天、1MiB 起,运行中应用锁定;删除确认弹条「跳过升级包,只删其余」
- 桌面小工具新增 CPU 面板:总占用曲线 + 整行逻辑核心渐变柱(绿→黄→橙→红连续插值,悬停显示核心 N 百分比,0 起编号,柱宽随核心数自适应)
- Windows 上「废纸篓」文案全链路改为「回收站」(bootstrap.binNoun 驱动,macOS 不变)
- 常驻 CPU 优化:轻/全两档采样(system_snapshot(full))、双窗口共享 2s 采样缓存、主窗口收托盘与小工具折叠时完全停止轮询
- 修复小工具自适应尺寸→重锚定 IPC 死循环(主进程+渲染进程空转、每循环写一次 widget.json);同时修复由此摘除 prefs 依赖引入的面板高度不自适应回归
- 版本升至 0.1.10(4 处同步),release/0.1.10 全套发布文件(安装包/便携包/SHA256/更新清单/一键安装.bat)
2026-11-19 00:08:56 +08:00
lijunjie 67a68b4fbb Squid 0.1.6-0.1.9: 权限管理、桌面小工具、概览/卸载修复
权限管理(新增页):开机启动项按软件分组 + 中文软件名 + 每行图标;
右键菜单对齐电脑管家颗粒度(文件/文件夹/桌面/驱动器/所有对象 横向
分类导航、创建者列、模块图标、占位名回退安装目录名、系统内置过滤、
模块去重);弹窗拦截(窗口/规则图标、一键建规则、常驻观察者)。
数据源 crates/squid-platform/src/permissions.rs + src-tauri manage.rs。

桌面小工具(新增,仿飞牛):桌面层无边框窗口(HWND_BOTTOM,压在
壁纸上、其他窗口下),运行状态圆环 / 网络与磁盘曲线 / 存储空间条,
独立面板开关、不透明度(90-100)、频率、停靠角、折叠记忆、拖拽位置
持久化;主界面「桌面小工具」管理页 + 托盘开关;widget.json 持久化。
src-tauri/src/widget.rs、src/pages/Widget{Window,Page}.tsx、
src/components/WidgetPanels.tsx。

概览页:本机配置面板(主板/CPU/内存条/硬盘型号/显卡,原生 API 读取)、
Windows 11 版本识别修复(构建号规则)、盘符百分比、无滚动的紧凑布局。
squid-platform hardware_info + squid-stats gpu_usage 字段。

卸载应用:EstimatedSize/实测目录修复 0 B;应用图标(DisplayIcon 解析、
老图标 AND 掩码、.lnk 目标跟踪)。

安装:NSIS 自定义模板静默覆盖升级(不弹卸载旧版页,继承安装位置与
%APPDATA% 配置);管家环境发布必带 一键安装.bat(复制到 C 盘 %TEMP%
再启动,docs/RELEASE.md 记录);release/0.1.6-0.1.9 归档。

测试:scracth 目录写入被端点防护拒绝时优雅跳过(core/engine/rules/tui);
widget 序列化契约 3 个新单测;工作区 199 测试全绿。
2026-11-18 11:52:36 +08:00
mula.liu b2460d506f The system panel may stop a process, once it has asked who is sitting at that number
The system panel has listed processes for a while, and a list of what is running
gets one question asked of it more than any other: this one is wedged, make it
stop. A panel that can name the hung app and then shrugs is scenery, so the
answer here is yes — spent through the machinery the interface already has for
irreversible things, a dialog that names what it is about to do and a log line
afterwards that says what it did.

The *how* is two lines and not very interesting: `kill(2)` with `SIGKILL`, or
`OpenProcess(PROCESS_TERMINATE)` followed by `TerminateProcess`. Both are the
same promise, which is why `squid_platform::process::force_stop` is called a
forced stop on every platform and the dialog says 强制结束 rather than anything
about saving. There is no TERM-then-KILL handshake in here, because there is no
polite promise to keep: the second line of the dialog is 它不会有机会保存任何内容.

`squid_stats::Sampler::stop` does not use `sysinfo`'s own `Process::kill`, and
the reason is the shape of its answer. It returns `false` for every way a stop
can fail, and two of those ways want opposite things from the reader. `ESRCH`
means the process left on its own and nothing is owed but a redraw; `EPERM`
means it is alive and the reader should go find an elevated terminal. Windows
serves the same pair up as `ERROR_INVALID_PARAMETER` and `ERROR_ACCESS_DENIED`.
A bool cannot carry that difference, so squid makes the call itself and keeps
the words the OS gave, quoted inside a sentence this program owns — the OS's
sentence arrives in the language of the OS, and translates no further than its
own frame.

The *whether* is where the damage is, so it is answered twice. First by rule, in
`squid-platform`: never this squid, never the first process of the machine, and
on Windows never one of the six names a boot rests on. Those rules exist because
the operating system does not enforce all of them. An unelevated squid on macOS
cannot reach `WindowServer` whatever it tries; an elevated squid on Windows
*can* open `csrss.exe` for termination, and the reward for one misplaced Enter
is a machine that reboots without asking. Six names is the whole cost of that
guard. `svchost` is deliberately absent from it, because it hosts services a
user may genuinely need to restart and the machine survives losing one — which
is the test a name has to pass before it belongs on that list.

Then by the operating system, whose answer is the only one with any authority
over this user, this token, this moment. Between the two sits the question the
platform module cannot answer, because it is a question about a sample rather
than about a pid: is the process holding this number still the process whose
name the user read? Pids are seat numbers, handed out again, and a process table
is drawn the moment the panel opens and read from seconds later. So
`squid_stats::Sampler::stop` reads the pid again through the new `sample_of`,
applies the rules to the process that is really there, and calls a name that no
longer matches *gone* — the thing that was pointed at really is gone, whichever
direction the pid moved. `shown_name` is why that comparison means anything:
macOS hands over a path and Windows a bare name, and the process table had been
trimming with `split('/')`, which does nothing at all to a Windows path. Nothing
was wrong on screen, because the name was already short there; it became
evidence, and evidence has to be spelled one way.

`x` is the same verb it has always been. On the three file panels it makes the
row under the cursor go away; the system panel has nothing to delete and does
have a process, so the same finger reaches the same meaning, and
`x_is_still_the_delete_key_on_a_list_of_files` pins the old meaning down so that
this one cannot push it aside. `d` still deletes everywhere. The rules are
applied in `ask_stop_process` *before* the dialog rather than after the answer:
a dialog that can only be answered "no" teaches the user that the dialog is
theatre, and the toast that names the rule says the same thing in less time.

Three crates now each hold a `sleeper()`, which is a duplication worth keeping
on purpose. The thing under test has to be a process — `sleep 60`, or
`ping -n 60 127.0.0.1` where `sleep` is not — and a kill feature tested against
a struct is a kill feature that has never killed anything. Twelve tests come
with this: five in the platform module, including the boot list and a vacant pid
reporting itself as gone; three in the sampler, one of which hands a pid to
`stop` under the wrong name and then checks that the innocent process is still
running; four in the interface, walking `x`, `y`, and a refusal from the key
press to the corpse being reaped. 190 tests green across the workspace, with
`cargo fmt --check` and `cargo clippy --workspace --all-targets` clean for the
host and for `x86_64-pc-windows-msvc` — the target where the boot list,
`TerminateProcess` and the parameter-is-incorrect mapping compile at all, which
is also where `the_processes_a_boot_rests_on_are_named_not_guessed` exists.

The Windows 10/11 box carries the part a mac can only compile. `squid.exe`
there builds with `Win32_System_Threading`, clippy clean under `-D warnings`,
185 tests green; and the dialog was read off the screen rather than off the
buffer — `TUI_COLS=140 TUI_ROWS=35 TUI_CP=936`, 2604 samples of the raw ConPTY
stream, 291 settled frames, 0 of them failing the layout judge, including the
confirm itself: `╭ 结束 iNodeCmn.exe? ╮` / `pid 9080 · 1.2% · 15.4 MB` /
`它不会有机会保存任何内容` / `回车 / y 确认 · n / esc 取消`, and 「已取消」 after `n`.
`docs/ARCHITECTURE.md` gains the module and the key, and one of its diagrams
finally admits that `squid-stats` has depended on `squid-platform` for weeks.
2026-10-16 11:49:10 +08:00
mula.liu f9f86f6103 The app list counted its own header as a row, and the cursor paid for it
Uninstall came back from the Windows box saying the thing it had already said
on macOS: once there are more apps than a page, paging down leaves the list
with no highlight anywhere. Two consoles that have spent this branch being
taught what a `█` costs agree with each other about nothing, so a complaint
that survives both of them is not standing in the console. It was standing in
`draw_uninstall`, and it had been there since the panel was written.

The panel pushes its column header — `size name version source`, plus a filter
chip while a filter is standing — into the same `List` widget that holds the
apps, and paints the highlight by asking whether `row == cursor`, where `row`
counts the apps that `visible()` returned. `ListState::selected` is handed that
same `app.uninstall.cursor`: a number in the space of visible apps, in a widget
whose rows are that space plus one, plus two with the chip. ratatui spends
`selected` on exactly one thing in this configuration, because `highlight_style`
is empty on purpose — the row paints its own highlight so that a cursor survives
a terminal with no colour at all — so the disagreement cannot mispaint a row.
What it can do is decide which rows exist on screen: the scroll window is
positioned around the row one above the cursor. While the list fits in the card,
or while the cursor is high enough in a list that does not, the cursor is inside
the window either way and the header costs nothing. That is why this needed a
machine with more installed apps than a fixture has, and why the same binary
lied the same way on both platforms.

`ScanPanel::lines` has never shown the symptom, and the reason is worth naming
rather than admiring: it holds entries and nothing else, because the heading of
that card lives on the `Block`. One widget, one index space, nothing to drift.
The uninstall *plan* was taught the same lesson from the other direction — it
used to swap item zero for a bundle heading, which held only while the `.app`
was the largest thing in the plan, until a container outgrew it and every row
under the heading sat one line away from its cursor. The app list was the third
place a header had been allowed to spend a row, and the only one nobody had
asked about.

The fix declines to count anything. `chrome` and the entries are two constraints
of one vertical `Layout`: the `Paragraph` takes the first rectangle, the `List`
gets a rectangle holding entries only, and `selected` and `band()` are back to
describing the same rows. Nowhere in the file is `cursor + header_lines` written
down, because an offset is the thing that just went wrong, and the next line of
chrome added to this header would need one of its own.

`the_app_under_the_cursor_is_the_row_that_is_on_screen` is the regression test,
and it loops over every cursor position rather than picking a deep one, because
whether one deep cursor fails depends on how tall the card happens to be where
the test is running — which is a measurement of a machine, not an invariant. For
each position it draws 140x34 and asks the buffer two questions: is the app under
the cursor on the screen at all, and is the cell it landed on wearing the accent
background and the bold that a highlight paints. The series runs twice, once with
the filter chip on screen, because the chip is the second row of the two index
spaces that were drifting apart. Before the fix it stops at cursor 25 with "the
app under the cursor is off screen". Nothing on the screen had been drawn
wrongly, which is the shape of this bug: every row was correct, and the only
thing missing was the cursor.

68 tests in the interface crate, one of them this one, green; `cargo fmt
--check` and `cargo clippy --workspace --all-targets` clean for the host.
2026-10-16 11:17:18 +08:00
mula.liu cc678dee21 Put the price list beside the console, since both programs pay it there
The exchange that stops the TUI overflowing lived in `squid-tui`, next to
the renderer, because that is where the bug was found: several copies of one
frame left on a cp936 console, because `─│█░·…↑↓✓` cost two cells there and
one cell in the layout. But the thing that was wrong was never specific to a
renderer. It is a fact about a console — what this glass charges for a
character whose price Unicode left unsettled — and a fact about a console is
worth exactly as much to the next program that draws on it. `squid status`
draws a volume gauge by repeating `█` twenty-eight times and rules a heading
with `─`. Same price. The difference is that the command line had nobody
asking it.

So `currency` now lives in `squid-platform`, beside `console`, and says in
its own documentation why it is there rather than beside the interface: the
command line and the interface buy the same screen at the same counter.
`Exchange` is the table — indexed by code point, holding the replacement
rather than a bit saying *this one is wrong* because the character is what
the caller needs, and built only when this console actually overcharges,
which is what makes `afford` free on the terminals where there is nothing to
repair. `disputed` says which characters are worth asking about, `cheaper`
what each is worth in characters the console accepts, `witnesses` turns
pieces of chrome into the list of questions to ask. `squid_tui::glyphs`
keeps the half that cannot travel: the walk over a finished ratatui
`Buffer`, which is a question about somebody else's library, now a `Carry`
trait implemented for `Exchange` so that the table and its spending still
read as one motion.

The tests went with their subject rather than staying where the code used to
be: what a shading block costs, and what it is worth in `.`, is a question
about prices, so those seven are in `currency` now, and what is left here is
about frames — three that draw a `Buffer` and check where the borders land,
one that reproduces the original overflow, and the two that hold the
invariant worth defending, that the glyphs this interface draws and the
glyphs it asks the price of are one list. A glyph drawn but never priced
looks correct on every terminal that charges one cell for everything,
including the one it was typed on.

176 tests here — the same number as before the move, which is what a move
ought to leave behind — clean under clippy for the host and for
`x86_64-pc-windows-msvc`, and `cargo doc -D warnings` quiet over both crates.
On the box, with only this commit applied: `RESULT: OK`, and the interface
regression at 140x35 on the code page the complaint came from — 890 samples,
90 settled frames, every one measured and none rejected, box-drawing intact.

One drive-by: `Prices::implied` documented itself by linking to a private
function, which `cargo doc -D warnings` refuses, so the link names the
function instead of promising a URL to something nobody outside the module
can reach.
2026-10-16 10:31:42 +08:00
mula.liu 345f8391ed The probe measured the distance from a cell nobody moved
`symbol_cells` asked the console one question — what does a box-drawing bar
cost — and spent the answer on sixty characters. That was already the wrong
shape of answer: what decides a price is the code page and the font the console
was left on, and nothing promises the box-drawing set and the block-shading set
land on the same side of it. But the measurement was worse than the shape, and
this is the part worth writing down.

To price a character the probe asked the console to move the cursor to an
anchor, wrote the character, read the cursor back, and computed `after.X -
at.X`: the distance from the anchor it had *requested*. On the console this was
chased on, `SetConsoleCursorPosition` returns success without moving anything.
Every read therefore returned the same cursor, and the "cost" of the nth
character was n. The temporary trace said it plainly: 1, 2, 3, and on up to 60.
`match cost { 0 => None, 1 => Single, _ => Double }` then read every character
from the third onwards as two cells wide, which is how a UTF-8 console that
charges one cell for the lot ended up with its rounded card downgraded to
ASCII, and how the earlier "this console prices bars one cell and blocks two"
found its evidence. That split was never measured. It was a counter.

The distance between two reads is the only number here that means what it looks
like, so that is what is read now: ask where the cursor is, write, ask again,
and the step is the price. A step that cannot be a price is no answer at all —
`price_from_step` accepts one cell and two cells and refuses zero, negatives,
three, and sixty, so a cursor that never moved produces a code page's guess
rather than a layout believing a number with no cells behind it. A read that
changed rows is no answer either, and neither is a row with fewer than two
columns left to answer in, and `SetConsoleCursorPosition` is still called but
its return value is deliberately ignored: a ruler that is obeyed asks all sixty
questions of the same cell, and a ruler that is ignored walks one row, which the
characters get wiped out of either way.

Because a ruler can lie in ways that still produce plausible numbers, `prices`
asks for `A` first. `A` costs one cell in every table that measures characters,
so an answer of anything else means the probe is not reading cells, and it says
"symbols unreadable: A does not cost one cell" and takes the code page's answer
instead of laying a screen out against the lie.

The answers are kept as a price list, not a verdict, and `squid-tui` asks it
only about the characters it means to draw (`witnesses`), so a console that
overcharges the shading but not the rules keeps its rounded card and gives up
only the gauges inside it. The module documentation no longer claims a split
price was measured on cp936: what the ConPTY measured there, as on 65001, is one
cell for all sixty. What remains from the real window is the symptom — a card
that fit and a gauge inside it that did not — which is the reason for the list,
not evidence about that box.

Tests: the fair-priced-and-dishonestly-priced console still downgrades only the
disputed set, and `a_step_that_cannot_be_a_price_is_not_an_answer` keeps sixty
from ever being a price again.
2026-10-15 22:28:35 +08:00
mula.liu 4fca6cd0bc Name the system the platform reported, not the one the row was written for
Found while reading a captured Windows screen against the machine that produced
it: the Power card printed `LENOVO 20SDA09HCD · macOS 15.1` on a Windows 10 box,
because the operating system was hardcoded in the `format!` while the platform
layer had been answering correctly all along. `host.os_version` is already
`Windows 10 Pro (build 18363)` there and `macOS 15.1 (24B83)` here, so the card
was naming a system twice and getting one of them wrong.

Truncation had it backwards too. The row squeezed whichever half it liked, and
the half that fell off the end on a narrow console was the build number — the one
number that decides whether Windows Terminal exists, whether the buffer can be
resized, whether the glyphs cost one cell or two. The machine model is now the
half asked to give room, and when fewer than six characters of it survive it
leaves the row entirely.
2026-10-15 21:20:37 +08:00
mula.liu 47ac6675d3 Stop the toast from cutting a hole in the card it sits on
The other half of the 花屏 report, and it had nothing to do with Windows: the
same coordinates are drawn on every platform, and on a console a repaint is what
the user reads as the screen.

The toast was pinned to `height - 3` of the *frame*, which is the panel card's
bottom border. `Clear` then removed as many cells as the text needed and left the
untouched tail of the border standing behind it, so the row read
`功能菜单 — 上下键选择,回车返回 ------╯`: half a sentence, half a frame, the
border turning into prose halfway across the screen. It appeared the moment the
menu opened and tore again on every key that answers with a toast, which is what
choosing a function does — hence "pressing 1 shows it twice".

The chip now floats on the card's last inner row, one cell inside each border, so
it may still cover a row of the list (that is what a toast is for) but cannot
reach an edge. It also draws *under* the popups: a four-second message must never
be the reason a dialog loses a border. The test draws the frame with and without
a toast and compares every row that starts a bottom border, which is the
invariant the bug broke — a border has to survive a toast unchanged — plus that
the toast is still readable, and still inside the card that carries it.
2026-10-15 21:20:27 +08:00
mula.liu ca53d1d140 Ask the console what it holds, and what it charges per cell
Both numbers an interface is laid out against used to be taken on trust: the
size the terminal reported, and the one column per glyph that a layout measured
in columns pays for. On the Windows console in front of us, both were wrong,
and both failures arrive at the same place — cells written past the end of a row
reappear at the start of the next one, so the screen becomes several copies of
itself at several offsets and looks like a renderer that cannot count.

`squid-platform::console` measures instead of trusting. It asks three questions
because a console has three ways to be too optimistic — the window, the buffer
behind it, and the largest window it could show at all — and it asks them of the
buffer being *shown*, because entering the alternate screen on a legacy console
activates a second buffer while the process keeps holding the handle it started
with, which then describes a screen nobody is looking at. A window wider than
the cells that exist is where the wrapping starts, so `repair` asks the console
for the cells it does have; a window that slid down its own scrollback moves the
picture without moving the size, which is why the renderer watches the offset too
and wipes rather than diffs when the screen moved under it.

The second measurement is what makes a whole screen break at once. East Asian
Ambiguous characters have no agreed price, and a console left on a Far-Eastern
code page charges two cells for exactly the class of characters an interface is
built out of: the rules, the shading, the arrows, the ticks, the middot. ratatui
charges one, so every row of the layout is longer than the glass by the symbols
it contains. `symbol_cells` writes one box-drawing bar and reads how far the
cursor moved, because the two things that decide the price — code page and
font — are both set outside this program, and `chcp 65001` moves the same bar
back to one cell on the box that charges two.

`squid-tui::glyphs` then rewrites the finished frame one column for one column:
the rules become `|-+`, the gauges `#`, the arrows `<^>v`, so the rows fit
without the layout moving at all. Chinese text and ordinary letters are left
alone — neither is ambiguous, so neither caused the overflow, and a person's
paths and process names are not what an alignment bug should be allowed to
rewrite. `SQUID_SYMBOL_CELLS` overrides the measurement for the case the
measurement cannot reach: over ssh this program measures the console sshd made
for it, not the one on the glass. `SQUID_CONSOLE_TRACE` writes the two buffer
answers side by side, since a hand-made resize leaves no other evidence.
2026-10-15 21:20:14 +08:00
mula.liu de5a39c0fb Give the formatter the lines it had been asking for
`cargo fmt --all --check` had opinions about three call sites that were already
wide enough to need breaking, and the incoming Windows work touches all three
files. Split off so the commits after this one contain only the changes they
are about.
2026-10-15 21:19:33 +08:00
mula.liu 34d88d6e33 Draw what the Windows console can actually carry
Measured by driving the real binary through a pseudoconsole that sshd hands out
(`scripts/win-tui-capture.sh`), then decoding the bytes it emitted.

The lock glyph was U+1F512. Every astral-plane character comes back out of a
conhost/ConPTY session as U+FFFD followed by the glyph, i.e. one cell too many,
which shifted every locked row in the list by one column. `⊘` is in the BMP,
one cell wide, and survives the same session; the other glyphs in use were
checked the same way.

A row wider than its card used to spill: `joined` collapsed the filler to
nothing and the terminal cut off whatever came last, which is the right half —
the delete mode the user is about to act on. Now the left half yields, giving
up whole spans before cutting one in half. This is what the longer Windows name
for the recycle bin exposed at 100 columns, where "empties only with the
Recycle Bin" had swallowed "delete to · Recycle Bin" whole.

The status row's trailing note is the one part of that line the user is not
acting on, so it is dropped rather than allowed to push the mode off the card.
Both languages were re-checked on the box afterwards: no replacement characters
left, and the note still shows wherever it fits.

`the_recycle_bin_is_called_what_the_os_calls_it` pins the new copy rule; the
group-name test now expects the operating system's word for that one group,
which is why it fails on Windows and passes on macOS until the rule is stated.
2026-10-15 18:54:51 +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 54585ffc40 squid 0.1.0: macOS 磁盘清理(CLI + TUI) 2026-10-13 17:00:50 +08:00