feat(desktop): a simpler Keep This Mac Awake menu

The owner found the options confusing after the first test build. The
menu now reads Off / While Agents Work / Always, then on a MacBook
Only When Plugged In and With the Lid Closed…, then one status line.

- "Always While Codeman Is Open" is now "Always"; the status line says
  "Awake: Codeman is open".
- "Only on Power Adapter" is now "Only When Plugged In".
- "Remove the Lid Helper…" is gone: the lid item is the helper.
  Ticking it installs the helper behind the administrator prompt,
  unticking it removes it behind another. The setting changes only
  once the prompt's command ran, so a cancelled prompt leaves the item
  as it was.
- Shorter status lines ("Awake: agents working, lid closed too",
  "Paused: on battery", "Sleeps as usual: no agent working").

Config keys and values are unchanged, so a saved choice carries over.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

CLAUDE.md

@@ -243,8 +243,6 @@ The terminal provider scans `terminalLinkLine()`, which extends `terminalPathLin
 
 **File Viewer edit mode** (issue #212): the file-preview overlay edits workspace text files in place: `GET .../file-content?edit=1` + `PUT /api/sessions/:id/file-content`, policy in `src/config/file-editing.ts`. This is a **third file surface and the only one that writes file contents** (the path picker's New folder creates folders only): read-path confinement (realpath + workspace + ownership, where an absolute path inside a followed outside worktree (`SessionState.outsideWorktree`) counts as a second workspace root) plus sensitive/blocked/`.git` denies and an extension **allowlist**; writes are `wx`-temp + rename (no `O_CREAT` anywhere = edit-in-place is structural); optimistic concurrency via sha256 `baseHash` → 409. ⚠️ `edit=1` never truncates and the client must never save a plain-preview buffer (the 500-line truncation would silently delete the rest). ⚠️ CRLF/UTF-8 guards: EOL re-applied server-side, non-UTF-8 refused via round-trip compare. → [architecture-invariants#file-viewer-edit-mode](docs/architecture-invariants.md#file-viewer-edit-mode), `docs/file-viewer-edit-plan.md`
 
-**Files panel delete** (salvaged from #529; `DELETE /api/sessions/:id/files?path=`, the × on a file row of the Files panel, tree and search results): removes ONE regular file and is the **only file surface that deletes**. It takes the edit route's confinement and guards whole (ownership via `findSessionOrFail`, `validateLocalSessionFilePath` behind `withGuardedOutsideWorktree`, so an absolute path in a followed outside worktree obeys the same rules, sensitive/blocked/`.git` 403), and both spellings are checked, the realpath and the path as named. ⚠️ **A symbolic link is refused (400), never followed**: the confinement check returns the REALPATH, i.e. the link's target, so an `unlink` of it deleted `CLAUDE.md` for `AGENTS.md -> CLAUDE.md` and left the link dangling. The final component is `lstat`ed on the path AS NAMED, only a plain file goes on, the inode is compared again before `unlink`, and `unlink` never follows a final link. A dangling link fails realpath and reads as 404. ⚠️ Remote sessions are refused before any path check (a same-named local folder would take the delete), and so are adopted ones (the `/tmp` file-surface exception is not copied to a new surface); Docker workspaces are allowed like the edit route. The workspace (and the outside worktree root) is probed bounded first (#516, `422` on a dead mount). ⚠️ The button is bound from the row's escaped `data-path` in the `.file-tree-item` loops, NEVER an inline `onclick` (`encodeURIComponent` leaves `'` alone, so `x'-alert(1)-'.txt` ran script); it asks with `confirm()`, reloads through `_reloadFileBrowserKeepingQuery()` so a search re-runs, stays visible under `@media (hover: none)`, and is not drawn for remote or adopted sessions. Tests: `test/routes/file-delete-routes.test.ts`, `test/file-delete-ui.test.ts`. → [architecture-invariants#files-panel-delete](docs/architecture-invariants.md#files-panel-delete)
-
 **Files panel search** (COD-236, the `q` param on `GET /api/sessions/:id/files`): `compileFileQuery()` (`utils/file-query.ts`, pure) compiles the query into a predicate the server-side walk prunes with; a query returns a FLAT match list and the walk recurses past non-matching directories. An empty, whitespace-only or overlong (`MAX_QUERY_LENGTH`, 256) query compiles to `null`, keeping the default tree response byte-identical. ⚠️ **Never compile a glob into a RegExp** (`*a*a*a…` backtracks and freezes the event loop for the whole server): `globMatch()` is a two-pointer wildcard walk. Tree and search share one walk shape: a per-directory round-robin (breadth-first, so fair per directory, not per subtree) over one 5,000-node budget, where a folder's own files count as one share beside the subfolders it just found (`walkTurnEnd()`). ⚠️ That budget caps what is LISTED, never what is read: a read keeps only what the listing can use (`readWalkFolder()`) and `MAX_WALK_ENTRIES_READ` (250,000) stops opening folders, or one GET reads the whole workspace into memory. ⚠️ A folder below the walk's root is probed (#516) before its `readdir`, and anything but `directory` is skipped unflagged. ⚠️ A directory has its node before it is read, so every cursor still queued or unread when the walk ends must get `incomplete: true` or it reads as an empty folder. → [architecture-invariants#files-panel-search](docs/architecture-invariants.md#files-panel-search)
 
 **Files panel in a worktree** (#765, `src/live-worktree.ts`, `root=live` and `root=live-any` on `GET /api/sessions/:id/files`): Claude's EnterWorktree moves the process, and `paneCwd` follows it (tmux reads the process cwd, measured on 2.1.318, back out on ExitWorktree too), while `workingDir` stays the session's identity. `refreshLiveWorktree()` (server.ts) turns a changed `paneCwd` into `SessionState.liveWorktree` by reading the `.git` FILE (never spawning git), walking up and stopping at `workingDir`, a repository or submodule of its own, or anything unreadable. That is the lookup for a pane inside `workingDir`; a pane outside it goes to `findOutsideWorktree()`, described below. ⚠️ The security argument has two halves. For a worktree inside `workingDir` the lookup only answers a folder strictly below it, but that is a LEXICAL judgement made when the pane moves, and a symlink can replace the folder or a parent later without moving the pane, so `root=live` re-checks on every request (`canWalkLiveWorktree()`, file-routes.ts: walk the worktree only when it resolves strictly inside the resolved `workingDir`, else walk `workingDir`). The walk starts there, returned `path`s stay relative to `workingDir`, and the routes keep confining to `workingDir`, so never make an INSIDE `liveWorktree` a confinement root. ⚠️ Only that check uses resolved paths: the walk keeps the session's spelling, or a workspace reached through a symlink stops producing paths relative to `workingDir`. ⚠️ A plain subfolder is deliberately no answer, or a `cd` in a shell would re-root the panel. ⚠️ A listing reports `worktree` whichever folder it walked, even when the worktree has gone or the check refused it: `_followFileBrowserWorktree()` compares that with the session's state, and an absent report would reload forever. The one exception is a listing without `root=live-any`, which omits an outside worktree; while the session folder is pinned, the panel compares with the worktree it pinned away from (`pinnedWorktree`, panels-ui.js). ⚠️ **A worktree OUTSIDE `workingDir` (`git worktree add ../feature`, or an EnterWorktree placed beside the repo) IS a second root**, answered only through `findOutsideWorktree()` with `outside: true` and published on the wire as `SessionState.outsideWorktree`, never in `liveWorktree`, which stays inside-only: the session's own repository must vouch for it by FILE READS (`workingDir` must be the top of its repository or worktree, so a session in a subfolder follows nothing outside it; the candidate's `.git` FILE names `<common dir>/worktrees/<id>` and that entry's `gitdir` names the candidate back, or its `.git` FOLDER is the session's common dir itself, which is the main worktree for a session started in a linked one, and a symlinked `.git` is refused; never spawn git from the pane watcher). It is refused at `/`, home or above, around `workingDir` and at/inside/around a Docker case workspace (an unreadable Docker list follows nothing). It is refused while attachment workspace confinement is on. It is also refused at, inside or around an attachment blocked tree, and at a root that is itself a sensitive folder such as `~/.ssh` (a child probe, since the sensitive patterns describe file locations). These rules are judged when the pane moves like the Docker rule, and multi-user mode applies `folderAllowedForUser`. The routes also re-check confinement and the blocked trees on every request (`isOutsideWorktreeRootRefused()`), so turning confinement on or blocking the folder stops serving it at once. ⚠️ `validateLocalSessionFilePath()` also refuses any file there that `isSensitivePath()` blocklists, so a root such as a credential folder can never serve its keys. Walking it is opt-in: only `root=live-any` (which the panel sends) lists it, with ABSOLUTE `path`s, while `root=live` never walks an outside worktree: it walks `workingDir` with relative paths, and its listing omits `worktree` for an outside one. An absolute path inside it is confined to it, falling back to `workingDir` when the worktree root refuses it (`validateLocalSessionFilePath()`, route-helpers.ts), while a relative path still resolves against `workingDir` alone. ⚠️ It is recorded as a REAL path, and every request re-checks that the folder still resolves to exactly that path (`outsideWorktreeRootFor()`, `canWalkOutsideWorktree()`), or a symlink swapped in would re-root the routes anywhere. Tests: `test/live-worktree.test.ts`, `test/live-worktree-outside.test.ts`, `test/routes/file-routes-live-worktree.test.ts`, `test/routes/file-routes-outside-worktree.test.ts`, `test/file-browser-worktree.test.ts`, `test/file-browser-outside-worktree.test.ts`. → [architecture-invariants#files-panel-in-a-worktree](docs/architecture-invariants.md#files-panel-in-a-worktree)

docs/api-reference.md

@@ -901,25 +901,6 @@ already serves non-media text inert (`text/plain`, `nosniff`), so this just
 keeps the server from storing what it would serve or an agent could run, and
 html and svg are the ones deliberately kept out.
 
-## Deleting a file (`DELETE /api/v1/sessions/:id/files?path=`)
-
-The Files panel's delete button. `path` is what the listing gave the row: relative to the
-session's `workingDir`, or absolute inside the session's outside worktree (see
-[Live worktree](#live-worktree-liveworktree-outsideworktree)). It removes that one regular file
-and answers `{ path }` as sent. It never deletes a folder and never follows a symbolic link:
-the file routes resolve a link to its target, so deleting through one would remove the file it
-points to.
-
-| Status | When |
-| ------ | ---- |
-| `200`  | The file is gone. |
-| `400`  | A remote (SSH) session or an adopted session (both refused before any path is looked at), a missing or repeated `path`, a symbolic link, or anything that is not a regular file. |
-| `403`  | A sensitive file (`.env`, credentials and the like), a blocked attachment tree, or anything under `.git`. |
-| `404`  | No such file, a path outside the workspace (`../`, an absolute path elsewhere, a link leading out), a dangling link, or a session the caller does not own in multi-user mode. |
-| `409`  | The file was replaced between the checks and the delete; reload the listing. |
-| `422`  | The workspace's mount did not answer. |
-
-## New folder in the path picker
 ## New folder in the path picker
 
 `POST /api/filesystem/mkdir` with `{ path, name, sessionId?, showHidden? }` makes one
@@ -1040,8 +1021,8 @@ of `liveWorktree` and `outsideWorktree`:
 Like `liveWorktree`, it is never restored after a restart.
 
 Such a worktree is a second root for the session's file routes. `file-content` (read and edit),
-`file-raw`, `file-preview`, `file-thumbnail`, `GET /api/v1/download`,
-`POST /api/v1/sessions/:id/html-view` and `DELETE /api/v1/sessions/:id/files` accept an ABSOLUTE path inside it, while a relative path
+`file-raw`, `file-preview`, `file-thumbnail`, `GET /api/v1/download` and
+`POST /api/v1/sessions/:id/html-view` accept an ABSOLUTE path inside it, while a relative path
 still resolves against `workingDir` only. A file there that the sensitive-path blocklist names
 (`.env`, `.aws/credentials`, `users.json` and the like) is refused on every one of those routes.
 Codeman reports the worktree only when the session's own repository lists it, and only when `workingDir` is the top of that repository or of a linked worktree, so a session started in a subfolder of its repository reports none. It never reports:

docs/architecture-invariants.md

@@ -468,7 +468,7 @@ The general rule: **any new endpoint that turns a caller-supplied `sessionId` in
 
 ### File Viewer edit mode
 
-**File Viewer edit mode** (issue #212, design in `docs/file-viewer-edit-plan.md`): the file-preview overlay can edit workspace text files in place — `GET /api/sessions/:id/file-content?edit=1` (read-for-edit) + `PUT /api/sessions/:id/file-content` (save), policy in `src/config/file-editing.ts`, UI in `panels-ui.js`. This is the **only file surface that writes file contents** (the Files panel's delete, [below](#files-panel-delete), removes whole files and borrows these confinement rules), so it carries every rule the read surfaces have plus its own:
+**File Viewer edit mode** (issue #212, design in `docs/file-viewer-edit-plan.md`): the file-preview overlay can edit workspace text files in place — `GET /api/sessions/:id/file-content?edit=1` (read-for-edit) + `PUT /api/sessions/:id/file-content` (save), policy in `src/config/file-editing.ts`, UI in `panels-ui.js`. This is the **only file surface that writes**, so it carries every rule the read surfaces have plus its own:
 
 - **Confinement is the read path's, plus write-only gates.** `findSessionOrFail` (ownership) → `validateSessionFilePath` (realpath + workspace boundary; escapes report as 404, same as reads) → sensitive-path + attachment-guard blocklists (403) → `.git/` subtree deny (403 — `.git/hooks/*` is code execution) → extension **allowlist** (400; `svg` and `env` deliberately excluded). ⚠️ **There is no `O_CREAT` anywhere in the handler** — that absence is what makes "edit-in-place only, never create" a structural property instead of a convention. Do not add a create path without treating it as a new security surface.
 - **A truncated buffer must never become an edit buffer.** The plain preview truncates to `lines` (default 500); saving such a buffer would silently delete everything past the cut, and the hash check cannot catch it (the loaded prefix hashes differently from the full file, which reads as an ordinary conflict at best). `edit=1` therefore never truncates — it 413s over `MAX_EDITABLE_BYTES` (512KB) instead — and the frontend always re-fetches with `edit=1` before swapping in the textarea, even though the preview already holds content.
@@ -479,18 +479,6 @@ The general rule: **any new endpoint that turns a caller-supplied `sessionId` in
 
 Tests: `test/file-editing-policy.test.ts` (pure policy), `test/routes/file-write-routes.test.ts` (deliberately **unmocked fs** against a real temp workspace — symlink/TOCTOU/mode behavior must be exercised for real).
 
-### Files panel delete
-
-**Files panel delete** (salvaged from contributor PR #529, which was closed; its upload half was dropped because `.codeman-uploads/` and the Attach button already cover it): a × on each file row of the Files panel, tree and search results alike, backed by `DELETE /api/sessions/:id/files?path=` in `file-routes.ts`. It removes ONE regular file and is the only file surface that deletes, so it takes the edit route's confinement whole and adds a rule of its own.
-
-- **Order of checks**: `findSessionOrFail` (ownership; a foreign session is a 404 in multi-user mode) → remote refused (400, before any path check, for the same reason as the edit route: `validateSessionFilePath` resolves against the LOCAL filesystem, so a same-named local folder would take the delete) → adopted refused (400) → a missing or repeated `path` (400) → a bounded probe of `workingDir`, and of the outside worktree root for an absolute path (#516; `422` on a mount that does not answer) → `validateLocalSessionFilePath(await withGuardedOutsideWorktree(...))` (realpath + boundary, an absolute path inside a followed outside worktree confined to it, the attachment guard re-read per request; any escape, a dangling link and a missing file are all 404) → sensitive / blocked trees / `.git` (403), each tested against BOTH the realpath and the path as named, so a `.git` reached through a linked folder and a linked `.git` are both caught → the link rule below → not a regular file (a folder: 400).
-- **A symbolic link is refused, never followed.** The confinement helper returns the REALPATH, which for a link is its target. #529 unlinked that path, so `DELETE ?path=AGENTS.md` with `AGENTS.md -> CLAUDE.md` deleted `CLAUDE.md` and left `AGENTS.md` dangling. The route therefore `lstat`s the path as the client named it (`resolve(workingDir, path)`, which keeps an absolute outside-worktree path as it is) and answers 400 for a link. The listing shows a link to a folder as a file row, so it gets a button, and the same 400 answers it. Deleting the link itself was the other option (confine the PARENT's realpath, unlink the link); it was not taken because refusing has no way to touch the target at all.
-- **The file checked is the file deleted.** A path whose last part is not a link has a realpath naming the same inode, so the route `lstat`s the realpath again and refuses with 409 if the inode, the device or the file type changed in between. `unlink` never follows a final symlink, so a link swapped in after that still removes only the link. A parent folder swapped for a link between the realpath and the `unlink` is the same check-then-use window every file route accepts (an agent running as the same user can delete the file anyway).
-- **Adopted and Docker.** An adopted session's folder is the neutral `/tmp`. The older file surfaces keep serving it as a standing exception (root `CLAUDE.md`, Adopted tmux sessions), which is not copied to a new surface, least of all one that deletes; the prompt-upload route refuses adopted sessions the same way. A Docker case workspace is bind-mounted at the same path and an `unlink` runs no hooks or filters (the reason git is kept away from those folders), so the route treats it like the edit route does: allowed.
-- **Frontend.** The button carries no inline handler: `encodeURIComponent` leaves `'` alone, so #529's `onclick="...decodeURIComponent('<path>')"` let a file named `x'-alert(1)-'.txt` run script in Codeman's origin, and `it's.txt` was a syntax error. It is bound in the existing `.file-tree-item` loops (`renderFileBrowserTree`, `_renderFileBrowserSearchResults`) from the row's escaped `data-path`, with `stopPropagation` so the row does not also open the preview. `deleteFileFromBrowser()` asks with `confirm()` (the panel's other destructive actions use the same native dialog, translated by i18n.js's wrapper) and reloads through `_reloadFileBrowserKeepingQuery()`, which re-runs a search in the box, so a row deleted from search results leaves them. The row buttons stay visible under `@media (hover: none)`, where the old hover-only rule meant the first tap opened the preview instead. `_fileBrowserCanDelete()` draws no button for a remote or an adopted session (`session.remote` is undefined on an adopted one, so `session.adopt` is tested too).
-
-Tests: `test/routes/file-delete-routes.test.ts` (unmocked fs again: the symlink defect only shows against a real link), `test/file-delete-ui.test.ts` (jsdom with `runScripts: 'dangerously'`, so the old inline handler would really run there, and the real `escapeHtml` from constants.js).
-
 ### File Viewer text view: rendered markdown and text toggles
 
 **Rendered markdown + Lines/Wrap** (`_renderFilePreviewText()` and its helpers in `panels-ui.js`, buttons in the `.file-preview-actions` row): a `.md`/`.markdown` opened in the File Viewer renders as a document by default, with an `MD` pill back to source; the plain-text view has `Lines` (a CSS-counter gutter) and `Wrap` toggles. Codeman already had `marked` + DOMPurify behind `_renderMarkdown()` for the Response Viewer, so the viewer reuses that and the codebase keeps ONE markdown pipeline.

docs/wiki/Installation.md

@@ -252,6 +252,15 @@ On a MacBook Pro with a PROLED XDR display, whose lid logo lights up,
 your own for working, for waiting for you and for needing permission. All three are off
 until you choose, and the menu only exists on such a Mac.
 
+**Codeman > Keep This Mac Awake** stops the Mac from going to sleep while your agents work
+on it (**While Agents Work**, plus 5 minutes after the last one stops), or for as long as
+the app is open (**Always**). It is off until you choose, only acts for a Codeman running
+on this Mac, needs no password, and ends when the app quits. On a MacBook it pauses on
+battery unless you untick **Only When Plugged In**, and **With the Lid Closed…** keeps a
+closed MacBook awake too: ticking it asks for your administrator password to install a
+small helper, unticking it asks again and removes the helper, and it never acts on
+battery.
+
 ### First launch
 
 1. Open `Codeman.dmg` and drag Codeman into Applications.

docs/wiki/Working-With-Files.md

@@ -19,13 +19,6 @@ not finish shows **Not fully scanned** rather than looking empty. A folder that
 such as a network mount that went away, is skipped rather than waited on and is marked the same way,
 so a search can miss what is inside it. The panel's Refresh button tries it again.
 
-Each file row has a download arrow and a × that deletes the file after you confirm. Both show
-when you point at the row, and always on a touch screen. Delete removes one file at a time,
-never a folder, and refuses a symbolic link (deleting one from here would remove the file it
-points to), anything under `.git`, and the sensitive files the viewer will not serve. It is not
-offered for remote (SSH) sessions or for tmux sessions opened from outside Codeman. Deleting
-from search results takes the row out of the results.
-
 It renders what it can:
 
 | Kind                     | Behaviour                                                                 |

packages/desktop/Cargo.toml

@@ -50,6 +50,7 @@ objc2-foundation = { version = "0.3.2", default-features = false, features = [
     "NSGeometry",
     "NSObject",
     "NSOperation",
+    "NSProcessInfo",
     "NSRange",
     "NSSet",
     "NSString",

packages/desktop/README.md

@@ -41,6 +41,7 @@ cannot do.
 | **Downloads** | Codeman's Download links, and downloads Codeman opens in a new window, save the file to `~/Downloads` whatever its type, and a toast in Codeman names the file. Files the web view cannot display are saved the same way. |
 | **A page that stops** | When the web content process of a window ends (a WebKit crash, or macOS taking the process back under memory pressure), the window loads its page again instead of staying blank. A second time within 30 seconds, the main window goes back to the connect screen and a pop-out closes, so a page that cannot stay up never becomes a reload loop. |
 | **Apple logo** | On a MacBook Pro with a PROLED XDR display, the lit Apple logo on the lid says what the agents are doing, with a blink style of your own for each state: **View > Blink Apple Logo > While Working**, **Waiting for You (Yellow)** and **Needs Permission (Red)**. Off, Calm, Slow, Wink, Heartbeat, Fast, or Alarm, three sharp flashes for a state that needs you. All three are off until you choose. When several states hold, the most urgent one with a style shows: red, then yellow, then work. A style chosen in an earlier version stays as the one for work, and yellow and red start as Wink and Alarm. The menu only exists on a Mac with that logo. No password is needed. Shell tabs do not count. The app asks the server every two seconds, and a change has to hold for three seconds before the logo follows it, so an agent between two turns does not flicker it. It keeps working while the window is hidden, and with any Codeman server. A logo you switched off yourself stays off, and if the setting changes while a blink runs, the blink ends and leaves it as it found it. While the app is closed nothing blinks, and macOS keeps the logo dark while the display sleeps or the lid is closed, so the blink pauses then and writes nothing. |
+| **Keep awake** | **Codeman > Keep This Mac Awake** keeps the Mac from going to sleep while Codeman's agents work on it: **While Agents Work** (an agent at work, and for 5 minutes after the last one stopped, so the gap between two turns or a reply from your phone does not let it drop off), or **Always** (while the app is open). Off until you choose. Only for a Codeman on this Mac (`127.0.0.1`, `localhost`, or one of this Mac's own addresses); for a server on another machine the menu says so. The display still sleeps. No password is needed for this part: the app holds a power assertion of its own, which macOS shows in Activity Monitor and in `pmset -g assertions` as *Codeman keeps this Mac awake while its agents work*, and which ends with the app, a crash or a Force Quit included. On a MacBook, **Only When Plugged In** (on by default) pauses it on battery, and **With the Lid Closed…** keeps a closed MacBook awake as well: nothing an app holds can do that, so ticking it asks for your administrator password and installs a small helper (see Decisions), and unticking it asks again and removes the helper. The lid is never kept awake on battery, whatever the settings, and while the lid is covered *Sleep* in the Apple menu does nothing. A line at the bottom of the menu says what it does right now. It lives in the app, so it ends when the app quits: Codeman keeps running as a LaunchAgent, but nothing keeps the Mac awake then. |
 | **Window** | Size, position and full-screen state are remembered. A saved window that hangs off the screen it opens on (it was last on a larger display that is gone, say) is pulled back on and shrunk to fit; one whose title bar is on no screen at all opens at the default size instead. Clicking the Dock icon brings back a minimized window. |
 
 ## Build (on a Mac)
@@ -147,6 +148,30 @@ classes of wry's own delegates, so wry stays an unmodified crates.io dependency.
 - `codeman web -d` gets the port and base path as separate arguments, never as
   shell text.
 
+**Keeping a closed MacBook awake takes a root helper, installed on request.**
+macOS sleeps on lid close whatever an app asks: `caffeinate` and every power
+assertion stop idle sleep only. `pmset -a disablesleep 1` keeps a closed MacBook
+awake, but it is a machine-wide root setting with no owner process, so nothing
+would undo it after a crash. So ticking *With the Lid Closed…* installs a
+LaunchDaemon (`com.getcodeman.keepawake`) that runs `macos/keep-awake-lid.sh`
+every 20 seconds. The script sets `disablesleep` only while a request file next
+to `desktop.json` is younger than 2 minutes, is not a symlink, names a live
+process of the file's owner, and `pmset -g batt` says the Mac runs on its power
+adapter. The app writes its own pid there and rewrites it every 30 seconds while
+it wants the lid covered, so an app that quits or crashes is a dead pid and the
+lid is released at the next run. The script undoes only a `disablesleep` it set
+itself (a marker file), never an administrator's own. The app writes the script
+and the plist itself, as root, straight into `/Library/Application
+Support/Codeman` and `/Library/LaunchDaemons` from the copies built into it
+(base64 in the root command, so nothing user-writable is copied and no file
+content needs quoting), behind macOS's administrator prompt (`do shell script
+... with administrator privileges` through `osascript`, so the event loop keeps
+running while the prompt is open). The idle-sleep part needs none of this: an
+`NSProcessInfo` activity with `IdleSystemSleepDisabled`, released by the kernel
+with the process. While the app watches for work but holds nothing, a second
+kind of activity keeps App Nap from slowing its look at the server, and still
+allows sleep.
+
 **The app runs the installer itself; Terminal is the fallback.** `install.sh
 --no-admin` puts Node.js and tmux in the home folder, so a This Mac install needs
 no password and therefore no terminal, and the two questions only a person can
@@ -319,6 +344,14 @@ crosses, so the login is never on a command line.
   dark phase the logo stays dark until the app next starts. `api/sessions` does
   not say which turns are Codeman's own, so with prompt-cache keep-warm on, a
   keep-alive turn blinks too.
+- **Keeping the lid awake has not been seen on a real closed MacBook yet.**
+  The helper ran every case against a stand-in `pmset`, the install and removal
+  commands ran in a temporary folder with stand-ins for `chown` and `launchctl`,
+  and the power assertion was measured on a Mac mini (it appears with its name
+  while agents work, and goes with a clean end and with a SIGKILL). Whether a
+  closed MacBook goes to sleep at once when the helper lets go (the app quit, an
+  agent finished, the adapter came out) has not been watched. The helper is
+  machine-wide: on a Mac where two users install it, the last install wins.
 - **Self-signed HTTPS is refused.** A server started with `codeman web --https`
   uses a self-signed certificate, and WKWebView rejects it (wry has no trust
   override). Use `http://127.0.0.1:3000` for a server on this Mac. For another

packages/desktop/macos/keep-awake-lid.sh

@@ -0,0 +1,74 @@
+#!/bin/bash
+# keep-awake-lid.sh: the root helper behind "Keep This Mac Awake > Also With the Lid
+# Closed" in the Codeman app for Mac.
+#
+# The app keeps the Mac from idle sleep on its own, with no root (a power assertion).
+# Closing the lid is another matter: only `pmset -a disablesleep 1` keeps a closed
+# MacBook awake, and that is a machine-wide root setting with no owner process. So this
+# helper, run by the com.getcodeman.keepawake LaunchDaemon every 20 seconds, applies it
+# while the app asks for it and undoes it when the app stops asking:
+#
+#   - The app writes its pid to the request file, and rewrites it every 30 seconds, while
+#     it wants the lid covered.
+#   - The request counts only while the file is fresh (under 2 minutes old), is not a
+#     symlink, its pid is alive, that process belongs to the file's owner, and the Mac
+#     runs on its power adapter. An app that quits or crashes is a dead pid, so the lid
+#     is released at the next run.
+#   - Never on battery, whatever the app says: a closed MacBook that cannot sleep in a
+#     bag only heats up and drains.
+#   - It undoes only a disablesleep it set itself (the .owned file), so an
+#     administrator's own `pmset -a disablesleep 1` is never switched off.
+#
+# The app writes this file to a ROOT-OWNED path itself, behind macOS's administrator
+# prompt; a root daemon must never run a file a user can edit.
+#
+# Usage: keep-awake-lid.sh <request-file>
+# Test hooks (set only by the test suite; launchd passes no environment of the user's):
+# CODEMAN_KEEPAWAKE_PMSET, CODEMAN_KEEPAWAKE_STATE_DIR.
+#
+# bash 3.2 (what macOS ships) and BSD tools only.
+
+set -u
+
+REQ="${1:?usage: keep-awake-lid.sh <request-file>}"
+PMSET="${CODEMAN_KEEPAWAKE_PMSET:-/usr/bin/pmset}"
+STATE_DIR="${CODEMAN_KEEPAWAKE_STATE_DIR:-/Library/Application Support/Codeman}"
+OWNED="$STATE_DIR/keep-awake.owned"
+
+want=0
+# -L: refuse a symlink (root must not be steered to read some other file).
+# find -mmin -2: modified within the last 2 minutes (BSD and GNU find both support it).
+if [ -f "$REQ" ] && [ ! -L "$REQ" ] && [ -n "$(find "$REQ" -mmin -2 2>/dev/null)" ]; then
+    pid=$(head -c 32 "$REQ" 2>/dev/null | tr -dc '0-9')
+    if [ -n "$pid" ] && kill -0 "$pid" 2>/dev/null; then
+        file_uid=$(ls -ln "$REQ" 2>/dev/null | awk '{print $3}')
+        pid_uid=$(ps -o uid= -p "$pid" 2>/dev/null | tr -d ' ')
+        if [ -n "$file_uid" ] && [ "$file_uid" = "$pid_uid" ]; then
+            want=1
+        fi
+    fi
+fi
+
+# The power adapter, or nothing: an unreadable answer counts as battery.
+if [ "$want" = "1" ] && ! "$PMSET" -g batt 2>/dev/null | grep -q "'AC Power'"; then
+    want=0
+fi
+
+current=$("$PMSET" -g 2>/dev/null | awk '/SleepDisabled/ {print $2; exit}')
+[ -n "$current" ] || current=0
+
+if [ "$want" = "1" ]; then
+    # Already 1 without our marker means an administrator set it: leave it and do not
+    # claim it, so releasing later never switches their setting off.
+    if [ "$current" != "1" ]; then
+        if "$PMSET" -a disablesleep 1; then
+            mkdir -p "$STATE_DIR" && : > "$OWNED"
+        fi
+    fi
+elif [ -f "$OWNED" ]; then
+    if [ "$current" = "1" ]; then
+        "$PMSET" -a disablesleep 0 || exit 1
+    fi
+    rm -f "$OWNED"
+fi
+exit 0

packages/desktop/src/config.rs

@@ -3,6 +3,7 @@
 //! (`~/Library/Application Support/Codeman/desktop.json` on macOS). Passwords
 //! never go here; they live in the Keychain (see `credentials`).
 
+use crate::keep_awake;
 use crate::logo::BlinkStyles;
 use serde::{Deserialize, Serialize};
 use std::fs;
@@ -49,6 +50,10 @@ pub struct Config {
     /// reads as off: a bad style must not make the whole file unreadable.
     #[serde(deserialize_with = "lenient_blink")]
     pub logo_blink: BlinkStyles,
+    /// Keep This Mac Awake (keep_awake.rs): when, only on the power adapter, and
+    /// with the lid closed too. Read field by field, like `logo_blink`.
+    #[serde(deserialize_with = "lenient_keep_awake")]
+    pub keep_awake: keep_awake::Settings,
     /// Anything that is not a whole frame reads as None: a bad frame must not
     /// make the whole file unreadable, which would cost the server list.
     #[serde(deserialize_with = "lenient_window")]
@@ -64,6 +69,10 @@ fn lenient_blink<'de, D: serde::Deserializer<'de>>(d: D) -> Result<BlinkStyles,
     Ok(BlinkStyles::read(&serde_json::Value::deserialize(d)?))
 }
 
+fn lenient_keep_awake<'de, D: serde::Deserializer<'de>>(d: D) -> Result<keep_awake::Settings, D::Error> {
+    Ok(keep_awake::Settings::read(&serde_json::Value::deserialize(d)?))
+}
+
 impl Default for Config {
     fn default() -> Self {
         Config {
@@ -71,6 +80,7 @@ impl Default for Config {
             auto_connect: true,
             start_fullscreen: false,
             logo_blink: BlinkStyles::default(),
+            keep_awake: keep_awake::Settings::default(),
             window: None,
         }
     }
@@ -429,6 +439,33 @@ mod tests {
         }
     }
 
+    #[test]
+    fn keep_awake_round_trips_and_a_bad_value_never_costs_the_file() {
+        use crate::keep_awake::{Mode, Settings};
+        let mut c = Config::default();
+        assert_eq!(c.keep_awake, Settings::default());
+        c.keep_awake.mode = Mode::WhileWorking;
+        c.keep_awake.lid = true;
+        let text = serde_json::to_string(&c).unwrap();
+        assert!(
+            text.contains(r#""keepAwake":{"mode":"whileWorking","acOnly":true,"lid":true}"#),
+            "{text}"
+        );
+        assert_eq!(serde_json::from_str::<Config>(&text).unwrap().keep_awake, c.keep_awake);
+        for bad in [
+            r#"{"keepAwake":3}"#,
+            r#"{"keepAwake":null}"#,
+            r#"{"keepAwake":"always"}"#,
+        ] {
+            let c: Config = serde_json::from_str(bad).unwrap();
+            assert_eq!(c.keep_awake, Settings::default(), "{bad}");
+        }
+        // A file from before the setting: every other field still reads.
+        let c: Config = serde_json::from_str(r#"{"startFullscreen":true}"#).unwrap();
+        assert!(c.start_fullscreen);
+        assert_eq!(c.keep_awake, Settings::default());
+    }
+
     #[test]
     fn the_style_a_mac_saved_before_there_were_states_is_kept() {
         use crate::logo::BlinkStyle;

packages/desktop/src/macos.rs

@@ -222,6 +222,13 @@ pub fn content_size(window: &tao::window::Window) -> Option<(f64, f64)> {
     imp::content_size(window)
 }
 
+/// An app-modal message with an OK button, for something the user asked the app
+/// itself to do that failed. Main thread only; does nothing elsewhere.
+#[cfg(target_os = "macos")]
+pub fn show_message(title: &str, detail: &str) {
+    imp::show_message(title, detail);
+}
+
 #[cfg(target_os = "macos")]
 mod imp {
     use std::cell::{Cell, RefCell};
@@ -456,6 +463,17 @@ mod imp {
         }
     }
 
+    pub(super) fn show_message(title: &str, detail: &str) {
+        let Some(mtm) = MainThreadMarker::new() else {
+            return;
+        };
+        let alert = NSAlert::new(mtm);
+        alert.setMessageText(&NSString::from_str(title));
+        alert.setInformativeText(&NSString::from_str(detail));
+        let _ = alert.addButtonWithTitle(&NSString::from_str("OK"));
+        alert.runModal();
+    }
+
     pub(super) fn content_size(window: &tao::window::Window) -> Option<(f64, f64)> {
         // NSWindow is main-thread only.
         MainThreadMarker::new()?;

packages/desktop/src/main.rs

@@ -27,6 +27,7 @@ mod assets;
 mod config;
 mod credentials;
 mod gui_install;
+mod keep_awake;
 mod local_server;
 mod login;
 mod logo;
@@ -182,6 +183,18 @@ enum UserEvent {
     /// install opened in Terminal, the install command copied): the message
     /// goes to the page if it is still the one choosing a server.
     ToConnectPage(serde_json::Value),
+    /// The keep-awake worker's status line, for the value numbered `generation`
+    /// (keep_awake::KeepAwake::is_current).
+    KeepAwakeStatus {
+        generation: u64,
+        text: String,
+    },
+    /// The administrator prompt for the lid helper was answered, and its command
+    /// ran (keep_awake::install_helper, keep_awake::remove_helper).
+    LidHelperDone {
+        install: bool,
+        outcome: keep_awake::AdminOutcome,
+    },
 }
 
 struct ProbeDone {
@@ -318,6 +331,10 @@ struct App {
     fullscreen_retry: Option<(Instant, u8)>,
     /// The child that watches the connected server and blinks the logo.
     logo_watch: logo::Watcher,
+    /// The worker that keeps this Mac awake while its agents work.
+    keep_awake: keep_awake::KeepAwake,
+    /// An administrator prompt for the lid helper is open.
+    lid_helper_busy: bool,
 }
 
 fn main() {
@@ -370,6 +387,7 @@ fn main() {
     let mut windows = HashMap::new();
     windows.insert(main_id, AppWindow::new(webview, window, Kind::Main));
 
+    let keep_awake_proxy = proxy.clone();
     let mut app = App {
         proxy,
         config,
@@ -397,6 +415,10 @@ fn main() {
         add_agent_on_load: false,
         fullscreen_retry: wants_fullscreen.then(|| (Instant::now() + FULLSCREEN_FIRST_CHECK, 0)),
         logo_watch: logo::Watcher::default(),
+        keep_awake: keep_awake::KeepAwake::new(move |generation, text| {
+            let _ = keep_awake_proxy.send_event(UserEvent::KeepAwakeStatus { generation, text });
+        }),
+        lid_helper_busy: false,
     };
 
     event_loop.run(move |event, target, control_flow| app.handle(event, target, control_flow));
@@ -730,6 +752,7 @@ impl App {
             } => self.show_main_window(),
             Event::MainEventsCleared => self.on_events_cleared(control_flow),
             Event::LoopDestroyed => {
+                self.keep_awake.shutdown();
                 self.record_main_frame();
                 self.save_config();
             }
@@ -796,6 +819,7 @@ impl App {
                 if id == self.main_id {
                     // Closing the main window quits; the server and its
                     // sessions keep running, so nothing is lost.
+                    self.keep_awake.shutdown();
                     self.record_main_frame();
                     self.save_config();
                     *control_flow = ControlFlow::Exit;
@@ -875,6 +899,7 @@ impl App {
                         *self.phase.borrow_mut() = next;
                     }
                     self.sync_logo_watch();
+                    self.sync_keep_awake();
                 }
                 if let Some(w) = self.windows.get_mut(&window) {
                     w.committed = Url::parse(&url).ok();
@@ -937,6 +962,14 @@ impl App {
             }
             UserEvent::AuthRejected => self.recheck_login(),
             UserEvent::ContentProcessGone { window } => self.on_content_process_gone(window),
+            UserEvent::KeepAwakeStatus { generation, text } => {
+                if self.keep_awake.is_current(generation) {
+                    if let Some(items) = &self.menu.keep_awake {
+                        items.status.set_text(&text);
+                    }
+                }
+            }
+            UserEvent::LidHelperDone { install, outcome } => self.on_lid_helper_done(install, outcome),
         }
     }
 
@@ -1061,12 +1094,154 @@ impl App {
         }
     }
 
+    /// Keep-awake watches the open server while a mode is chosen. Whether that
+    /// server is this Mac is the worker's to find out.
+    fn sync_keep_awake(&mut self) {
+        let settings = self.config.keep_awake;
+        let server = self.phase.borrow().loaded().cloned();
+        let watch = server
+            .filter(|_| settings.mode != keep_awake::Mode::Off)
+            .map(|server| keep_awake::Watch {
+                server,
+                authorization: self.auth.clone(),
+                settings,
+            });
+        let idle = match (settings.mode, &watch) {
+            (keep_awake::Mode::Off, _) => Some(keep_awake::OFF_TEXT),
+            (_, None) => Some(keep_awake::NO_SERVER_TEXT),
+            _ => None,
+        };
+        self.keep_awake.sync(watch);
+        if let (Some(text), Some(items)) = (idle, &self.menu.keep_awake) {
+            items.status.set_text(text);
+        }
+    }
+
+    fn choose_keep_awake_mode(&mut self, mode: keep_awake::Mode) {
+        if let Some(items) = &self.menu.keep_awake {
+            // A click flips the item it landed on, the chosen one included.
+            for (item_mode, item) in &items.modes {
+                item.set_checked(*item_mode == mode);
+            }
+        }
+        self.config.keep_awake.mode = mode;
+        self.config_dirty = true;
+        self.sync_keep_awake();
+    }
+
+    fn toggle_keep_awake_ac_only(&mut self) {
+        let Some(item) = self.menu.keep_awake.as_ref().and_then(|items| items.ac_only.as_ref()) else {
+            return;
+        };
+        self.config.keep_awake.ac_only = item.is_checked();
+        self.config_dirty = true;
+        self.sync_keep_awake();
+    }
+
+    /// The lid item is the helper: ticking it installs the helper behind the
+    /// administrator prompt (unless this version's is already in), unticking it removes
+    /// it behind another. The setting changes only once the prompt's command ran, so a
+    /// cancelled or failed prompt leaves the item as it was.
+    fn toggle_keep_awake_lid(&mut self) {
+        use keep_awake::HelperState;
+        let Some(wanted) = self
+            .menu
+            .keep_awake
+            .as_ref()
+            .and_then(|items| items.lid.as_ref())
+            .map(|item| item.is_checked())
+        else {
+            return;
+        };
+        let state =
+            keep_awake::request_path().map_or(HelperState::Missing, |request| keep_awake::helper_state(&request));
+        let prompt = match (wanted, state) {
+            _ if self.lid_helper_busy => None,
+            (true, HelperState::Installed) | (false, HelperState::Missing) => {
+                self.config.keep_awake.lid = wanted;
+                self.config_dirty = true;
+                None
+            }
+            (install, _) => Some(install),
+        };
+        // The click flipped the item already. Until a prompt's command ran it shows
+        // what is true.
+        if let Some(items) = &self.menu.keep_awake {
+            items.show_helper(state, self.config.keep_awake.lid);
+        }
+        match prompt {
+            Some(install) => self.run_lid_helper(install),
+            None => self.sync_keep_awake(),
+        }
+    }
+
+    fn run_lid_helper(&mut self, install: bool) {
+        if self.lid_helper_busy {
+            return;
+        }
+        self.lid_helper_busy = true;
+        let proxy = self.proxy.clone();
+        std::thread::spawn(move || {
+            let outcome = match install {
+                true => keep_awake::install_helper(),
+                false => keep_awake::remove_helper(),
+            };
+            let _ = proxy.send_event(UserEvent::LidHelperDone { install, outcome });
+        });
+    }
+
+    fn on_lid_helper_done(&mut self, install: bool, outcome: keep_awake::AdminOutcome) {
+        use keep_awake::{AdminOutcome, HelperState};
+        self.lid_helper_busy = false;
+        let state =
+            keep_awake::request_path().map_or(HelperState::Missing, |request| keep_awake::helper_state(&request));
+        let failure = match (&outcome, install, state) {
+            (AdminOutcome::Cancelled, _, _) => None,
+            (AdminOutcome::Failed(error), true, _) => Some(("The lid helper could not be installed.", error.clone())),
+            (AdminOutcome::Failed(error), false, _) => Some(("The lid helper could not be removed.", error.clone())),
+            (AdminOutcome::Done, true, HelperState::Installed) => {
+                self.config.keep_awake.lid = true;
+                self.config_dirty = true;
+                None
+            }
+            (AdminOutcome::Done, true, _) => Some((
+                "The lid helper could not be installed.",
+                "The installation ran, but the helper's files are not what the app wrote.".to_owned(),
+            )),
+            (AdminOutcome::Done, false, HelperState::Missing) => {
+                self.config.keep_awake.lid = false;
+                self.config_dirty = true;
+                None
+            }
+            (AdminOutcome::Done, false, _) => Some((
+                "The lid helper could not be removed.",
+                "The removal ran, but the helper's files are still there.".to_owned(),
+            )),
+        };
+        if let Some(items) = &self.menu.keep_awake {
+            items.show_helper(state, self.config.keep_awake.lid);
+        }
+        self.keep_awake.refresh();
+        self.sync_keep_awake();
+        if let Some((title, detail)) = failure {
+            eprintln!("codeman-desktop: {title} {detail}");
+            #[cfg(target_os = "macos")]
+            macos::show_message(title, &detail);
+        }
+    }
+
     fn on_menu(&mut self, id: &str) {
         if let Some((signal, style)) = BlinkStyle::from_menu_id(id) {
             self.choose_logo_blink(signal, style);
             return;
         }
+        if let Some(mode) = keep_awake::Mode::from_menu_id(id) {
+            self.choose_keep_awake_mode(mode);
+            return;
+        }
         match id {
+            keep_awake::AC_ONLY_ID => self.toggle_keep_awake_ac_only(),
+            keep_awake::LID_ID => self.toggle_keep_awake_lid(),
             menu_id::SWITCH => self.show_connect_page(None, true),
             menu_id::ADD_AGENT => self.add_agent(),
             menu_id::RELOAD => self.reload_focused(),

packages/desktop/src/menu.rs

@@ -4,6 +4,7 @@ use muda::accelerator::{Accelerator, Code, Modifiers};
 use muda::{AboutMetadata, CheckMenuItem, Menu, MenuItem, PredefinedMenuItem, Submenu};
 
 use crate::config::Config;
+use crate::keep_awake::{self, HelperState, Mode};
 use crate::logo::{self, BlinkStyle, Signal};
 use crate::{APP_NAME, VERSION};
 
@@ -29,6 +30,77 @@ pub struct AppMenu {
     /// One item per state and style. Empty on a Mac without a lit logo, which has no
     /// such menu.
     pub logo_styles: Vec<(Signal, BlinkStyle, CheckMenuItem)>,
+    /// None where the app cannot keep the Mac awake (a build for another OS).
+    pub keep_awake: Option<KeepAwakeMenu>,
+}
+
+/// App menu > Keep This Mac Awake: Off / While Agents Work / Always, then on a
+/// MacBook Only When Plugged In and With the Lid Closed…, then one status line.
+pub struct KeepAwakeMenu {
+    pub modes: Vec<(Mode, CheckMenuItem)>,
+    /// Only on a Mac with a lid: a desktop Mac always runs on mains and cannot close.
+    pub ac_only: Option<CheckMenuItem>,
+    /// Ticked = the helper is in and asked for. Ticking or unticking it asks for the
+    /// administrator password (install, remove), hence the ellipsis.
+    pub lid: Option<CheckMenuItem>,
+    /// What it does right now (keep_awake::status_line). Not clickable.
+    pub status: MenuItem,
+}
+
+impl KeepAwakeMenu {
+    /// The lid item as the helper now is: ticked only while it is installed and on.
+    pub fn show_helper(&self, state: HelperState, lid_on: bool) {
+        if let Some(item) = &self.lid {
+            item.set_checked(lid_on && state == HelperState::Installed);
+        }
+    }
+}
+
+fn build_keep_awake(config: &Config) -> muda::Result<(Submenu, KeepAwakeMenu)> {
+    let settings = config.keep_awake;
+    let submenu = Submenu::new("Keep This Mac Awake", true);
+    let mut modes = Vec::new();
+    for mode in Mode::ALL {
+        let item = CheckMenuItem::with_id(mode.menu_id(), mode.label(), true, settings.mode == mode, None);
+        submenu.append(&item)?;
+        modes.push((mode, item));
+    }
+    let (mut ac_only, mut lid) = (None, None);
+    if keep_awake::has_lid() {
+        let state =
+            keep_awake::request_path().map_or(HelperState::Missing, |request| keep_awake::helper_state(&request));
+        let ac = CheckMenuItem::with_id(
+            keep_awake::AC_ONLY_ID,
+            "Only When Plugged In",
+            true,
+            settings.ac_only,
+            None,
+        );
+        let lid_item = CheckMenuItem::with_id(
+            keep_awake::LID_ID,
+            "With the Lid Closed\u{2026}",
+            true,
+            settings.lid && state == HelperState::Installed,
+            None,
+        );
+        submenu.append_items(&[&PredefinedMenuItem::separator(), &ac, &lid_item])?;
+        (ac_only, lid) = (Some(ac), Some(lid_item));
+    }
+    let initial = match settings.mode {
+        Mode::Off => keep_awake::OFF_TEXT,
+        _ => keep_awake::NO_SERVER_TEXT,
+    };
+    let status = MenuItem::new(initial, false, None);
+    submenu.append_items(&[&PredefinedMenuItem::separator(), &status])?;
+    Ok((
+        submenu,
+        KeepAwakeMenu {
+            modes,
+            ac_only,
+            lid,
+            status,
+        },
+    ))
 }
 
 pub fn build_menu(config: &Config) -> muda::Result<AppMenu> {
@@ -67,6 +139,15 @@ pub fn build_menu(config: &Config) -> muda::Result<AppMenu> {
             &PredefinedMenuItem::quit(None),
         ],
     )?;
+    // Right under "Add a Coding Agent to This Mac…".
+    let keep_awake = match keep_awake::available() {
+        true => {
+            let (submenu, items) = build_keep_awake(config)?;
+            app_menu.insert(&submenu, 4)?;
+            Some(items)
+        }
+        false => None,
+    };
     // Without these items Cmd+C / Cmd+V do nothing inside a WKWebView.
     let edit = Submenu::with_items(
         "Edit",
@@ -157,5 +238,6 @@ pub fn build_menu(config: &Config) -> muda::Result<AppMenu> {
         help_menu,
         start_fullscreen,
         logo_styles,
+        keep_awake,
     })
 }

src/types/common.ts

@@ -115,12 +115,6 @@ export interface FileWriteData {
   eol: 'lf' | 'crlf';
 }
 
-/** Response payload for `DELETE /api/sessions/:id/files?path=` (the Files panel's delete button). */
-export interface FileDeleteData {
-  /** The path as submitted (workspace-relative, or absolute inside the session's outside worktree) */
-  path: string;
-}
-
 export type CleanupResourceType = 'timer' | 'interval' | 'watcher' | 'listener' | 'stream';
 
 /**

src/web/public/i18n.js

@@ -1688,11 +1688,6 @@
       // The file name is user text: it passes through untranslated.
       [/^Downloaded (.+) to Downloads$/, (_m, name) => `已将 ${name} 下载到“下载”文件夹`],
       [/^Download of (.+) failed$/, (_m, name) => `下载 ${name} 失败`],
-      // The Files panel's delete button (panels-ui.js): the path is user text, and the server's
-      // reason passes through untranslated.
-      [/^Delete the file ([\s\S]+)\? This cannot be undone\.$/, (_m, path) => `删除文件 ${path}？此操作无法撤销。`],
-      [/^File deleted: ([\s\S]+)$/, (_m, path) => `已删除文件：${path}`],
-      [/^Delete failed: ([\s\S]+)$/, (_m, why) => `删除失败：${why}`],
       // Group names are user text: they pass through untranslated.
       [/^Move to "(.+)"$/, (_m, group) => `移到“${group}”`],
       // Session names are user text too.

src/web/public/panels-ui.js

@@ -3777,7 +3777,6 @@ Object.assign(CodemanApp.prototype, {
     }
 
     const html = [];
-    const canDelete = this._fileBrowserCanDelete(owner);
 
     const renderNode = (node, depth) => {
       const isDir = node.type === 'directory';
@@ -3800,13 +3799,6 @@ Object.assign(CodemanApp.prototype, {
       const downloadBtn = !isDir
         ? `<a class="file-tree-download" href="${escapeHtml(CodemanBase.url(`/api/sessions/${encodeURIComponent(owner)}/file-raw?path=${encodeURIComponent(node.path)}&download=true`))}" title="Download" onclick="event.stopPropagation()">&#x2B07;</a>`
         : '';
-      // No inline handler: the path is a workspace file name, which an agent or a cloned repo
-      // chose, and `encodeURIComponent` leaves `'` alone, so a quoted string in an onclick ran
-      // whatever a file name like `x'-alert(1)-'.txt` held (#529's review). The click is bound
-      // below from the row's already-escaped `data-path`.
-      const deleteBtn = !isDir && canDelete
-        ? `<button type="button" class="file-tree-delete" title="Delete" aria-label="Delete ${escapeHtml(node.name)}">&times;</button>`
-        : '';
 
       html.push(`
         <div class="file-tree-item" data-path="${escapeHtml(node.path)}" data-type="${escapeHtml(node.type)}" data-depth="${depth}">
@@ -3815,7 +3807,6 @@ Object.assign(CodemanApp.prototype, {
           <span class="${nameClass}">${escapeHtml(node.name)}</span>
           ${sizeStr}
           ${downloadBtn}
-          ${deleteBtn}
         </div>
       `);
 
@@ -3851,21 +3842,9 @@ Object.assign(CodemanApp.prototype, {
           this.openFilePreview(path, owner);
         }
       });
-      item.querySelector('.file-tree-delete')?.addEventListener('click', (e) => {
-        e.stopPropagation();
-        this.deleteFileFromBrowser(owner, item.dataset.path);
-      });
     });
   },
 
-  // The delete button is offered only where the route can act: never for a remote (SSH) session,
-  // whose files live on another host, nor for an adopted one, whose folder is not a workspace of
-  // ours (`session.remote` is undefined on an adopted session, so both are tested).
-  _fileBrowserCanDelete(sessionId) {
-    const session = this.sessions?.get?.(sessionId);
-    return !session?.remote && !session?.adopt;
-  },
-
   toggleFileBrowserFolder(path) {
     if (this.fileBrowserExpandedDirs.has(path)) {
       this.fileBrowserExpandedDirs.delete(path);
@@ -3991,7 +3970,6 @@ Object.assign(CodemanApp.prototype, {
       treeEl.innerHTML = `<div class="file-browser-empty">${escapeHtml('No matches')}</div>`;
     } else {
       const ownerPath = encodeURIComponent(ownerSessionId);
-      const canDelete = this._fileBrowserCanDelete(ownerSessionId);
       treeEl.innerHTML = matches
         .map(match => {
           const isDir = match.type === 'directory';
@@ -4003,10 +3981,6 @@ Object.assign(CodemanApp.prototype, {
           const downloadBtn = !isDir
             ? `<a class="file-tree-download" href="${escapeHtml(CodemanBase.url(`/api/sessions/${ownerPath}/file-raw?path=${encodeURIComponent(match.path)}&download=true`))}" title="Download" onclick="event.stopPropagation()">&#x2B07;</a>`
             : '';
-          // Bound below from `data-path`, never an inline handler (see renderFileBrowserTree).
-          const deleteBtn = !isDir && canDelete
-            ? `<button type="button" class="file-tree-delete" title="Delete" aria-label="Delete ${escapeHtml(match.name)}">&times;</button>`
-            : '';
           return `
             <div class="file-tree-item" data-path="${escapeHtml(match.path)}" data-type="${escapeHtml(match.type)}" data-owner="${escapeHtml(ownerSessionId)}">
               <span class="file-tree-expand"></span>
@@ -4014,7 +3988,6 @@ Object.assign(CodemanApp.prototype, {
               <span class="${nameClass}">${escapeHtml(match.name)}</span>
               ${sizeStr}
               ${downloadBtn}
-              ${deleteBtn}
             </div>
           `;
         })
@@ -4030,10 +4003,6 @@ Object.assign(CodemanApp.prototype, {
           this.openFilePreview(path, ownerSessionId);
         }
       });
-      item.querySelector('.file-tree-delete')?.addEventListener('click', (e) => {
-        e.stopPropagation();
-        this.deleteFileFromBrowser(ownerSessionId, item.dataset.path);
-      });
     });
 
     const statusEl = this.$('fileBrowserStatus');
@@ -4043,33 +4012,6 @@ Object.assign(CodemanApp.prototype, {
     }
   },
 
-  // The Files panel's delete button (DELETE .../files?path=): asks first, in the same native
-  // dialog the panel's other destructive actions use, then reloads the listing. With a search in
-  // the box the reload re-runs it, so the deleted row leaves the results too; a plain reload
-  // would refresh the tree behind them and leave the row on screen.
-  async deleteFileFromBrowser(sessionId, filePath) {
-    if (!sessionId || !filePath) return;
-    if (!confirm(`Delete the file ${filePath}? This cannot be undone.`)) return;
-    let result = null;
-    try {
-      const response = await fetch(
-        `/api/sessions/${encodeURIComponent(sessionId)}/files?path=${encodeURIComponent(filePath)}`,
-        { method: 'DELETE' },
-      );
-      result = await response.json().catch(() => null);
-      if (!response.ok || result?.success !== true) {
-        throw new Error(result?.error || `HTTP ${response.status}`);
-      }
-    } catch (error) {
-      console.error('File browser delete failed:', error);
-      this.showToast(`Delete failed: ${error?.message || 'network error'}`, 'error');
-      return;
-    }
-    this.showToast(`File deleted: ${filePath}`, 'success');
-    const state = this._ensureFileBrowserState();
-    if (state.ownerSessionId === sessionId) await this._reloadFileBrowserKeepingQuery();
-  },
-
   _findFileBrowserDirectory(nodes, targetPath, ancestors = []) {
     if (!Array.isArray(nodes)) return null;
     for (const node of nodes) {

src/web/public/styles.css

@@ -12386,32 +12386,6 @@ html:is([data-skin="paper-gray"], [data-skin="solarized-light"], [data-skin="cat
 .file-tree-download:hover {
   color: #4fc3f7;
 }
-.file-tree-delete {
-  display: none;
-  margin-left: 2px;
-  padding: 0 4px;
-  border: 0;
-  background: transparent;
-  color: #888;
-  font-size: 14px;
-  line-height: 1;
-  cursor: pointer;
-  flex-shrink: 0;
-}
-.file-tree-item:hover .file-tree-delete {
-  display: inline;
-}
-.file-tree-delete:hover {
-  color: #ef5350;
-}
-/* A touch screen has no hover, so the row's buttons stay visible there: otherwise the first tap
-   on a row opens the preview and the buttons never show. */
-@media (hover: none) {
-  .file-tree-download,
-  .file-tree-delete {
-    display: inline;
-  }
-}
 
 /* File tree indent levels */
 .file-tree-item[data-depth="0"] { padding-left: 0.5rem; }

src/web/routes/file-routes.ts

@@ -1,11 +1,9 @@
 /**
  * @fileoverview File browser and streaming routes.
  * Provides directory listing, file content preview, raw file serving, tail
- * streaming, the File Viewer edit-mode write path (edit=1 read +
+ * streaming, and the File Viewer edit-mode write path (edit=1 read +
  * PUT /api/sessions/:id/file-content; policy in src/config/file-editing.ts,
- * design in docs/file-viewer-edit-plan.md), and the Files panel's delete
- * (DELETE /api/sessions/:id/files?path=: one regular file, the edit route's
- * confinement and guards, symbolic links refused).
+ * design in docs/file-viewer-edit-plan.md).
  */
 
 import { FastifyInstance, type FastifyReply } from 'fastify';
@@ -21,7 +19,6 @@ import type {
   FilesystemBrowseEntry,
   FilesystemBrowseRoot,
   FilesystemPreviewKind,
-  FileDeleteData,
   FileWriteData,
 } from '../../types.js';
 import { ApiErrorCode, createErrorResponse, getErrorMessage } from '../../types.js';
@@ -2003,103 +2000,6 @@ export function registerFileRoutes(app: FastifyInstance, ctx: SessionPort & Even
     };
   });
 
-  // The Files panel's delete button: remove ONE regular file from the session's workspace (or from
-  // its outside worktree, for an absolute path inside it). A write surface like the edit route
-  // above, so it takes that route's confinement and guards whole (ownership, realpath + workspace boundary, sensitive and blocked trees, `.git`), and adds
-  // its own rule for links: a symbolic link is REFUSED, never followed. The confinement check
-  // returns the link's realpath, which is its TARGET, so an `unlink` of that path deletes the file
-  // the link points at and leaves the link dangling (#529's review: `AGENTS.md -> CLAUDE.md`
-  // deleted CLAUDE.md). The final component is therefore read with `lstat` on the path as the
-  // client named it, and only a path whose last part is a plain file goes on; `unlink` never
-  // follows a final symlink, so a link swapped in after that check is removed rather than its
-  // target, and the inode is compared again right before the unlink.
-  app.delete('/api/sessions/:id/files', async (req): Promise<ApiResponse<FileDeleteData>> => {
-    const { id } = req.params as { id: string };
-    const { path: filePath } = req.query as { path?: string };
-    const session = findSessionOrFail(ctx, id, req);
-    // Ahead of any path check, as on the edit route: the validation below resolves against the
-    // LOCAL filesystem, so a same-named local directory would take the delete.
-    if (session.remote) {
-      throwRouteError(400, ApiErrorCode.INVALID_INPUT, 'Deleting is not supported for remote (SSH) sessions');
-    }
-    // An adopted session has no workspace of ours: its folder is the neutral `/tmp`. The older
-    // file surfaces keep serving it as a standing exception (root CLAUDE.md, Adopted tmux
-    // sessions), which is not copied to a new surface, least of all one that deletes.
-    if (session.isAdopted) {
-      throwRouteError(400, ApiErrorCode.INVALID_INPUT, 'Deleting is not supported for adopted sessions');
-    }
-    // A repeated `?path=` arrives as an array.
-    if (typeof filePath !== 'string' || !filePath) {
-      throwRouteError(400, ApiErrorCode.INVALID_INPUT, 'Missing path parameter');
-    }
-    // #516: the confinement check below runs realpathSync, which freezes the server on a mount
-    // that stopped answering. Probe the folders it will touch first, bounded.
-    const scope = await withGuardedOutsideWorktree({
-      workingDir: session.workingDir,
-      liveWorktree: session.liveWorktree,
-    });
-    const worktreeRoot = scope.liveWorktree?.outside && isAbsolute(filePath) ? scope.liveWorktree.path : null;
-    for (const folder of worktreeRoot ? [session.workingDir, worktreeRoot] : [session.workingDir]) {
-      if ((await probePathKind(folder, { pastCap: true })) === 'unknown') {
-        throwRouteError(
-          422,
-          ApiErrorCode.OPERATION_FAILED,
-          describeUnknownPath('Workspace', folder, { pastCap: true })
-        );
-      }
-    }
-    const validated = validateLocalSessionFilePath(scope, filePath);
-    if (!validated) {
-      // Missing files, traversal and symlink escapes alike, as on every other file route.
-      throwRouteError(404, ApiErrorCode.NOT_FOUND, 'File not found');
-    }
-    const { resolvedPath, relativePath } = validated;
-    // The path as the client named it: `resolve` keeps an absolute (outside worktree) path as is.
-    const namedPath = resolve(session.workingDir, filePath);
-    const guard = await loadAttachmentGuardConfig();
-    if (
-      isSensitivePath(resolvedPath) ||
-      isSensitivePath(namedPath) ||
-      isBlockedAttachmentPath(resolvedPath, guard.blockedTrees) ||
-      isBlockedAttachmentPath(namedPath, guard.blockedTrees)
-    ) {
-      throwRouteError(403, ApiErrorCode.FORBIDDEN, 'Deleting this file is blocked');
-    }
-    // Both spellings: a `.git` reached through a linked folder, and a linked `.git`.
-    if (isDeniedEditRelativePath(relativePath) || isDeniedEditRelativePath(relative(session.workingDir, namedPath))) {
-      throwRouteError(403, ApiErrorCode.FORBIDDEN, 'Files under .git cannot be deleted');
-    }
-    const named = await fs.lstat(namedPath).catch(() => undefined);
-    if (!named) {
-      throwRouteError(404, ApiErrorCode.NOT_FOUND, 'File not found');
-    }
-    if (named.isSymbolicLink()) {
-      throwRouteError(
-        400,
-        ApiErrorCode.INVALID_INPUT,
-        'Symbolic links are not deleted from the Files panel (deleting one here would remove the file it points to)'
-      );
-    }
-    if (!named.isFile()) {
-      throwRouteError(400, ApiErrorCode.INVALID_INPUT, 'Only regular files can be deleted');
-    }
-    // The same file the checks were made on: realpath of a path whose last part is no link names
-    // the same inode. A change in between (the file replaced) refuses rather than guesses.
-    const real = await fs.lstat(resolvedPath).catch(() => undefined);
-    if (!real || !real.isFile() || real.ino !== named.ino || real.dev !== named.dev) {
-      throwRouteError(409, ApiErrorCode.CONFLICT, 'The file changed while it was being deleted; reload and try again');
-    }
-    try {
-      await fs.unlink(resolvedPath);
-    } catch (err) {
-      const code = (err as NodeJS.ErrnoException).code;
-      if (code === 'ENOENT') throwRouteError(404, ApiErrorCode.NOT_FOUND, 'File not found');
-      // The errno text names the resolved path, so only its code goes back.
-      throwRouteError(500, ApiErrorCode.OPERATION_FAILED, `Failed to delete the file (${code ?? 'error'})`);
-    }
-    return { success: true, data: { path: filePath } };
-  });
-
   // Get file content for preview (File Browser)
   app.get('/api/sessions/:id/file-content', async (req) => {
     const { id } = req.params as { id: string };

test/desktop-keep-awake-lid.test.ts

@@ -0,0 +1,234 @@
+/**
+ * @fileoverview Runs the real lid helper of the Codeman app for Mac
+ * (packages/desktop/macos/keep-awake-lid.sh) in bash against a stub `pmset` that
+ * records what it was asked to do. The helper runs as root from a LaunchDaemon, so the
+ * cases that matter are the ones where it must NOT act: a stale, dead, foreign or
+ * symlinked request, a Mac on battery, and an administrator's own `disablesleep 1`,
+ * which it must never switch off.
+ *
+ * Only the BSD/GNU-portable tools the script uses (find -mmin, ps -o uid=, ls -ln) run
+ * here, so this passes on Linux and macOS alike. The app embeds the same file
+ * (include_str! in packages/desktop/src/keep_awake.rs), so this is the script that
+ * gets installed. Port: none.
+ */
+
+import { spawnSync } from 'node:child_process';
+import {
+  chmodSync,
+  existsSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  symlinkSync,
+  utimesSync,
+  writeFileSync,
+} from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+
+const HELPER = fileURLToPath(new URL('../packages/desktop/macos/keep-awake-lid.sh', import.meta.url));
+
+let dir: string;
+let stateDir: string;
+let request: string;
+
+/**
+ * Stub pmset: `-g` prints the stored SleepDisabled, `-g batt` the stored power source,
+ * `-a disablesleep N` stores N and logs it.
+ */
+function writeStubPmset(initial: '0' | '1' | null, power: 'AC Power' | 'Battery Power' | null = 'AC Power') {
+  const value = join(dir, 'sleepdisabled');
+  if (initial !== null) writeFileSync(value, initial);
+  const source = join(dir, 'power');
+  if (power !== null) writeFileSync(source, power);
+  const stub = join(dir, 'pmset');
+  writeFileSync(
+    stub,
+    `#!/bin/bash
+if [ "$1" = "-g" ] && [ "$2" = "batt" ]; then
+  [ -f "${source}" ] || exit 1
+  echo "Now drawing from '$(cat "${source}")'"
+  exit 0
+fi
+if [ "$1" = "-g" ]; then
+  echo "System-wide power settings:"
+  [ -f "${value}" ] && printf ' SleepDisabled\\t\\t%s\\n' "$(cat "${value}")"
+  echo "Currently in use:"
+  echo " sleep                1"
+  exit 0
+fi
+if [ "$1" = "-a" ] && [ "$2" = "disablesleep" ]; then
+  printf '%s' "$3" > "${value}"
+  echo "disablesleep $3" >> "${join(dir, 'pmset.log')}"
+  exit 0
+fi
+exit 1
+`
+  );
+  chmodSync(stub, 0o755);
+  return stub;
+}
+
+const setPower = (power: 'AC Power' | 'Battery Power') => writeFileSync(join(dir, 'power'), power);
+
+function run() {
+  const result = spawnSync('bash', [HELPER, request], {
+    encoding: 'utf-8',
+    env: {
+      ...process.env,
+      CODEMAN_KEEPAWAKE_PMSET: join(dir, 'pmset'),
+      CODEMAN_KEEPAWAKE_STATE_DIR: stateDir,
+    },
+  });
+  expect(result.status, result.stderr).toBe(0);
+}
+
+const calls = () => (existsSync(join(dir, 'pmset.log')) ? readFileSync(join(dir, 'pmset.log'), 'utf-8') : '');
+const sleepDisabled = () => readFileSync(join(dir, 'sleepdisabled'), 'utf-8');
+const owned = () => existsSync(join(stateDir, 'keep-awake.owned'));
+/** What the app writes: its own pid and a newline. This test process stands in for it. */
+const requestFromLiveApp = () => writeFileSync(request, `${process.pid}\n`);
+
+beforeEach(() => {
+  dir = mkdtempSync(join(tmpdir(), 'keep-awake-lid-'));
+  stateDir = join(dir, 'state');
+  request = join(dir, 'keep-awake-lid.pid');
+});
+
+afterEach(() => {
+  rmSync(dir, { recursive: true, force: true });
+});
+
+describe('keep-awake-lid.sh', () => {
+  it('does nothing without a request', () => {
+    writeStubPmset('0');
+    run();
+    expect(calls()).toBe('');
+    expect(owned()).toBe(false);
+  });
+
+  it('applies disablesleep for a fresh request from a live process, then undoes it when the request goes', () => {
+    writeStubPmset('0');
+    requestFromLiveApp();
+    run();
+    expect(sleepDisabled()).toBe('1');
+    expect(owned()).toBe(true);
+
+    run(); // steady state: no repeated pmset call
+    expect(calls()).toBe('disablesleep 1\n');
+
+    rmSync(request);
+    run();
+    expect(sleepDisabled()).toBe('0');
+    expect(owned()).toBe(false);
+    expect(calls()).toBe('disablesleep 1\ndisablesleep 0\n');
+  });
+
+  it('never acts on battery, and lets go when the adapter is pulled', () => {
+    writeStubPmset('0', 'Battery Power');
+    requestFromLiveApp();
+    run();
+    expect(calls()).toBe('');
+
+    setPower('AC Power');
+    run();
+    expect(sleepDisabled()).toBe('1');
+
+    setPower('Battery Power');
+    run();
+    expect(sleepDisabled()).toBe('0');
+    expect(owned()).toBe(false);
+  });
+
+  it('reads an unanswerable power source as battery', () => {
+    writeStubPmset('0', null);
+    requestFromLiveApp();
+    run();
+    expect(calls()).toBe('');
+  });
+
+  it("never switches off an administrator's own disablesleep", () => {
+    writeStubPmset('1');
+    requestFromLiveApp();
+    run();
+    expect(calls()).toBe('');
+    expect(owned()).toBe(false);
+    rmSync(request);
+    run();
+    expect(sleepDisabled()).toBe('1');
+    expect(calls()).toBe('');
+  });
+
+  it("leaves an administrator's own disablesleep on when the adapter is pulled", () => {
+    writeStubPmset('1', 'Battery Power');
+    requestFromLiveApp();
+    run();
+    expect(calls()).toBe('');
+    expect(sleepDisabled()).toBe('1');
+  });
+
+  it('treats an absent SleepDisabled line as 0', () => {
+    writeStubPmset(null);
+    requestFromLiveApp();
+    run();
+    expect(sleepDisabled()).toBe('1');
+    expect(owned()).toBe(true);
+  });
+
+  it('re-applies after a reboot or OS update reset it, while the request stands', () => {
+    writeStubPmset('0');
+    requestFromLiveApp();
+    run();
+    writeFileSync(join(dir, 'sleepdisabled'), '0'); // the reset
+    run();
+    expect(sleepDisabled()).toBe('1');
+  });
+
+  it('ignores a stale request (an app that hangs) and releases', () => {
+    writeStubPmset('0');
+    requestFromLiveApp();
+    run();
+    expect(sleepDisabled()).toBe('1');
+    const threeMinutesAgo = (Date.now() - 3 * 60_000) / 1000;
+    utimesSync(request, threeMinutesAgo, threeMinutesAgo);
+    run();
+    expect(sleepDisabled()).toBe('0');
+    expect(owned()).toBe(false);
+  });
+
+  it('releases at the next run once the app is gone, however fresh its file', () => {
+    writeStubPmset('0');
+    requestFromLiveApp();
+    run();
+    expect(sleepDisabled()).toBe('1');
+    const gone = spawnSync('true').pid;
+    writeFileSync(request, `${gone}\n`);
+    run();
+    expect(sleepDisabled()).toBe('0');
+    expect(owned()).toBe(false);
+  });
+
+  it('ignores a request whose pid is not running', () => {
+    writeStubPmset('0');
+    const gone = spawnSync('true').pid;
+    writeFileSync(request, `${gone}\n`);
+    run();
+    expect(calls()).toBe('');
+  });
+
+  it('ignores garbage and refuses a symlinked request', () => {
+    writeStubPmset('0');
+    writeFileSync(request, 'not-a-pid\n');
+    run();
+    expect(calls()).toBe('');
+
+    rmSync(request);
+    const real = join(dir, 'elsewhere.pid');
+    writeFileSync(real, `${process.pid}\n`);
+    symlinkSync(real, request);
+    run();
+    expect(calls()).toBe('');
+  });
+});

test/file-browser-search.test.ts

@@ -30,9 +30,6 @@ interface FakeRow {
   dataset: Record<string, string>;
   addEventListener: (type: string, handler: ClickHandler) => void;
   click: () => void;
-  // The row's delete button is looked up per row; the fake rows carry none (file-delete-ui.test.ts
-  // drives it over a real DOM).
-  querySelector: (selector: string) => null;
 }
 
 interface FakeElement {
@@ -108,7 +105,6 @@ function fakeElement(initialClasses: string[] = []): FakeElement {
           click() {
             clickHandler?.();
           },
-          querySelector: () => null,
         });
       }
     },

test/file-delete-ui.test.ts

@@ -1,264 +0,0 @@
-/**
- * @fileoverview The Files panel's delete button (salvaged from #529), in the browser module.
- *
- * #529 first rendered the button with an inline `onclick` that quoted the path inside
- * `decodeURIComponent('...')`. `encodeURIComponent` leaves `'` alone, so a file named
- * `x'-alert(1)-'.txt` ran script in Codeman's origin, and `it's.txt` was a syntax error whose
- * button did nothing. Workspace names come from agents and cloned repos, so the click is now
- * bound from the row's escaped `data-path`.
- *
- * The DOM is jsdom with `runScripts: 'dangerously'` on purpose: jsdom then compiles inline event
- * attributes the way a browser does, with `window.app` and `window.alert` present, so the old
- * markup would really call `alert` here and this test would fail on it. The escaper is the real
- * one from constants.js, not a stub. panels-ui.js loads via `vm` as in
- * test/file-browser-incomplete.test.ts. Port: N/A.
- */
-import { readFileSync } from 'node:fs';
-import { resolve } from 'node:path';
-import vm from 'node:vm';
-import { JSDOM } from 'jsdom';
-import { afterAll, describe, expect, it, vi } from 'vitest';
-
-const PUBLIC = resolve(import.meta.dirname, '../src/web/public');
-const PANELS = readFileSync(resolve(PUBLIC, 'panels-ui.js'), 'utf8');
-const CONSTANTS = readFileSync(resolve(PUBLIC, 'constants.js'), 'utf8');
-const STYLES = readFileSync(resolve(PUBLIC, 'styles.css'), 'utf8');
-
-// The shipped escaper: its map, its pattern and the function, cut from constants.js.
-const ESCAPE_START = CONSTANTS.indexOf('const _htmlEscapeMap');
-const ESCAPE_END = CONSTANTS.indexOf('\n}\n', CONSTANTS.indexOf('function escapeHtml(')) + 3;
-const ESCAPE_SRC = CONSTANTS.slice(ESCAPE_START, ESCAPE_END);
-
-const HOSTILE = ["x'-alert(1)-'.txt", "it's.txt", 'a "b" <i>c</i> & d.txt', "');alert(2);('.txt"];
-const SESSION = 'sess-1';
-
-const dom = new JSDOM(
-  `<div id="fileBrowserPanel" class="visible"></div>
-   <input id="fileBrowserSearch">
-   <div id="fileBrowserStatus"></div>
-   <div id="fileBrowserTree"></div>`,
-  { runScripts: 'dangerously' }
-);
-afterAll(() => dom.window.close());
-const document = dom.window.document;
-const win = dom.window as unknown as Record<string, unknown>;
-const treeEl = () => document.getElementById('fileBrowserTree') as HTMLElement;
-
-interface FakeResponse {
-  ok: boolean;
-  status: number;
-  json: () => Promise<unknown>;
-}
-const reply = (body: unknown, status = 200): FakeResponse => ({
-  ok: status >= 200 && status < 300,
-  status,
-  json: async () => body,
-});
-
-function loadPanel(
-  options: {
-    confirm?: (message: string) => boolean;
-    fetch?: (url: string, init?: { method?: string }) => Promise<FakeResponse>;
-    session?: Record<string, unknown>;
-  } = {}
-) {
-  const CodemanApp = function CodemanApp(this: unknown) {} as unknown as new () => Record<string, any>;
-  const context = vm.createContext({
-    CodemanApp,
-    console,
-    localStorage: { getItem: () => null, setItem: () => {}, removeItem: () => {} },
-    document: { getElementById: () => null, addEventListener: vi.fn() },
-    window: { addEventListener: vi.fn() },
-    // The search debounce, collapsed so the re-run lands on the next turn.
-    setTimeout: (fn: () => void) => setTimeout(fn, 0),
-    clearTimeout,
-    CodemanBase: { url: (p: string) => p },
-    confirm: vi.fn(options.confirm ?? (() => true)),
-    fetch: vi.fn(options.fetch ?? (async () => reply({ success: true, data: {} }))),
-  });
-  vm.runInContext(ESCAPE_SRC, context, { filename: 'constants.js (escapeHtml)' });
-  vm.runInContext(PANELS, context, { filename: 'panels-ui.js' });
-
-  const app = new CodemanApp();
-  app.$ = (id: string) => document.getElementById(id);
-  app.activeSessionId = SESSION;
-  app.sessions = new Map([[SESSION, options.session ?? { id: SESSION }]]);
-  app.fileBrowserExpandedDirs = new Set(['src']);
-  app.fileBrowserShowHidden = false;
-  app.getFileIcon = () => '';
-  app.formatFileSize = () => '';
-  app.openFilePreview = vi.fn();
-  app.showToast = vi.fn();
-  // The sentinel the old inline handler reached: `app.deleteFileFromBrowser(...)` ran in the page.
-  win.app = app;
-  win.alert = vi.fn();
-  return { app, context: context as Record<string, any> };
-}
-
-const fileNode = (name: string) => ({ name, path: `src/${name}`, type: 'file', size: 1, extension: 'txt' });
-const treeEnvelope = (names: string[]) => ({
-  success: true,
-  data: {
-    root: '/repo',
-    tree: [{ name: 'src', path: 'src', type: 'directory', children: names.map(fileNode) }],
-    totalFiles: names.length,
-    totalDirectories: 1,
-    truncated: false,
-  },
-});
-const searchEnvelope = (names: string[]) => ({
-  success: true,
-  data: { mode: 'search', matches: names.map(fileNode), matchCount: names.length, truncated: false },
-});
-
-const rowFor = (path: string) =>
-  [...treeEl().querySelectorAll<HTMLElement>('.file-tree-item')].find((row) => row.dataset.path === path);
-const deleteButtonFor = (path: string) => rowFor(path)?.querySelector<HTMLButtonElement>('.file-tree-delete');
-
-function renderTree(app: Record<string, any>, names: string[]) {
-  app.fileBrowserData = app._validateFileBrowserTreeEnvelope(treeEnvelope(names));
-  app.renderFileBrowserTree(SESSION);
-}
-
-function renderSearch(app: Record<string, any>, names: string[]) {
-  app._renderFileBrowserSearchResults(names.map(fileNode), SESSION, { matchCount: names.length, truncated: false });
-}
-
-describe('Files panel delete button: no inline handler, the exact path', () => {
-  it.each([
-    ['tree', renderTree],
-    ['search results', renderSearch],
-  ])('%s: a click deletes exactly the hostile path and runs nothing', (_label, render) => {
-    const { app } = loadPanel();
-    app.deleteFileFromBrowser = vi.fn();
-    render(app, HOSTILE);
-
-    expect(treeEl().innerHTML).not.toContain('decodeURIComponent');
-    for (const name of HOSTILE) {
-      const button = deleteButtonFor(`src/${name}`);
-      expect(button, name).toBeTruthy();
-      expect(button!.getAttribute('onclick')).toBeNull();
-      expect(button!.type).toBe('button');
-
-      button!.click();
-
-      expect(app.deleteFileFromBrowser).toHaveBeenLastCalledWith(SESSION, `src/${name}`);
-    }
-    expect(app.deleteFileFromBrowser).toHaveBeenCalledTimes(HOSTILE.length);
-    expect(win.alert).not.toHaveBeenCalled();
-    // The click stays on the button: the row behind it does not open the file.
-    expect(app.openFilePreview).not.toHaveBeenCalled();
-    // The row itself still opens it.
-    rowFor(`src/${HOSTILE[0]}`)!.click();
-    expect(app.openFilePreview).toHaveBeenCalledWith(`src/${HOSTILE[0]}`, SESSION);
-  });
-
-  it('labels the button with the escaped name, as text', () => {
-    const { app } = loadPanel();
-    renderTree(app, ['a "b" <i>c</i> & d.txt']);
-    const button = deleteButtonFor('src/a "b" <i>c</i> & d.txt')!;
-    expect(button.getAttribute('aria-label')).toBe('Delete a "b" <i>c</i> & d.txt');
-    expect(rowFor('src/a "b" <i>c</i> & d.txt')!.querySelector('i')).toBeNull();
-  });
-
-  it('offers no delete button on a folder row', () => {
-    const { app } = loadPanel();
-    renderTree(app, ['a.txt']);
-    expect(rowFor('src')!.querySelector('.file-tree-delete')).toBeNull();
-    expect(deleteButtonFor('src/a.txt')).toBeTruthy();
-  });
-
-  it.each([
-    ['a remote (SSH) session', { id: SESSION, remote: { host: 'h' } }],
-    ['an adopted session', { id: SESSION, adopt: { kind: 'local' } }],
-  ])('offers none for %s, which the route refuses', (_label, session) => {
-    const { app } = loadPanel({ session });
-    renderTree(app, ['a.txt']);
-    expect(rowFor('src/a.txt')).toBeTruthy();
-    expect(deleteButtonFor('src/a.txt')).toBeNull();
-    renderSearch(app, ['a.txt']);
-    expect(rowFor('src/a.txt')).toBeTruthy();
-    expect(deleteButtonFor('src/a.txt')).toBeNull();
-  });
-});
-
-describe('deleteFileFromBrowser', () => {
-  it('asks first and sends nothing when the answer is no', async () => {
-    const { app, context } = loadPanel({ confirm: () => false });
-    await app.deleteFileFromBrowser(SESSION, "src/it's.txt");
-    expect(context.confirm).toHaveBeenCalledWith("Delete the file src/it's.txt? This cannot be undone.");
-    expect(context.fetch).not.toHaveBeenCalled();
-  });
-
-  it('sends one DELETE with the encoded path, then reloads keeping the query', async () => {
-    const { app, context } = loadPanel({ fetch: async () => reply({ success: true, data: { path: 'x' } }) });
-    app._reloadFileBrowserKeepingQuery = vi.fn(async () => {});
-    const path = "src/x'-alert(1)-' & #?.txt";
-
-    await app.deleteFileFromBrowser(SESSION, path);
-
-    expect(context.fetch).toHaveBeenCalledTimes(1);
-    expect(context.fetch).toHaveBeenCalledWith(`/api/sessions/${SESSION}/files?path=${encodeURIComponent(path)}`, {
-      method: 'DELETE',
-    });
-    expect(app.showToast).toHaveBeenCalledWith(`File deleted: ${path}`, 'success');
-    expect(app._reloadFileBrowserKeepingQuery).toHaveBeenCalledTimes(1);
-  });
-
-  it('shows the server reason and reloads nothing when the delete is refused', async () => {
-    const { app } = loadPanel({
-      fetch: async () => reply({ success: false, error: 'Symbolic links are not deleted from the Files panel' }, 400),
-    });
-    app._reloadFileBrowserKeepingQuery = vi.fn(async () => {});
-
-    await app.deleteFileFromBrowser(SESSION, 'AGENTS.md');
-
-    expect(app.showToast).toHaveBeenCalledWith(
-      'Delete failed: Symbolic links are not deleted from the Files panel',
-      'error'
-    );
-    expect(app._reloadFileBrowserKeepingQuery).not.toHaveBeenCalled();
-  });
-
-  it('removes the row from the search results it was deleted from', async () => {
-    let files = ['delete-me.txt', 'keep-me.txt', 'other.md'];
-    const { app, context } = loadPanel({
-      fetch: async (url, init) => {
-        const query = new URL(url, 'http://localhost');
-        if (init?.method === 'DELETE') {
-          const gone = query.searchParams.get('path')!.replace(/^src\//, '');
-          files = files.filter((name) => name !== gone);
-          return reply({ success: true, data: { path: query.searchParams.get('path') } });
-        }
-        const q = query.searchParams.get('q');
-        return reply(q ? searchEnvelope(files.filter((name) => name.includes(q))) : treeEnvelope(files));
-      },
-    });
-    await app.loadFileBrowser(SESSION);
-    (document.getElementById('fileBrowserSearch') as HTMLInputElement).value = 'me';
-    app.filterFileBrowser('me');
-    await vi.waitFor(() => expect(rowFor('src/delete-me.txt')).toBeTruthy());
-    expect(rowFor('src/other.md')).toBeUndefined();
-
-    deleteButtonFor('src/delete-me.txt')!.click();
-
-    await vi.waitFor(() => expect(rowFor('src/delete-me.txt')).toBeUndefined());
-    expect(rowFor('src/keep-me.txt')).toBeTruthy();
-    // Still the search view, not the tree behind it.
-    expect(rowFor('src/other.md')).toBeUndefined();
-    expect(document.getElementById('fileBrowserStatus')!.textContent).toBe('1 match');
-    const methods = context.fetch.mock.calls.map(([url, init]: [string, { method?: string }?]) =>
-      init?.method === 'DELETE' ? 'DELETE' : url.includes('&q=') ? 'search' : 'tree'
-    );
-    expect(methods).toEqual(['tree', 'search', 'DELETE', 'tree', 'search']);
-  });
-});
-
-describe('Files panel delete button: touch screens', () => {
-  it('keeps the row buttons visible where there is no hover', () => {
-    const blocks = [...STYLES.matchAll(/@media \(hover: none\) \{([^{}]*\{[^{}]*\})\s*\}/g)].map((m) => m[1]);
-    expect(
-      blocks.some((block) => /\.file-tree-download,\s*\.file-tree-delete\s*\{\s*display: inline;/.test(block))
-    ).toBe(true);
-  });
-});

test/routes/file-delete-routes.test.ts

@@ -1,322 +0,0 @@
-/**
- * @fileoverview `DELETE /api/sessions/:id/files?path=`, the Files panel's delete button (salvaged
- * from #529).
- *
- * Real temp workspace, no fs mock, like test/routes/file-write-routes.test.ts: the thing under
- * test is what the route does to real files, and the defect it fixes (a delete of
- * `AGENTS.md -> CLAUDE.md` removed CLAUDE.md, because the confinement check hands back the
- * realpath) only shows against a real symlink. Each refusal also checks that nothing on disk moved.
- *
- * Uses app.inject() — no real HTTP ports needed.
- * Port: N/A (app.inject doesn't open ports)
- */
-
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import {
-  existsSync,
-  lstatSync,
-  mkdirSync,
-  mkdtempSync,
-  readFileSync,
-  realpathSync,
-  rmSync,
-  symlinkSync,
-  writeFileSync,
-} from 'node:fs';
-import { tmpdir } from 'node:os';
-import { dirname, join } from 'node:path';
-import { createRouteTestHarness, type RouteTestHarness } from './_route-test-utils.js';
-import { registerFileRoutes } from '../../src/web/routes/file-routes.js';
-import { SETTINGS_PATH } from '../../src/web/route-helpers.js';
-
-describe('DELETE /api/sessions/:id/files (real fs)', () => {
-  let harness: RouteTestHarness;
-  let base: string;
-  let workDir: string;
-  let outsideDir: string;
-
-  const del = (path: string, h: RouteTestHarness = harness) =>
-    h.app.inject({
-      method: 'DELETE',
-      url: `/api/sessions/${h.ctx._sessionId}/files?path=${encodeURIComponent(path)}`,
-    });
-
-  beforeEach(async () => {
-    harness = await createRouteTestHarness(registerFileRoutes);
-    // realpath: tmpdir() can hold a symlinked component (macOS /tmp), and the fixtures compare paths.
-    base = realpathSync(mkdtempSync(join(tmpdir(), 'codeman-delete-')));
-    workDir = join(base, 'ws');
-    outsideDir = join(base, 'outside');
-    mkdirSync(workDir);
-    mkdirSync(outsideDir);
-    harness.ctx._session.workingDir = workDir;
-  });
-
-  afterEach(async () => {
-    await harness.app.close();
-    rmSync(base, { recursive: true, force: true });
-    rmSync(SETTINGS_PATH, { force: true });
-  });
-
-  it('deletes a regular file and answers the path it was given', async () => {
-    mkdirSync(join(workDir, 'src'));
-    writeFileSync(join(workDir, 'src', 'old.ts'), 'x');
-    writeFileSync(join(workDir, 'keep.ts'), 'y');
-
-    const res = await del('src/old.ts');
-
-    expect(res.statusCode).toBe(200);
-    expect(res.json()).toEqual({ success: true, data: { path: 'src/old.ts' } });
-    expect(existsSync(join(workDir, 'src', 'old.ts'))).toBe(false);
-    expect(existsSync(join(workDir, 'src'))).toBe(true);
-    expect(readFileSync(join(workDir, 'keep.ts'), 'utf8')).toBe('y');
-  });
-
-  it('deletes a file whose name carries quotes and other characters a shell or a URL cares about', async () => {
-    const name = "x'-alert(1)-' & #?.txt";
-    writeFileSync(join(workDir, name), 'x');
-
-    const res = await del(name);
-
-    expect(res.statusCode).toBe(200);
-    expect(existsSync(join(workDir, name))).toBe(false);
-  });
-
-  describe('symbolic links are refused, never followed', () => {
-    it('leaves both the link and its target when asked to delete AGENTS.md -> CLAUDE.md', async () => {
-      writeFileSync(join(workDir, 'CLAUDE.md'), '# rules');
-      symlinkSync('CLAUDE.md', join(workDir, 'AGENTS.md'));
-
-      const res = await del('AGENTS.md');
-
-      expect(res.statusCode).toBe(400);
-      expect(res.json().success).toBe(false);
-      expect(res.json().error).toMatch(/symbolic link/i);
-      expect(readFileSync(join(workDir, 'CLAUDE.md'), 'utf8')).toBe('# rules');
-      expect(lstatSync(join(workDir, 'AGENTS.md')).isSymbolicLink()).toBe(true);
-    });
-
-    it('refuses a link to a folder, which the listing shows as a file row', async () => {
-      mkdirSync(join(workDir, 'real'));
-      writeFileSync(join(workDir, 'real', 'a.txt'), 'a');
-      symlinkSync('real', join(workDir, 'alias'));
-
-      const res = await del('alias');
-
-      expect(res.statusCode).toBe(400);
-      expect(readFileSync(join(workDir, 'real', 'a.txt'), 'utf8')).toBe('a');
-      expect(lstatSync(join(workDir, 'alias')).isSymbolicLink()).toBe(true);
-    });
-
-    it('answers 404 for a link that leads out of the workspace, and leaves its target', async () => {
-      writeFileSync(join(outsideDir, 'secret.txt'), 'secret');
-      symlinkSync(join(outsideDir, 'secret.txt'), join(workDir, 'leak.txt'));
-
-      const res = await del('leak.txt');
-
-      expect(res.statusCode).toBe(404);
-      expect(readFileSync(join(outsideDir, 'secret.txt'), 'utf8')).toBe('secret');
-    });
-
-    it('deletes a plain file reached through a linked folder inside the workspace', async () => {
-      mkdirSync(join(workDir, 'real'));
-      writeFileSync(join(workDir, 'real', 'b.txt'), 'b');
-      symlinkSync('real', join(workDir, 'alias'));
-
-      const res = await del('alias/b.txt');
-
-      expect(res.statusCode).toBe(200);
-      expect(existsSync(join(workDir, 'real', 'b.txt'))).toBe(false);
-      expect(lstatSync(join(workDir, 'alias')).isSymbolicLink()).toBe(true);
-    });
-  });
-
-  it('refuses a file under .git with 403, also when .git is reached through a linked folder', async () => {
-    mkdirSync(join(workDir, '.git'));
-    writeFileSync(join(workDir, '.git', 'config'), '[core]');
-    symlinkSync('.git', join(workDir, 'gitdir'));
-
-    for (const path of ['.git/config', 'gitdir/config']) {
-      const res = await del(path);
-      expect(res.statusCode).toBe(403);
-      expect(res.json().success).toBe(false);
-    }
-    expect(readFileSync(join(workDir, '.git', 'config'), 'utf8')).toBe('[core]');
-  });
-
-  it('refuses a sensitive file with 403', async () => {
-    writeFileSync(join(workDir, '.env'), 'TOKEN=abc');
-
-    const res = await del('.env');
-
-    expect(res.statusCode).toBe(403);
-    expect(readFileSync(join(workDir, '.env'), 'utf8')).toBe('TOKEN=abc');
-  });
-
-  it('answers 404 for a path that climbs out of the workspace', async () => {
-    writeFileSync(join(outsideDir, 'victim.txt'), 'v');
-
-    for (const path of ['../outside/victim.txt', join(outsideDir, 'victim.txt')]) {
-      const res = await del(path);
-      expect(res.statusCode).toBe(404);
-    }
-    expect(readFileSync(join(outsideDir, 'victim.txt'), 'utf8')).toBe('v');
-  });
-
-  it('answers 404 for a file that does not exist', async () => {
-    expect((await del('nope.txt')).statusCode).toBe(404);
-  });
-
-  it('refuses a directory with 400', async () => {
-    mkdirSync(join(workDir, 'src'));
-    writeFileSync(join(workDir, 'src', 'a.ts'), 'a');
-
-    const res = await del('src');
-
-    expect(res.statusCode).toBe(400);
-    expect(readFileSync(join(workDir, 'src', 'a.ts'), 'utf8')).toBe('a');
-  });
-
-  it('refuses a missing or repeated path parameter with 400', async () => {
-    const missing = await harness.app.inject({
-      method: 'DELETE',
-      url: `/api/sessions/${harness.ctx._sessionId}/files`,
-    });
-    expect(missing.statusCode).toBe(400);
-    writeFileSync(join(workDir, 'a.txt'), 'a');
-    const repeated = await harness.app.inject({
-      method: 'DELETE',
-      url: `/api/sessions/${harness.ctx._sessionId}/files?path=a.txt&path=a.txt`,
-    });
-    expect(repeated.statusCode).toBe(400);
-    expect(existsSync(join(workDir, 'a.txt'))).toBe(true);
-  });
-
-  it('refuses a remote (SSH) session before looking at the local twin of its folder', async () => {
-    // The local folder of the same absolute name is exactly the hazard: validation would resolve
-    // against it and the delete would land here while the user meant the remote file.
-    writeFileSync(join(workDir, 'twin.txt'), 'local');
-    harness.ctx._session.remote = {
-      hostId: 'host-1',
-      label: 'testhost',
-      host: '192.0.2.10',
-      username: 'j',
-      remotePath: workDir,
-    };
-
-    const res = await del('twin.txt');
-
-    expect(res.statusCode).toBe(400);
-    expect(res.json().error).toMatch(/remote/i);
-    expect(readFileSync(join(workDir, 'twin.txt'), 'utf8')).toBe('local');
-  });
-
-  it('refuses an adopted session, whose folder is not a workspace of ours', async () => {
-    writeFileSync(join(workDir, 'shared.txt'), 'tmp');
-    harness.ctx._session.isAdopted = true;
-
-    const res = await del('shared.txt');
-
-    expect(res.statusCode).toBe(400);
-    expect(res.json().error).toMatch(/adopted/i);
-    expect(readFileSync(join(workDir, 'shared.txt'), 'utf8')).toBe('tmp');
-  });
-
-  describe('a worktree outside the session folder', () => {
-    let sibling: string;
-
-    beforeEach(() => {
-      sibling = join(base, 'ws-feature');
-      mkdirSync(join(sibling, 'src'), { recursive: true });
-      writeFileSync(join(sibling, 'src', 'feature.ts'), 'feature');
-      Object.assign(harness.ctx._session, {
-        liveWorktree: { name: 'ws-feature', path: sibling, outside: true },
-      });
-    });
-
-    it('deletes an absolute path inside it, as the other file routes serve it', async () => {
-      const res = await del(join(sibling, 'src', 'feature.ts'));
-      expect(res.statusCode).toBe(200);
-      expect(existsSync(join(sibling, 'src', 'feature.ts'))).toBe(false);
-    });
-
-    it('does not reach it with a relative path, which resolves against the session folder only', async () => {
-      const res = await del('../ws-feature/src/feature.ts');
-      expect(res.statusCode).toBe(404);
-      expect(existsSync(join(sibling, 'src', 'feature.ts'))).toBe(true);
-    });
-
-    it('refuses a symlink in it that leads out of it, and leaves the target', async () => {
-      writeFileSync(join(outsideDir, 'key.txt'), 'secret');
-      symlinkSync(join(outsideDir, 'key.txt'), join(sibling, 'leak.txt'));
-
-      const res = await del(join(sibling, 'leak.txt'));
-
-      expect(res.statusCode).toBe(404);
-      expect(readFileSync(join(outsideDir, 'key.txt'), 'utf8')).toBe('secret');
-    });
-
-    it('reaches nothing there once it is no longer an outside worktree', async () => {
-      Object.assign(harness.ctx._session, { liveWorktree: { name: 'ws-feature', path: sibling } });
-      expect((await del(join(sibling, 'src', 'feature.ts'))).statusCode).toBe(404);
-      expect(existsSync(join(sibling, 'src', 'feature.ts'))).toBe(true);
-    });
-
-    it.each([
-      ['workspace confinement is turned on', () => ({ attachmentConfineToWorkspace: true })],
-      ['its parent folder is blocked', () => ({ attachmentBlockedPaths: [base] })],
-    ])('deletes nothing there once %s', async (_label, settings) => {
-      mkdirSync(dirname(SETTINGS_PATH), { recursive: true });
-      writeFileSync(SETTINGS_PATH, JSON.stringify(settings()));
-
-      const res = await del(join(sibling, 'src', 'feature.ts'));
-
-      expect(res.statusCode).toBe(404);
-      expect(readFileSync(join(sibling, 'src', 'feature.ts'), 'utf8')).toBe('feature');
-    });
-  });
-
-  describe('multi-user mode', () => {
-    let prevMultiUser: string | undefined;
-
-    beforeEach(() => {
-      prevMultiUser = process.env.CODEMAN_MULTIUSER;
-      process.env.CODEMAN_MULTIUSER = '1';
-    });
-
-    afterEach(() => {
-      if (prevMultiUser === undefined) delete process.env.CODEMAN_MULTIUSER;
-      else process.env.CODEMAN_MULTIUSER = prevMultiUser;
-    });
-
-    it("answers 404 for another user's session and deletes nothing", async () => {
-      const bob = await createRouteTestHarness(registerFileRoutes, { authUser: { username: 'bob', role: 'user' } });
-      try {
-        bob.ctx._session.workingDir = workDir;
-        (bob.ctx._session as unknown as { owner?: string }).owner = 'alice';
-        writeFileSync(join(workDir, 'alice.txt'), 'mine');
-
-        const res = await del('alice.txt', bob);
-
-        expect(res.statusCode).toBe(404);
-        expect(readFileSync(join(workDir, 'alice.txt'), 'utf8')).toBe('mine');
-      } finally {
-        await bob.app.close();
-      }
-    });
-
-    it('lets the owner delete in their own session', async () => {
-      const bob = await createRouteTestHarness(registerFileRoutes, { authUser: { username: 'bob', role: 'user' } });
-      try {
-        bob.ctx._session.workingDir = workDir;
-        (bob.ctx._session as unknown as { owner?: string }).owner = 'bob';
-        writeFileSync(join(workDir, 'bob.txt'), 'mine');
-
-        expect((await del('bob.txt', bob)).statusCode).toBe(200);
-        expect(existsSync(join(workDir, 'bob.txt'))).toBe(false);
-      } finally {
-        await bob.app.close();
-      }
-    });
-  });
-});