Fixed PKG install from internal storage.

Adjust back button display effects
Highlight specific directories' icon.
2026-10-06 09:00:26 +02:00 · 2026-08-09 12:38:23 +08:00 · 2026-08-08 17:47:54 +08:00 · 2026-08-06 21:18:15 +08:00 · 2026-08-06 14:51:43 +08:00 · 2026-08-06 14:33:02 +08:00
40 changed files with 6606 additions and 1292 deletions
@@ -3,3 +3,5 @@ gen/
 web-file-mgr-linux
 *.o
 *.d
+tools/
+test/
@@ -13,7 +13,7 @@ ifeq ($(MAKECMDGOALS),)
  endif
 endif

-VERSION_TAG := v0.2
+VERSION_TAG := v1.3
 TITLE_ID    := FMGR88888
 PYTHON      ?= python3
 STRIP       ?= $(PS5_PAYLOAD_SDK)/bin/prospero-strip
@@ -23,31 +23,31 @@ HOST_STRIP  ?= strip
 HOST_PKG_CONFIG ?= pkg-config

 BIN        := web-file-mgr.elf
-LEGACY_BIN := web-file-mgr-legacy.elf
 LINUX_BIN  := web-file-mgr-linux
-COMMON_SRCS := src/main.c src/websrv.c src/filemgr.c src/asset.c src/mime.c src/notify.c
+COMMON_SRCS := src/main.c src/websrv.c src/filemgr.c src/file_response.c src/task.c src/upload.c src/download.c src/text.c src/list.c src/space.c src/fs_util.c src/json_util.c src/path_util.c src/asset.c src/mime.c src/notify.c src/pkg_installer.c
 PS5_SRCS    := $(COMMON_SRCS) src/app_installer.c
 LINUX_SRCS  := $(COMMON_SRCS)
-ASSETS      := $(wildcard assets/*)
+BASE_ASSETS := $(filter-out %.dds,$(wildcard assets/*))
+ifneq ($(filter linux,$(MAKECMDGOALS)),)
+ASSETS      := $(BASE_ASSETS)
+else
+ASSETS      := $(filter-out assets/icon0.png,$(BASE_ASSETS))
+endif
 GEN_SRCS    := $(patsubst assets/%,gen/%, $(ASSETS:=.c))

 CFLAGS := -Oz -fno-asynchronous-unwind-tables -fno-unwind-tables -Wall -Werror -ffunction-sections -fdata-sections -Isrc -DVERSION_TAG=\"$(VERSION_TAG)\" -DTITLE_ID=\"$(TITLE_ID)\"
 CFLAGS += `$(PKG_CONFIG) libmicrohttpd --cflags`
 LDFLAGS := -Wl,--gc-sections
-LEGACY_CFLAGS := $(filter-out -ffunction-sections -fdata-sections,$(CFLAGS))
-LEGACY_LDFLAGS :=
 LDADD  := `$(PKG_CONFIG) libmicrohttpd --libs`
 LDADD  += -lSceIpmi -lSceAppInstUtil
-LINUX_CFLAGS := -O2 -Wall -Werror -Isrc -DVERSION_TAG=\"$(VERSION_TAG)\" -DTITLE_ID=\"$(TITLE_ID)\"
+LINUX_CFLAGS := -O2 -flto -Wall -Werror -Isrc -DVERSION_TAG=\"$(VERSION_TAG)\" -DTITLE_ID=\"$(TITLE_ID)\"
 LINUX_CFLAGS += `$(HOST_PKG_CONFIG) libmicrohttpd --cflags`
 LINUX_LDADD := `$(HOST_PKG_CONFIG) libmicrohttpd --libs` -pthread

-.PHONY: all legacy linux deps linux-deps clean
+.PHONY: all linux deps linux-deps clean

 all: deps $(BIN)

-legacy: deps $(LEGACY_BIN)
-
 linux: linux-deps $(LINUX_BIN)

 deps:
@@ -61,17 +61,13 @@ gen:
 	mkdir gen

 clean:
-	rm -rf $(BIN) $(LEGACY_BIN) $(LINUX_BIN) gen
+	rm -rf $(BIN) $(LINUX_BIN) gen

-gen/%.c: assets/% gen-asset-module.py gen
+gen/%.c: assets/% gen-asset-module.py | gen
 	$(PYTHON) gen-asset-module.py --path $* $< > $@

 $(BIN): $(PS5_SRCS) $(GEN_SRCS)
-	$(CC) $(CFLAGS) $(LDFLAGS) -o $@ $^ $(LDADD)
-	$(STRIP) $@
-
-$(LEGACY_BIN): $(PS5_SRCS) $(GEN_SRCS)
-	$(CC) $(LEGACY_CFLAGS) $(LEGACY_LDFLAGS) -o $@ $^ $(LDADD)
+	$(CC) $(CFLAGS) $(LDFLAGS) -o $@ $(filter %.c,$^) $(LDADD)
 	$(STRIP) $@

 $(LINUX_BIN): $(LINUX_SRCS) $(GEN_SRCS)
@@ -5,19 +5,40 @@ safely copying game dump folders from USB storage to internal storage.

 ## Brief

-PS5 web file manager payload. It runs an HTTP UI starting at port `8888`, installs a home screen launcher in Media catagory on startup when needed, and provides file operations from the PS5 browser. If `8888` is already in use, the payload tries the next port until one is available; the startup notification shows the actual listen port.
+PS5 web file manager payload. It runs an HTTP UI starting at port `8888`, installs a home screen launcher in the Media category on startup when needed, and provides file operations from the PS5 browser or another browser on the same network. If `8888` is already in use, the payload tries the next port until one is available; the startup notification shows the actual listen port.
+
+## Screenshots
+
+<p>
+  <a href="docs/screenshots/20260617_231827.376.jpg" target="_blank"><img src="docs/screenshots/20260617_231827.376.jpg" width="31%" alt="PS5 Web File Manager screenshot 1"></a>
+  <a href="docs/screenshots/20260619_131432.399.jpg" target="_blank"><img src="docs/screenshots/20260619_131432.399.jpg" width="31%" alt="PS5 Web File Manager screenshot 2"></a>
+  <a href="docs/screenshots/20260617_232348.855.jpg" target="_blank"><img src="docs/screenshots/20260617_232348.855.jpg" width="31%" alt="PS5 Web File Manager screenshot 3"></a>
+  <a href="docs/screenshots/20260619_131811.644.jpg" target="_blank"><img src="docs/screenshots/20260619_131811.644.jpg" width="31%" alt="PS5 Web File Manager screenshot 4"></a>
+  <a href="docs/screenshots/20260619_131535.239.jpg" target="_blank"><img src="docs/screenshots/20260619_131535.239.jpg" width="31%" alt="PS5 Web File Manager screenshot 5"></a>
+  <a href="docs/screenshots/20260620_232728.533.jpg" target="_blank"><img src="docs/screenshots/20260620_232728.533.jpg" width="31%" alt="PS5 Web File Manager screenshot 6"></a>
+</p>

 ## Features

 - List files and folders.
- Copy, move, delete, rename, and create folders.
+- Sort the list by name, type, size, modified time, or permissions. The selected sort mode is saved in browser local storage.
+- Copy, move, delete, rename, create files, and create folders.
+- Edit UTF-8 text files up to 1 MiB using the built-in plain text editor.
 - Multi-select operations.
 - Copy/move by choosing sources first, then pasting or moving them into the current folder.
 - Conflict prompts for overwriting files and merging folders.
- Full-screen task overlay with progress, speed, ETA, cancel support, and task recovery after reopening the browser while the payload process is still running.
+- Upload files or folders from a remote browser. Upload is hidden in the PS5 browser because it is intended for another device on the network.
+- Download a single file directly, or download folders/multiple selections as a `.tar` archive. Download is hidden in the PS5 browser.
+- Full-screen task overlay with delayed display, progress, speed, ETA, cancel support, and task recovery after reopening the browser while the payload process is still running.
 - Copied/moved files and folders are set to `0777` where the filesystem supports Unix permissions. FAT/exFAT-style filesystems may ignore chmod.
+- Uploaded files are written through temporary files and are renamed into place after the upload completes.
 - Chinese and English UI. The browser language is read from `navigator.languages` / `navigator.language`; Chinese uses `zh`, everything else uses English.
+- Responsive layout for narrow mobile browsers, including wrapped toolbars and horizontally scrollable file lists.
 - Startup notification showing the app name, version, and listen port.
+- Home screen launcher icon and browser favicon use the same embedded `icon0.png` data in the PS5 build to avoid storing the icon twice in the ELF.
+- Create/edit text files ending with `.txt`, `.json`, `.xml`, `.ini`, `.cfg`, `.conf`, `.md`, `.log`, `.lua`, `.js`, `.css`, `.html`, `.htm`, `.c`, `.h`, `.cpp`, `.hpp`, `.sh`, `.csv`, `.yaml`, `.yml`, `.shn`.
+- Preview image files ending with `.png`, `.jpg`, `.jpeg`, `.gif`, `.bmp`, `.webp`.
+- Install PKG files ends with `.pkg`.

 ## Build

@@ -52,6 +73,15 @@ The output is:
 web-file-mgr.elf
 ```

+For local browser/UI testing on Linux:
+
+```sh
+make linux
+./web-file-mgr-linux
+```
+
+The Linux build does not include the PS5 home screen installer.
+
 ## Usage

 Start an ELF loader on the PS5. The common listener port is `9021`.
@@ -69,20 +99,29 @@ After the payload starts, the PS5 notification shows the app name, version, and
 http://${PS5_IP_ADDRESS}:8888/
 ```

-On first startup the payload installs a `PS5 Web File Manager` web shortcut in the Media category when needed. If the payload had to use a fallback port such as `8889`, use the port shown in the startup notification.
+On first startup the payload installs a `PS5 Web File Manager` web shortcut in the Media category when needed. Existing installed launcher files are not overwritten; missing launcher files are written and then the install step is triggered. If the payload had to use a fallback port such as `8889`, use the port shown in the startup notification.

 ## Notes

- Copy, move, and delete run as single background tasks. While one task is running, other file operations are rejected.
+- Copy, move, delete, upload, and download run as single background tasks. While one task is running, other file operations are rejected.
 - Delete is recursive and permanent. There is no recycle bin.
 - Copy/move tasks can be canceled. A partially copied single file is removed, but partially copied folders are left in place to avoid deleting existing files when merging into an existing target folder.
+- Upload tasks can be canceled. A partially uploaded temporary file is removed when possible.
+- Downloading a folder or multiple selected items produces a tar stream. The tar archive is generated by the payload and is not written to PS5 storage first.
 - The UI can recover the active task display if the browser is closed and reopened while the payload process is still running.
+- Text editing is limited to common text-file extensions. Non-UTF-8 and oversized files are rejected.
+- File names are transmitted as UTF-8 through the web API. The payload also attempts to preserve legacy byte-oriented names returned by mounted filesystems so mixed USB filename encodings can still be displayed and operated on.
+
+## FAQ
+- This is a homebrew app and should not intentionally modify system processes or kernel memory. If a kernel panic happens, make sure you are using a recent jailbreak method and ELF loader, or switch back to the stable method you normally use.
+- If you are using P2JB and this payload causes a kernel panic, avoid using it with that setup. Stability matters more than convenience when each retry takes a long time.
+- The preparing stage may calculate folder size and check available space. It can be slow when a folder contains many files, but it helps prevent starting a copy, move, upload, or download operation that cannot be completed safely.

 ## Credits

 This project was built with reference to these projects:

- **[ps5-payload-dev/websrv](https://github.com/ps5-payload-dev/websrv):** HTTP server structure, static asset embedding ideas, and PS5 browser/websrv behavior. License: GPLv3+.
+- **[ps5-payload-dev/websrv](https://github.com/ps5-payload-dev/websrv):** HTTP server structure, static asset embedding ideas, PS5 browser/websrv behavior and PKG install function. License: GPLv3+.
 - **[ps5-payload-dev/ftpsrv](https://github.com/ps5-payload-dev/ftpsrv):** PS5 payload conventions, home screen launcher/install flow reference, process handling style and startup installation reference. License: GPLv3+.
 - **[itsPLK/ps5-payload-manager](https://github.com/itsPLK/ps5-payload-manager):** Payload building behavior. License: GPLv3.
 - **[libmicrohttpd](https://ftp.gnu.org/gnu/libmicrohttpd/):** Used as the embedded HTTP server library. It is licensed by GNU under the LGPL; this payload links it as the SDK-provided static library.
@@ -4,13 +4,35 @@
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>PS5 Web File Manager</title>
+  <link rel="icon" type="image/png" href="/icon0.png">
+  <style>
+    html, body { margin: 0; min-height: 100%; background: #111316; color: #edf0f2; }
+    .init-loading {
+      position: fixed;
+      top: 0;
+      right: 0;
+      bottom: 0;
+      left: 0;
+      z-index: 20000;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      background: #111316;
+      color: #aab4be;
+      font: 18px system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+    }
+  </style>
  <link rel="stylesheet" href="/main.css">
 </head>
 <body>
  <main class="shell">
    <header class="topbar">
-      <div id="path" class="path">/</div>
-      <div id="spaceInfo" class="space-info"></div>
+      <div class="top-left">
+        <div id="path" class="path">/</div>
+      </div>
+      <div class="top-right">
+        <div id="spaceInfo" class="space-info"></div>
+      </div>
      <button id="exitBtn" class="icon-button power-button" type="button" aria-label="Exit"></button>
    </header>

@@ -19,35 +41,57 @@
        <button id="copyBtn" data-i18n="copy"></button>
        <button id="moveBtn" data-i18n="move"></button>
        <button id="renameBtn" data-i18n="rename"></button>
+        <button id="downloadBtn" class="remote-only" data-i18n="download"></button>
        <button id="deleteBtn" class="danger" data-i18n="delete"></button>
+        <button id="installPkgBtn" class="install-action" data-i18n="install" hidden></button>
        <button id="pasteBtn" class="paste-action" hidden>
          <span id="pasteVerb" data-i18n="paste"></span>
-          <span id="pasteName" class="paste-name"></span>
+          <span id="pasteName" class="paste-name"></span><span id="pasteCount" class="paste-count"></span>
          <span id="pasteTargetText" data-i18n="pasteToCurrent"></span>
        </button>
        <button id="clearClipboardBtn" data-i18n="cancel" hidden></button>
      </div>
      <div class="tool-right">
        <button id="refreshBtn" data-i18n="refresh"></button>
+        <div id="uploadMenu" class="split-button remote-only">
+          <button id="uploadBtn" class="split-main" data-i18n="upload"></button>
+          <button id="uploadMenuBtn" class="split-arrow" type="button" aria-label="Upload menu"></button>
+          <div class="split-menu">
+            <button id="uploadFolderBtn" type="button" data-i18n="uploadFolder"></button>
+          </div>
+        </div>
+        <button id="newTextBtn" data-i18n="newText"></button>
        <button id="mkdirBtn" data-i18n="mkdir"></button>
      </div>
    </section>
+    <input id="uploadFiles" type="file" multiple hidden>
+    <input id="uploadFolder" type="file" multiple webkitdirectory hidden>

    <section id="content" class="content">
      <table>
        <thead>
          <tr>
            <th class="select-col"><label class="select-hit"><input id="selectAll" type="checkbox"></label></th>
-            <th class="name-col" data-i18n="name"></th>
-            <th class="type-col" data-i18n="type"></th>
-            <th class="size-col" data-i18n="size"></th>
-            <th class="time-col" data-i18n="mtime"></th>
-            <th class="mode-col" data-i18n="mode"></th>
+            <th class="name-col sortable" data-sort="name">
+              <div class="name-head">
+                <button id="parentBtn" class="parent-nav-button" type="button" aria-label="Parent directory" disabled>
+                  <img src="/icon-back.png" alt="">
+                </button>
+                <span class="name-heading" data-i18n="name"></span>
+              </div>
+            </th>
+            <th class="type-col sortable" data-sort="type" data-i18n="type"></th>
+            <th class="size-col sortable" data-sort="size" data-i18n="size"></th>
+            <th class="time-col sortable" data-sort="mtime" data-i18n="mtime"></th>
+            <th class="mode-col sortable" data-sort="mode" data-i18n="mode"></th>
          </tr>
        </thead>
        <tbody id="files"></tbody>
      </table>
      <div id="empty" class="empty" data-i18n="empty" hidden></div>
+      <div id="contentLoading" class="content-loading" hidden>
+        <div class="content-loading-text" data-i18n="readDir"></div>
+      </div>
    </section>

    <footer class="status">
@@ -56,19 +100,36 @@
    </footer>
  </main>

+  <div id="textEditorOverlay" class="text-editor-overlay" hidden>
+    <section class="text-editor-panel">
+      <div id="textEditorPath" class="text-editor-path"></div>
+      <textarea id="textEditor" class="text-editor" wrap="off" spellcheck="false"
+                autocomplete="off" autocorrect="off" autocapitalize="off"></textarea>
+      <div id="textEditorStatus" class="text-editor-status"></div>
+      <div class="text-editor-actions">
+        <button id="textEditorCloseBtn" class="secondary" data-i18n="close"></button>
+        <button id="textEditorSaveBtn" class="primary" data-i18n="save"></button>
+      </div>
+    </section>
+  </div>
+
+  <div id="imagePreviewOverlay" class="text-editor-overlay" hidden>
+    <section class="text-editor-panel image-preview-panel">
+      <div id="imagePreviewName" class="text-editor-path"></div>
+      <div class="image-preview-stage">
+        <img id="imagePreview" class="image-preview" alt="">
+      </div>
+      <button id="imagePreviewCloseBtn" class="secondary" data-i18n="close"></button>
+    </section>
+  </div>
+
  <div id="taskOverlay" class="task-overlay" hidden>
    <div class="task-panel">
      <div id="tasks" class="tasks"></div>
    </div>
  </div>

-  <div id="initLoading" class="init-loading" aria-hidden="true">
-    <div class="loading-dots">
-      <span></span>
-      <span></span>
-      <span></span>
-    </div>
-  </div>
+  <div id="initLoading" class="init-loading" aria-hidden="true">Loading...</div>

  <script src="/main.js"></script>
 </body>
@@ -3,14 +3,29 @@ window.WFM_LANG = {
  copy: "Copy",
  move: "Move",
  delete: "Delete",
+  download: "Download",
+  upload: "Upload",
+  uploadFolder: "Upload Folder",
+  copying: "Copying",
+  moving: "Moving",
+  deleting: "Deleting",
  rename: "Rename",
  paste: "Paste",
  cancel: "Cancel",
+  close: "Close",
+  save: "Save",
  exit: "Exit",
  exiting: "Exiting...",
  refresh: "Refresh",
  mkdir: "New Folder",
+  newText: "New Text",
+  install: "Install",
+  installPackage: "Install package",
+  pkgInstalling: "Starting package installation: {name}...",
+  pkgInstallStarted: "Package installation started: {name}",
  file: "File",
+  textFile: "Text",
+  image: "Image",
  dir: "Folder",
  parent: "Parent",
  name: "Name",
@@ -33,12 +48,17 @@ window.WFM_LANG = {
  speedLabel: "Speed",
  progressLabel: "Progress",
  etaLabel: "ETA",
+  elapsedLabel: "Elapsed",
+  durationHours: "{hours}h {minutes}m",
+  durationMinutes: "{minutes}m {seconds}s",
+  durationSeconds: "{seconds}s",
  preparingTask: "Preparing task",
  canceling: "Canceling...",
  selectedItems: "{name} and {count} items",
  countItems: "{count} items",
  totalItems: "{count} items",
  readDir: "Reading folder...",
+  processing: "Processing...",
  actionBusy: "{label}...",
  taskCreated: "{label} task created",
  actionDone: "{label} done",
@@ -47,19 +67,38 @@ window.WFM_LANG = {
  taskCanceled: "{label} canceled",
  selectedForPaste: "Selected {name}. Enter the target folder, then choose {verb}",
  clipboardCleared: "Pending operation canceled",
+  downloadStarted: "Download started: {name}",
+  uploadFolderChoice: "Upload a folder?\n\nOK: choose a folder\nCancel: choose files",
+  uploadOverwriteConfirm: "Items with the same name already exist: {names}\n\nOverwrite matching files and merge matching folders?",
+  uploadingStatus: "Uploading {index}/{count}: {name}",
+  uploadDone: "Upload done, {count} items",
+  uploadFailed: "Upload failed: {error}",
+  downloading: "Downloading",
+  uploading: "Uploading",
  sameSourceTarget: "Source and destination are the same. Cannot {label} {name}",
  removeConflictFirst: "A {existingType} named {name} already exists. To {label} this {sourceType}, delete that {existingType} first.",
  overwriteFiles: "Files with the same name will be overwritten: {names}",
  mergeDirs: "Folders with the same name will be merged. Internal files with the same name will be overwritten: {names}",
  continueConfirm: "Continue?",
-  preparingPaste: "{label} preparing: calculating size and checking target space...",
+  preparingPaste: "Preparing: calculating size and checking target space...",
  preparingStatus: "{label} preparing...",
  cancelPrepare: "Preparation canceled",
  cancelTaskConfirm: "Cancel current {label} task?",
  cancelFailed: "Cancel failed: {error}",
  tasksPollFailed: "Failed to read task status: {error}",
+  transferComplete: "{label} completed: {name}\n\nTotal time: {duration}\nTransferred: {size}",
+  transferCompleteFiles: "{label} completed: {name}\n\nTotal time: {duration}\nTransferred: {size}\nFiles: {count}",
  renamePrompt: "New name",
  mkdirPrompt: "Folder name",
+  newTextPrompt: "Text file name",
+  creatingText: "Creating text file...",
+  createTextFailed: "Failed to create text file: {error}",
+  unsavedSaveConfirm: "The text has unsaved changes. Close without saving?\n\nCancel keeps the editor open.",
+  loadingText: "Loading text...",
+  savingText: "Saving...",
+  textSaved: "Text saved",
+  openTextFailed: "Failed to open text: {error}",
+  saveTextFailed: "Failed to save text: {error}",
  deleteConfirm: "Delete {name}?",
  deleteConfirmRecursive: "Delete {name}?\n\nFolders will be deleted recursively.",
  activeTask: "A task is running",
@@ -70,11 +109,14 @@ window.WFM_LANG = {
  storageUsb: "USB",
  storageM2: "M.2",
  storageExtended: "Extended",
+  storageRoot: "Root",
+  storageCurrent: "Current",
  err_target_dir_not_writable: "Target folder is not writable: {path}",
  err_target_file_not_writable: "Target file is not writable: {path}",
-  err_target_parent_not_writable: "Target parent folder is not writable: {path}",
+  err_target_parent_not_writable: "Current folder is not writable: {path}",
  err_target_check_failed: "Cannot check target path: {path}",
  err_target_path_too_long: "Target path is too long",
+  err_path_too_long: "Path is too long",
  err_space_check_failed: "Cannot read target free space: {path}",
  err_no_space: "Not enough target space. Required {required}, available {available}",
  err_active_task: "A task is running",
@@ -82,6 +124,18 @@ window.WFM_LANG = {
  err_source_destination_same: "Source and destination are the same",
  err_destination_inside_source: "Cannot copy or move a folder inside itself",
  err_invalid_path: "Invalid path",
+  err_pkg_type_invalid: "Only .pkg files can be installed",
+  err_pkg_install_failed: "Package installation failed ({arg})",
+  err_pkg_install_unsupported: "Package installation is only available on PS5",
+  err_file_not_found: "File not found",
+  err_file_already_exists: "A file with the same name already exists",
+  err_invalid_method: "Invalid request method",
+  err_text_type_not_editable: "This file type is not supported by the text editor",
+  err_text_file_too_large: "The text file is too large. The maximum size is 1 MiB",
+  err_text_invalid_utf8: "The file is not valid UTF-8 text",
+  err_text_file_changed: "The file changed after it was opened. Close and reopen it",
+  err_text_file_not_writable: "The text file is not writable",
+  err_request_body_too_large: "Too many selected items. Select fewer items and try again",
  err_unknown_api: "Unknown API",
  err_out_of_memory: "Out of memory",
  err_no_source_paths: "No source paths",
@@ -3,14 +3,29 @@ window.WFM_LANG = {
  copy: "复制",
  move: "移动",
  delete: "删除",
+  download: "下载",
+  upload: "上传",
+  uploadFolder: "上传文件夹",
+  copying: "复制",
+  moving: "移动",
+  deleting: "删除",
  rename: "重命名",
  paste: "粘贴",
  cancel: "取消",
+  close: "关闭",
+  save: "保存",
  exit: "退出",
  exiting: "正在退出...",
  refresh: "刷新",
  mkdir: "新建目录",
+  newText: "新建文本",
+  install: "安装",
+  installPackage: "安装 PKG",
+  pkgInstalling: "正在提交安装：{name}...",
+  pkgInstallStarted: "已开始安装：{name}",
  file: "文件",
+  textFile: "文本",
+  image: "图片",
  dir: "目录",
  parent: "上级目录",
  name: "名称",
@@ -33,12 +48,17 @@ window.WFM_LANG = {
  speedLabel: "速度",
  progressLabel: "进度",
  etaLabel: "剩余",
+  elapsedLabel: "耗时",
+  durationHours: "{hours}小时 {minutes}分",
+  durationMinutes: "{minutes}分 {seconds}秒",
+  durationSeconds: "{seconds}秒",
  preparingTask: "正在准备任务",
  canceling: "正在取消...",
  selectedItems: "{name} 等 {count} 项",
  countItems: "{count} 项",
  totalItems: "共 {count} 项",
-  readDir: "读取目录...",
+  readDir: "读取目录中...",
+  processing: "处理中...",
  actionBusy: "{label}...",
  taskCreated: "{label}任务已创建",
  actionDone: "{label}完成",
@@ -47,19 +67,38 @@ window.WFM_LANG = {
  taskCanceled: "{label}已取消",
  selectedForPaste: "已选择 {name}，进入目标目录后点击{verb}",
  clipboardCleared: "已清除待操作项目",
+  downloadStarted: "已开始下载 {name}",
+  uploadFolderChoice: "选择要上传的目录？\n\n确定：选择目录\n取消：选择文件",
+  uploadOverwriteConfirm: "目标中已存在同名项目: {names}\n\n是否覆盖同名文件并合并同名目录？",
+  uploadingStatus: "正在上传 {index}/{count}: {name}",
+  uploadDone: "上传完成，共 {count} 项",
+  uploadFailed: "上传失败: {error}",
+  downloading: "下载中",
+  uploading: "上传中",
  sameSourceTarget: "源和目标相同，不能{label} {name}",
  removeConflictFirst: "目标中已存在同名{existingType} {name}。要{label}{sourceType}，请先删除该{existingType}才能继续。",
  overwriteFiles: "同名文件将被覆盖: {names}",
  mergeDirs: "同名目录将被合并，内部同名文件会被覆盖: {names}",
  continueConfirm: "继续？",
-  preparingPaste: "{label}准备中：正在计算大小并检查目标空间...",
+  preparingPaste: "准备中：正在计算大小并检查目标空间...",
  preparingStatus: "{label}准备中...",
  cancelPrepare: "已取消准备操作",
  cancelTaskConfirm: "取消当前{label}任务？",
  cancelFailed: "取消失败: {error}",
  tasksPollFailed: "任务状态读取失败: {error}",
+  transferComplete: "{label}完成：{name}\n\n总耗时：{duration}\n传输大小：{size}",
+  transferCompleteFiles: "{label}完成：{name}\n\n总耗时：{duration}\n传输大小：{size}\n文件数量：{count}",
  renamePrompt: "新名称",
  mkdirPrompt: "目录名",
+  newTextPrompt: "文本文件名",
+  creatingText: "正在新建文本...",
+  createTextFailed: "新建文本失败: {error}",
+  unsavedSaveConfirm: "文本有未保存的修改，是否不保存并关闭？\n\n取消将留在编辑器中。",
+  loadingText: "正在读取文本...",
+  savingText: "正在保存...",
+  textSaved: "文本已保存",
+  openTextFailed: "打开文本失败: {error}",
+  saveTextFailed: "保存文本失败: {error}",
  deleteConfirm: "确认删除 {name}？",
  deleteConfirmRecursive: "确认删除 {name}？\n\n目录会递归删除。",
  activeTask: "有任务正在执行",
@@ -70,11 +109,14 @@ window.WFM_LANG = {
  storageUsb: "USB存储",
  storageM2: "M2扩充存储",
  storageExtended: "扩展存储",
+  storageRoot: "根分区",
+  storageCurrent: "当前目录",
  err_target_dir_not_writable: "目标目录不可写: {path}",
  err_target_file_not_writable: "目标文件不可写: {path}",
-  err_target_parent_not_writable: "目标父目录不可写: {path}",
+  err_target_parent_not_writable: "当前目录不可写: {path}",
  err_target_check_failed: "无法检查目标路径: {path}",
  err_target_path_too_long: "目标路径过长",
+  err_path_too_long: "路径过长",
  err_space_check_failed: "无法读取目标剩余空间: {path}",
  err_no_space: "目标空间不足，需要 {required}，可用 {available}",
  err_active_task: "有任务正在执行",
@@ -82,6 +124,18 @@ window.WFM_LANG = {
  err_source_destination_same: "源和目标相同",
  err_destination_inside_source: "不能复制或移动目录到它自己的内部",
  err_invalid_path: "路径无效",
+  err_pkg_type_invalid: "只能安装 .pkg 文件",
+  err_pkg_install_failed: "PKG 安装失败（{arg}）",
+  err_pkg_install_unsupported: "PKG 安装仅支持 PS5 环境",
+  err_file_not_found: "文件不存在",
+  err_file_already_exists: "同名文件已存在",
+  err_invalid_method: "请求方式无效",
+  err_text_type_not_editable: "该文件类型不支持文本编辑",
+  err_text_file_too_large: "文本文件过大，最大支持 1 MiB",
+  err_text_invalid_utf8: "文件不是有效的 UTF-8 文本",
+  err_text_file_changed: "文件在打开后已发生变化，请关闭后重新打开",
+  err_text_file_not_writable: "文本文件不可写",
+  err_request_body_too_large: "选择的项目过多，请减少选择后重试",
  err_unknown_api: "未知接口",
  err_out_of_memory: "内存不足",
  err_no_source_paths: "没有源路径",
@@ -23,41 +23,8 @@
  align-items: center;
  justify-content: center;
  background: #111316;
-}
-
-.loading-dots {
-  display: flex;
-}
-
-.loading-dots span {
-  width: 14px;
-  height: 14px;
-  margin: 0 6px;
-  border-radius: 50%;
-  background: #8fa1b3;
-  animation: loading-pulse 1s ease-in-out infinite;
-}
-
-.loading-dots span:nth-child(2) {
-  animation-delay: .12s;
-}
-
-.loading-dots span:nth-child(3) {
-  animation-delay: .24s;
-}
-
-@keyframes loading-pulse {
-  0%,
-  80%,
-  100% {
-    opacity: .35;
-    transform: scale(.75);
-  }
-
-  40% {
-    opacity: 1;
-    transform: scale(1);
-  }
+  color: #aab4be;
+  font-size: 18px;
 }

 body {
@@ -76,18 +43,48 @@ body {
 }

 .topbar {
+  position: relative;
+  flex: 0 0 auto;
+  height: auto;
+  min-height: 54px;
  display: flex;
-  align-items: center;
-  padding: 12px 30px;
+  align-items: start;
+  flex-wrap: wrap;
+  justify-content: space-between;
+  padding: 0 18px;
  background: #1b2026;
  border-bottom: 1px solid #2d343d;
+  overflow: visible;
+}
+
+.top-left,
+.top-right {
+  height: auto;
+  display: flex;
+  align-items: center;
+}
+
+.top-left {
+  flex: 1 1 420px;
+  min-width: 0;
+  margin-top: 15px;
+}
+
+.top-right {
+  flex: 1 1 360px;
+  min-width: 0;
+  margin-left: auto;
+  justify-content: flex-end;
+  flex-wrap: wrap;
+  padding: 12px 40px 12px 0;
+  text-align: right;
 }

 .path {
  color: #aab4be;
  font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
  font-size: 22px;
-  line-height: 1.35;
+  line-height: 24px;
  white-space: nowrap;
  overflow: hidden;
  text-overflow: ellipsis;
@@ -96,19 +93,25 @@ body {
 }

 .space-info {
+  height: auto;
+  min-height: 0;
  display: flex;
+  align-items: center;
+  flex-wrap: wrap;
  justify-content: flex-end;
-  flex: 0 1 auto;
-  max-width: 58vw;
+  flex: 1 1 auto;
+  max-width: none;
  color: #c9d3dc;
  font-size: 18px;
-  line-height: 1.35;
+  line-height: 30px;
  white-space: nowrap;
-  overflow: hidden;
+  overflow: visible;
+  text-align: right;
 }

 .space-item {
  margin-left: 14px;
+  max-width: 100%;
  overflow: hidden;
  text-overflow: ellipsis;
 }
@@ -129,8 +132,6 @@ body {
  width: 24px;
  height: 24px;
  padding: 0;
-  flex: 0 0 24px;
-  margin-left: 16px;
 }

 .power-button {
@@ -160,6 +161,13 @@ body {
  transform: translateX(-50%);
 }

+#exitBtn {
+  position: absolute;
+  top: 15px;
+  right: 18px;
+  margin-left: 0;
+}
+
 .toolbar,
 .tool-left,
 .tool-right {
@@ -169,10 +177,14 @@ body {
 }

 .toolbar {
+  flex: 0 0 auto;
+  height: auto;
+  min-height: 84px;
  justify-content: space-between;
-  padding: 14px 30px;
+  padding: 15px 18px 0;
  background: #15191e;
  border-bottom: 1px solid #2d343d;
+  overflow: visible;
 }

 .tool-left {
@@ -180,9 +192,15 @@ body {
  flex: 1 1 auto;
 }

+.toolbar .tool-left,
+.toolbar .tool-right {
+  min-height: 54px;
+  flex-wrap: wrap;
+}
+
 .tool-left > *,
 .tool-right > * {
-  margin: 0 12px 0 0;
+  margin: 0 12px 15px 0;
 }

 .tool-right > * {
@@ -192,11 +210,70 @@ body {

 .tool-right {
  justify-content: flex-end;
-  flex: 0 0 auto;
+  flex: 1 1 auto;
+}
+
+.split-button {
+  position: relative;
+  display: inline-flex;
+  align-items: stretch;
+  height: 54px;
+  min-height: 54px;
+  margin-bottom: 15px;
+}
+
+.split-button .split-main {
+  min-width: 82px;
+  border-top-right-radius: 0;
+  border-bottom-right-radius: 0;
+  margin: 0;
+}
+
+.split-button .split-arrow {
+  min-width: 38px;
+  width: 38px;
+  padding: 0;
+  border-left: 0;
+  border-top-left-radius: 0;
+  border-bottom-left-radius: 0;
+  margin: 0;
+}
+
+.split-arrow::before {
+  content: "";
+  display: block;
+  width: 0;
+  height: 0;
+  border-left: 6px solid transparent;
+  border-right: 6px solid transparent;
+  border-top: 7px solid #f2f5f7;
+}
+
+.split-menu {
+  position: absolute;
+  top: 100%;
+  right: 0;
+  z-index: 40;
+  display: none;
+  min-width: 150px;
+  padding-top: 6px;
+}
+
+.split-menu button {
+  width: 100%;
+  min-width: 150px;
+  margin: 0;
+  white-space: nowrap;
+}
+
+.split-button:hover .split-menu,
+.split-button.open .split-menu {
+  display: block;
 }

 button,
 .button {
+  height: 54px;
  min-height: 54px;
  min-width: 96px;
  padding: 0 20px;
@@ -220,8 +297,8 @@ button:focus,
  outline-offset: 2px;
 }

-button:not(.row-action):hover,
-.button:hover {
+button:not(.row-action):hover:not(:disabled),
+.button:hover:not(:disabled) {
  background: #303945;
 }

@@ -237,31 +314,87 @@ button:disabled,
  background: #402326;
 }

+.primary {
+  border-color: #4f9f7b;
+  background: #285943;
+}
+
+button.primary:hover:not(:disabled) {
+  background: #347358;
+}
+
+.secondary {
+  border-color: #59636e;
+  background: #20262d;
+}
+
 .paste-action {
-  max-width: 480px;
+  max-width: 360px;
 }

 .paste-action > * {
+  flex: 0 0 auto;
  margin-right: 8px;
 }

 .paste-name {
  display: inline-block;
-  max-width: 180px;
+  flex: 1 1 auto;
+  min-width: 0;
+  max-width: 120px;
  overflow: hidden;
  text-overflow: ellipsis;
  white-space: nowrap;
 }

+.install-action {
+  min-width: 88px;
+  border-color: #8c6425;
+  background: #352b1c;
+  color: #f8dfae;
+}
+
+button.install-action:hover:not(:disabled) {
+  background: #433521;
+}
+
+.paste-count {
+  white-space: nowrap;
+}
+
 .content {
+  position: relative;
  flex: 1 1 auto;
  min-height: 0;
  overflow: auto;
 }

+.content.loading {
+  pointer-events: none;
+}
+
+.content-loading {
+  position: absolute;
+  right: 0;
+  left: 0;
+  height: 100%;
+  z-index: 2;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  background: rgba(4, 6, 8, .72);
+}
+
+.content-loading-text {
+  color: #aab4be;
+  font-size: 18px;
+}
+
 table {
  width: 100%;
-  border-collapse: collapse;
+  min-width: 1034px;
+  border-collapse: separate;
+  border-spacing: 0;
  table-layout: fixed;
 }

@@ -274,6 +407,7 @@ td {
  overflow: hidden;
  text-overflow: ellipsis;
  font-size: 20px;
+  line-height: 24px;
 }

 th {
@@ -285,13 +419,108 @@ th {
  font-weight: 600;
 }

+th.sortable {
+  cursor: pointer;
+}
+
+th.sortable::after {
+  content: "";
+  display: inline-block;
+  width: 12px;
+  margin-left: 8px;
+  color: #aeb8c2;
+  text-align: center;
+}
+
+th.sorted-asc::after {
+  content: "^";
+}
+
+th.sorted-desc::after {
+  content: "v";
+}
+
+.name-head {
+  height: 78px;
+  min-height: 78px;
+  display: flex;
+  align-items: center;
+  min-width: 0;
+}
+
+th.name-col {
+  padding: 0;
+}
+
+th.name-col.sortable::after {
+  content: none;
+}
+
+.name-heading {
+  min-width: 100px;
+  padding-left: 18px;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.name-heading::after {
+  content: "";
+  display: inline-block;
+  width: 12px;
+  margin-left: 8px;
+  color: #aeb8c2;
+  text-align: center;
+}
+
+th.name-col.sorted-asc .name-heading::after {
+  content: "^";
+}
+
+th.name-col.sorted-desc .name-heading::after {
+  content: "v";
+}
+
+.parent-nav-button {
+  width: 78px;
+  min-width: 78px;
+  height: 78px;
+  min-height: 78px;
+  padding: 0;
+  border: 0;
+  border-radius: 0;
+  background: transparent;
+  position: relative;
+}
+
+.parent-nav-button img {
+  width: 32px;
+  height: 32px;
+  display: block;
+}
+
+.parent-nav-button:hover:not(:disabled) {
+  background: #222932;
+}
+
+.parent-nav-button:not(:disabled):focus {
+  outline-offset: -5px;
+}
+
+.parent-nav-button:disabled img {
+  opacity: .42;
+}
+
+.parent-nav-button:disabled {
+  pointer-events: auto;
+}
+
 .select-col {
  width: 74px;
  padding: 0;
 }

 .name-col {
-  min-width: 360px;
+  min-width: 600px;
 }

 td.name-col {
@@ -308,6 +537,10 @@ td.name-col {
  text-align: right;
 }

+th.size-col {
+  text-align: center;
+}
+
 .time-col {
  width: 225px;
  text-align: center;
@@ -328,6 +561,7 @@ tr {
 }

 thead tr {
+  height: 78px;
  cursor: default;
 }

@@ -340,7 +574,12 @@ tr.selected {
  background: #1d2d35;
 }

+tr[data-type="parent"] {
+  cursor: pointer;
+}
+
 .select-hit {
+  height: 78px;
  min-height: 78px;
  width: 100%;
  display: flex;
@@ -359,19 +598,19 @@ input[type="checkbox"] {
  width: 32px;
  height: 32px;
  flex: 0 0 32px;
-  display: inline-flex;
-  align-items: center;
-  justify-content: center;
+  display: block;
 }

-.icon img {
-  width: 32px;
-  height: 32px;
-  display: block;
+.special-folder-icon {
+  -webkit-filter: hue-rotate(65deg);
+  filter: hue-rotate(65deg);
+  -webkit-transform: scale(1.1);
+  transform: scale(1.1);
 }

 .row-action {
  width: 100%;
+  height: 78px;
  min-height: 78px;
  padding: 16px 18px;
  border: 0;
@@ -402,10 +641,11 @@ input[type="checkbox"] {

 .status {
  color: #aab4be;
-  padding: 10px 25px;
-}
-
-.status {
+  flex: 0 0 auto;
+  height: 46px;
+  min-height: 46px;
+  padding: 0 25px;
+  line-height: 46px;
  border-top: 1px solid #2d343d;
  background: #15191e;
  font-size: 18px;
@@ -419,6 +659,112 @@ input[type="checkbox"] {
  color: #7f8a94;
 }

+.text-editor-overlay {
+  position: fixed;
+  top: 0;
+  right: 0;
+  bottom: 0;
+  left: 0;
+  z-index: 9000;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  padding: 48px;
+  background: rgba(4, 6, 8, .9);
+}
+
+.text-editor-panel {
+  width: 1200px;
+  height: calc(100vh - 96px);
+  min-width: 0;
+  max-width: calc(100vw - 96px);
+  display: flex;
+  flex-direction: column;
+  padding: 24px;
+  border: 1px solid #46515f;
+  border-radius: 10px;
+  background: #15191e;
+  box-shadow: 0 18px 60px rgba(0, 0, 0, .45);
+}
+
+.text-editor-path {
+  flex: 0 0 auto;
+  margin-bottom: 14px;
+  overflow: hidden;
+  color: #c9d3dc;
+  font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+  font-size: 20px;
+  white-space: nowrap;
+  text-overflow: ellipsis;
+}
+
+.text-editor {
+  width: 100%;
+  min-height: 0;
+  flex: 1 1 auto;
+  padding: 18px;
+  border: 1px solid #46515f;
+  border-radius: 6px;
+  outline: none;
+  resize: none;
+  background: #0f1215;
+  color: #edf0f2;
+  font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+  font-size: 20px;
+  line-height: 1.5;
+}
+
+.text-editor:focus {
+  border-color: #6fb1ff;
+}
+
+.text-editor-status {
+  min-height: 28px;
+  padding-top: 8px;
+  color: #aab4be;
+  font-size: 18px;
+}
+
+.text-editor-actions {
+  display: flex;
+}
+
+.text-editor-actions button {
+  flex: 1 1 0;
+}
+
+.text-editor-actions button + button {
+  margin-left: 14px;
+}
+
+.image-preview-stage {
+  width: 100%;
+  height: calc(100vh - 250px);
+  min-width: 0;
+  min-height: 0;
+  flex: 1 1 auto;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  overflow: hidden;
+}
+
+.image-preview {
+  display: block;
+  width: auto;
+  height: auto;
+  max-width: 100%;
+  max-height: calc(100vh - 250px);
+  pointer-events: none;
+  -webkit-user-drag: none;
+  user-select: none;
+}
+
+.image-preview-panel > button {
+  width: 100%;
+  margin-top: 14px;
+}
+
 .task-overlay {
  position: fixed;
  top: 0;
@@ -467,6 +813,8 @@ input[type="checkbox"] {
  display: flex;
  align-items: flex-start;
  font-size: 24px;
+  justify-content: space-between;
+  position: relative;
 }

 .task-head.has-amount {
@@ -483,13 +831,18 @@ input[type="checkbox"] {
 .task-current {
  min-width: 0;
  overflow: hidden;
-  text-overflow: ellipsis;
  white-space: nowrap;
 }

+.task-current-plain {
+  text-overflow: ellipsis;
+}
+
 .task-name {
  display: flex;
  min-width: 0;
+  text-overflow: ellipsis;
+  flex: 1 1 auto;
 }

 .task-name > * {
@@ -509,6 +862,14 @@ input[type="checkbox"] {
  white-space: nowrap;
 }

+.task-elapsed {
+  flex: 0 0 auto;
+  white-space: nowrap;
+  text-align: right;
+  margin-left: 16px;
+  color: #aab4be;
+}
+
 .task-meta {
  display: flex;
  color: #c9d3dc;
@@ -577,18 +938,250 @@ input[type="checkbox"] {
  background: #8a929b;
 }

-@media (max-width: 900px) {
-  .topbar {
-    align-items: stretch;
-    flex-direction: column;
+@media (max-width: 815px) {
+  .top-left {
+    padding: 0 40px 0 0;
  }

-  th:nth-child(4),
-  td:nth-child(4),
-  th:nth-child(5),
-  td:nth-child(5),
-  th:nth-child(6),
-  td:nth-child(6) {
+  .top-right {
+    padding: 10px 0;
+  }
+}
+
+@media (max-width: 640px) {
+  body {
+    font-size: 16px;
+  }
+
+  .topbar {
+    min-height: 42px;
+    padding: 0 10px;
+    align-items: center;
+    flex-wrap: nowrap;
+  }
+
+  .top-left {
+    flex: 1 1 auto;
+    margin-top: 0;
+    padding-right: 34px;
+  }
+
+  .top-right {
    display: none;
+  }
+
+  .path {
+    font-size: 16px;
+    line-height: 42px;
+  }
+
+  #exitBtn {
+    top: 9px;
+    right: 10px;
+  }
+
+  .toolbar {
+    min-height: 0;
+    padding: 8px 8px 0;
+  }
+
+  .toolbar .tool-left,
+  .toolbar .tool-right {
+    min-height: 0;
+  }
+
+  .tool-left,
+  .tool-right {
+    flex: 1 1 100%;
+  }
+
+  .tool-right {
+    justify-content: flex-start;
+  }
+
+  .tool-left > *,
+  .tool-right > * {
+    margin: 0 8px 8px 0;
+  }
+
+  .tool-right > * {
+    margin-left: 0;
+  }
+
+  button,
+  .button {
+    height: 40px;
+    min-height: 40px;
+    min-width: 76px;
+    padding: 0 12px;
+    border-radius: 6px;
+    font-size: 16px;
+  }
+
+  .split-button {
+    height: 40px;
+    min-height: 40px;
+    margin-bottom: 8px;
+  }
+
+  .split-button .split-main {
+    min-width: 64px;
+  }
+
+  .split-button .split-arrow {
+    min-width: 34px;
+    width: 34px;
+  }
+
+  .split-menu {
+    min-width: 126px;
+    padding-top: 4px;
+  }
+
+  .split-menu button {
+    min-width: 126px;
+  }
+
+  .paste-action {
+    max-width: 100%;
+  }
+
+  .paste-name {
+    max-width: 120px;
+  }
+
+  table {
+    min-width: 960px;
+  }
+
+  .name-col {
+    width: 600px;
+  }
+
+  th,
+  td {
+    padding: 10px 12px;
+    font-size: 16px;
+    line-height: 20px;
+  }
+
+  tr,
+  thead tr,
+  .name-head,
+  .parent-nav-button,
+  .select-hit,
+  .row-action {
+    height: 56px;
+    min-height: 56px;
+  }
+
+  .parent-nav-button {
+    width: 56px;
+    min-width: 56px;
+  }
+
+  .name-heading {
+    padding-left: 12px;
+  }
+
+  .row-action {
+    padding: 10px 12px;
+  }
+
+  input[type="checkbox"] {
+    width: 28px;
+    height: 28px;
+  }
+
+  .icon {
+    width: 26px;
+    height: 26px;
+    flex-basis: 26px;
+  }
+
+  .status {
+    height: 34px;
+    min-height: 34px;
+    padding: 0 12px;
+    line-height: 34px;
+    font-size: 14px;
+  }
+
+  .task-overlay {
+    padding: 18px;
+    align-items: center;
+  }
+
+  .task-panel {
+    width: 100%;
+    max-width: none;
+    padding: 18px;
+    border-radius: 8px;
+  }
+
+  .task > * + * {
+    margin-top: 12px;
+  }
+
+  .task-head {
+    display: block;
+    font-size: 20px;
+  }
+
+  .task-name {
+    display: flex;
+    max-width: none;
+    white-space: nowrap;
+  }
+
+  .task-name > * {
+    margin: 0 8px 0 0;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+  }
+
+  .task-name-subject {
+    flex: 1 1 auto;
+    max-width: none;
+    min-width: 0;
+  }
+
+  .task-elapsed {
+    margin: 8px 0 0;
+    text-align: left;
+    font-size: 18px;
+  }
+
+  .task-current {
+    font-size: 18px;
+    white-space: normal;
+    word-break: break-all;
+  }
+
+  .task-meta {
+    display: block;
+    font-size: 18px;
+  }
+
+  .task-meta div,
+  .task-meta div:nth-child(2),
+  .task-meta div:nth-child(3) {
+    display: block;
+    margin: 0 0 8px;
+    text-align: left;
+    white-space: normal;
+  }
+
+  .task-meta div:last-child {
+    margin-bottom: 0;
+  }
+
+  .progress {
+    height: 32px;
+  }
+
+  .task .danger {
+    width: 100%;
  }
 }
@@ -4,12 +4,13 @@
 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
 #include <sys/stat.h>

 #include <ps5/kernel.h>

+#include "asset.h"
+#include "pkg_installer.h"
+
 #define INCASSET(name, file)                    \
  __asm__(".section .rodata\n"                  \
          ".global " #name "\n"                 \
@@ -28,14 +29,20 @@
 INCASSET(param_json, "assets/param.json");
 INCASSET(icon0_png, "assets/icon0.png");

-int sceAppInstUtilInitialize(void);
 int sceAppInstUtilAppInstallAll(void *);

 static int
 install_file(const char *path, const uint8_t *data, size_t size) {
+  struct stat st;
  FILE *f;

-  if(!(f = fopen(path, "w"))) {
+  if(!stat(path, &st)) {
+    return 0;
+  }
+  if(errno != ENOENT) {
+    return -1;
+  }
+  if(!(f = fopen(path, "wb"))) {
    return -1;
  }
  if(fwrite(data, size, 1, f) != 1) {
@@ -65,32 +72,13 @@ install_app(const char *title_id, const char *dir) {
 }

 static int
-needs_update(const char *path, const uint8_t *expected, size_t expected_size) {
+needs_install_file(const char *path) {
  struct stat st;
-  uint8_t *buf;
-  FILE *f;
-  int mismatch;

-  if(stat(path, &st) || st.st_size != (off_t)expected_size) {
+  if(stat(path, &st)) {
    return 1;
  }
-  if(!(f = fopen(path, "r"))) {
-    return 1;
-  }
-  if(!(buf = malloc(expected_size))) {
-    fclose(f);
-    return 1;
-  }
-  if(fread(buf, 1, expected_size, f) != expected_size) {
-    free(buf);
-    fclose(f);
-    return 1;
-  }
-  fclose(f);
-
-  mismatch = memcmp(buf, expected, expected_size);
-  free(buf);
-  return mismatch != 0;
+  return 0;
 }

 int
@@ -104,6 +92,8 @@ app_install_if_needed(void) {
  int update_needed = 0;
  int err;

+  asset_register("/icon0.png", icon0_png, icon0_png_size, "image/png", 0);
+
  snprintf(base_dir, sizeof(base_dir), "/user/app/%s", title_id);
  snprintf(sce_sys_dir, sizeof(sce_sys_dir), "/user/app/%s/sce_sys", title_id);
  snprintf(param_path, sizeof(param_path), "%s/param.json", sce_sys_dir);
@@ -111,8 +101,7 @@ app_install_if_needed(void) {

  if(stat(base_dir, &st)) {
    update_needed = 1;
-  } else if(needs_update(param_path, param_json, param_json_size) ||
-            needs_update(icon_path, icon0_png, icon0_png_size)) {
+  } else if(needs_install_file(param_path) || needs_install_file(icon_path)) {
    update_needed = 1;
  }

@@ -122,7 +111,7 @@ app_install_if_needed(void) {

  printf("Installing launcher app %s\n", title_id);

-  if((err = sceAppInstUtilInitialize())) {
+  if((err = pkg_installer_initialize())) {
    printf("sceAppInstUtilInitialize: error 0x%08X\n", err);
    return -1;
  }
@@ -0,0 +1,754 @@
+#include <dirent.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <time.h>
+#include <unistd.h>
+
+#include "filemgr_internal.h"
+#include "json_util.h"
+#include "path_util.h"
+#include "websrv.h"
+
+#define DOWNLOAD_ARCHIVE_NAME_LIMIT 20
+
+typedef struct tar_frame {
+  char path[PATH_MAX];
+  char name[PATH_MAX];
+  DIR *dir;
+  int header_sent;
+  struct tar_frame *next;
+} tar_frame_t;
+
+typedef struct tar_stream {
+  file_task_t *task;
+  char **paths;
+  size_t path_count;
+  size_t path_index;
+  size_t stack_depth;
+  tar_frame_t *stack;
+  int fd;
+  char current_file[PATH_MAX];
+  unsigned long long file_remaining;
+  size_t file_padding;
+  size_t pad_remaining;
+  char *pending;
+  size_t pending_size;
+  size_t pending_offset;
+  int final_blocks;
+  int done;
+  int error;
+} tar_stream_t;
+
+typedef struct download_file_stream {
+  file_task_t *task;
+  FILE *file;
+  unsigned long long size;
+  unsigned long long sent;
+  int done;
+  int error;
+} download_file_stream_t;
+
+static enum MHD_Result
+download_task_request_error(struct MHD_Connection *conn, file_task_t *task,
+                            char **paths, size_t count, unsigned int status,
+                            const char *msg) {
+  free_paths(paths, count);
+  free_task(task);
+  return send_json_error(conn, status, msg);
+}
+
+static int
+tar_checksum(char *header) {
+  int sum = 0;
+  int i;
+
+  memset(header + 148, ' ', 8);
+  for(i = 0; i < 512; i++) {
+    sum += (unsigned char)header[i];
+  }
+  snprintf(header + 148, 8, "%06o", sum);
+  header[154] = 0;
+  header[155] = ' ';
+  return 0;
+}
+
+static int
+tar_split_name(const char *name, char *out_name, size_t out_name_size,
+               char *prefix, size_t prefix_size) {
+  size_t len = strlen(name);
+  const char *slash;
+
+  memset(out_name, 0, out_name_size);
+  memset(prefix, 0, prefix_size);
+  if(len < out_name_size) {
+    strcpy(out_name, name);
+    return 0;
+  }
+  for(slash = name + len; slash > name; slash--) {
+    size_t prefix_len;
+    size_t name_len;
+
+    if(*slash != '/') {
+      continue;
+    }
+    prefix_len = (size_t)(slash - name);
+    name_len = len - prefix_len - 1;
+    if(prefix_len < prefix_size && name_len > 0 && name_len < out_name_size) {
+      memcpy(prefix, name, prefix_len);
+      prefix[prefix_len] = 0;
+      memcpy(out_name, slash + 1, name_len + 1);
+      return 0;
+    }
+  }
+  errno = ENAMETOOLONG;
+  return -1;
+}
+
+static int
+tar_queue_header(tar_stream_t *s, const char *name, const struct stat *st,
+                 char type) {
+  char header[512];
+  char tar_name[100];
+  char prefix[155];
+  unsigned int mode = (unsigned int)(st->st_mode & 07777);
+  unsigned long long size = type == '0' ? (unsigned long long)st->st_size : 0;
+  long long mtime = (long long)st->st_mtime;
+
+  if(tar_split_name(name, tar_name, sizeof(tar_name), prefix, sizeof(prefix))) {
+    return -1;
+  }
+  memset(header, 0, sizeof(header));
+  memcpy(header, tar_name, strlen(tar_name));
+  snprintf(header + 100, 8, "%07o", mode);
+  snprintf(header + 108, 8, "%07o", 0);
+  snprintf(header + 116, 8, "%07o", 0);
+  snprintf(header + 124, 12, "%011llo", size);
+  snprintf(header + 136, 12, "%011llo", (unsigned long long)mtime);
+  header[156] = type;
+  memcpy(header + 257, "ustar", 5);
+  memcpy(header + 263, "00", 2);
+  if(prefix[0]) {
+    memcpy(header + 345, prefix, strlen(prefix));
+  }
+  tar_checksum(header);
+  s->pending = malloc(sizeof(header));
+  if(!s->pending) {
+    errno = ENOMEM;
+    return -1;
+  }
+  memcpy(s->pending, header, sizeof(header));
+  s->pending_size = sizeof(header);
+  s->pending_offset = 0;
+  return 0;
+}
+
+static int
+tar_push_dir(tar_stream_t *s, const char *path, const char *name) {
+  tar_frame_t *frame = calloc(1, sizeof(*frame));
+
+  if(!frame) {
+    errno = ENOMEM;
+    return -1;
+  }
+  snprintf(frame->path, sizeof(frame->path), "%s", path);
+  snprintf(frame->name, sizeof(frame->name), "%s", name);
+  frame->dir = opendir(path);
+  if(!frame->dir) {
+    int error = errno;
+    free(frame);
+    errno = error;
+    return -1;
+  }
+  frame->next = s->stack;
+  s->stack = frame;
+  s->stack_depth++;
+  return 0;
+}
+
+static void
+tar_pop_dir(tar_stream_t *s) {
+  tar_frame_t *frame = s->stack;
+
+  if(!frame) {
+    return;
+  }
+  s->stack = frame->next;
+  if(s->stack_depth) {
+    s->stack_depth--;
+  }
+  if(frame->dir) {
+    closedir(frame->dir);
+  }
+  free(frame);
+}
+
+static int
+tar_start_path(tar_stream_t *s, const char *path, const char *name) {
+  struct stat st;
+
+  if(lstat(path, &st)) {
+    return -1;
+  }
+  if(S_ISDIR(st.st_mode)) {
+    char dir_name[PATH_MAX];
+    snprintf(dir_name, sizeof(dir_name), "%s%s", name,
+             name[strlen(name) - 1] == '/' ? "" : "/");
+    return tar_push_dir(s, path, dir_name);
+  }
+  if(!S_ISREG(st.st_mode)) {
+    errno = ENOTSUP;
+    return -1;
+  }
+  if(tar_queue_header(s, name, &st, '0')) {
+    return -1;
+  }
+  s->fd = open(path, O_RDONLY);
+  if(s->fd < 0) {
+    return -1;
+  }
+  snprintf(s->current_file, sizeof(s->current_file), "%s", path);
+  s->file_remaining = (unsigned long long)st.st_size;
+  s->file_padding = (size_t)((512 - ((unsigned long long)st.st_size % 512)) % 512);
+  return 0;
+}
+
+static int
+tar_prepare_next(tar_stream_t *s) {
+  while(!s->pending && s->fd < 0 && !s->done) {
+    if(s->task && task_cancel_requested(s->task)) {
+      errno = ECANCELED;
+      return -1;
+    }
+    if(s->pad_remaining) {
+      size_t size = s->pad_remaining > 512 ? 512 : s->pad_remaining;
+      s->pending = calloc(1, size);
+      if(!s->pending) {
+        errno = ENOMEM;
+        return -1;
+      }
+      s->pending_size = size;
+      s->pending_offset = 0;
+      s->pad_remaining -= size;
+      return 0;
+    }
+    if(s->stack) {
+      tar_frame_t *frame = s->stack;
+      struct dirent *entry;
+      struct stat st;
+
+      if(!frame->header_sent) {
+        frame->header_sent = 1;
+        if(lstat(frame->path, &st) ||
+           tar_queue_header(s, frame->name, &st, '5')) {
+          return -1;
+        }
+        return 0;
+      }
+      while((entry = readdir(frame->dir))) {
+        char child[PATH_MAX];
+        char child_name[PATH_MAX];
+
+        if(!strcmp(entry->d_name, ".") || !strcmp(entry->d_name, "..")) {
+          continue;
+        }
+        if(path_join(child, sizeof(child), frame->path, entry->d_name) ||
+           path_join(child_name, sizeof(child_name), frame->name,
+                     entry->d_name) ||
+           tar_start_path(s, child, child_name)) {
+          return -1;
+        }
+        return 0;
+      }
+      tar_pop_dir(s);
+      continue;
+    }
+    if(s->path_index < s->path_count) {
+      const char *path = s->paths[s->path_index++];
+      if(tar_start_path(s, path, path_basename(path))) {
+        return -1;
+      }
+      continue;
+    }
+    if(s->final_blocks < 2) {
+      s->pending = calloc(1, 512);
+      if(!s->pending) {
+        errno = ENOMEM;
+        return -1;
+      }
+      s->pending_size = 512;
+      s->pending_offset = 0;
+      s->final_blocks++;
+      return 0;
+    }
+    s->done = 1;
+  }
+  return 0;
+}
+
+static ssize_t
+tar_read(void *cls, uint64_t pos, char *buf, size_t max) {
+  tar_stream_t *s = cls;
+  size_t out = 0;
+  (void)pos;
+
+  while(out < max && !s->done) {
+    if(s->task && task_cancel_requested(s->task)) {
+      s->error = ECANCELED;
+      return out ? (ssize_t)out : MHD_CONTENT_READER_END_WITH_ERROR;
+    }
+    if(tar_prepare_next(s)) {
+      s->error = errno ? errno : EIO;
+      return out ? (ssize_t)out : MHD_CONTENT_READER_END_WITH_ERROR;
+    }
+    if(s->pending) {
+      size_t left = s->pending_size - s->pending_offset;
+      size_t take = left < max - out ? left : max - out;
+      memcpy(buf + out, s->pending + s->pending_offset, take);
+      s->pending_offset += take;
+      out += take;
+      if(s->pending_offset >= s->pending_size) {
+        free(s->pending);
+        s->pending = NULL;
+        s->pending_size = 0;
+        s->pending_offset = 0;
+      }
+      continue;
+    }
+    if(s->fd >= 0) {
+      size_t want = max - out;
+      ssize_t n;
+      if((unsigned long long)want > s->file_remaining) {
+        want = (size_t)s->file_remaining;
+      }
+      n = read(s->fd, buf + out, want);
+      if(n < 0) {
+        s->error = errno;
+        return out ? (ssize_t)out : MHD_CONTENT_READER_END_WITH_ERROR;
+      }
+      if(!n) {
+        close(s->fd);
+        s->fd = -1;
+        s->current_file[0] = 0;
+        s->file_remaining = 0;
+        continue;
+      }
+      out += (size_t)n;
+      s->file_remaining -= (unsigned long long)n;
+      if(s->task) {
+        task_update(s->task, TASK_RUNNING,
+                    s->current_file[0] ? s->current_file : NULL,
+                    (unsigned long long)n, NULL);
+      }
+      if(!s->file_remaining) {
+        close(s->fd);
+        s->fd = -1;
+        s->current_file[0] = 0;
+        s->pad_remaining = s->file_padding;
+        s->file_padding = 0;
+      }
+    }
+  }
+  return out ? (ssize_t)out : MHD_CONTENT_READER_END_OF_STREAM;
+}
+
+static void
+tar_close(void *cls) {
+  tar_stream_t *s = cls;
+  int canceled;
+
+  if(!s) {
+    return;
+  }
+  if(s->fd >= 0) {
+    close(s->fd);
+  }
+  while(s->stack) {
+    tar_pop_dir(s);
+  }
+  canceled = s->task && task_cancel_requested(s->task);
+  if(s->task) {
+    char current[PATH_MAX];
+    snprintf(current, sizeof(current), "%s",
+             s->task->current[0] ? s->task->current : s->task->src);
+    if(canceled) {
+      task_update(s->task, TASK_CANCELED, current, 0, "canceled");
+    } else if(s->error) {
+      errno = s->error;
+      task_update(s->task, TASK_FAILED, current, 0, strerror(errno));
+    } else if(s->done) {
+      task_update(s->task, TASK_DONE, current, 0, NULL);
+    } else {
+      task_update(s->task, TASK_FAILED, current, 0, "client disconnected");
+    }
+  }
+  free(s->pending);
+  free_paths(s->paths, s->path_count);
+  free(s);
+}
+
+static int
+prepare_download_task(file_task_t *task) {
+  unsigned long long total = 0;
+  size_t file_count = 0;
+  size_t dir_count = 0;
+  size_t i;
+
+  task_update(task, TASK_RUNNING, "preparing", 0, NULL);
+  for(i = 0; i < task->src_count; i++) {
+    if(count_task_path_bytes(task, task->srcs[i], task->srcs[i],
+                             &total, &file_count, &dir_count)) {
+      return -1;
+    }
+  }
+  pthread_mutex_lock(&g_tasks_lock);
+  task->total = total;
+  task->file_count = file_count;
+  task->dir_count = dir_count;
+  task->updated_at = time(NULL);
+  pthread_mutex_unlock(&g_tasks_lock);
+  return 0;
+}
+
+static size_t
+append_truncated_name(char *out, size_t size, size_t len, const char *name,
+                      size_t limit) {
+  while(*name && len < limit && len + 1 < size) {
+    unsigned char c = (unsigned char)*name;
+    out[len++] = *name++;
+    if(c >= 0x80) {
+      while((*name & 0xc0) == 0x80 && len < limit && len + 1 < size) {
+        out[len++] = *name++;
+      }
+    }
+  }
+  out[len] = 0;
+  return len;
+}
+
+static void
+download_archive_name(char *out, size_t size, char **paths, size_t count) {
+  char name[PATH_MAX];
+  size_t len = 0;
+  size_t i;
+
+  out[0] = 0;
+  if(count == 1) {
+    path_basename_copy(paths[0], name, sizeof(name));
+    append_truncated_name(out, size, 0, name, DOWNLOAD_ARCHIVE_NAME_LIMIT);
+  } else {
+    for(i = 0; i < count && len < DOWNLOAD_ARCHIVE_NAME_LIMIT; i++) {
+      path_basename_copy(paths[i], name, sizeof(name));
+      if(i && len + 1 < DOWNLOAD_ARCHIVE_NAME_LIMIT && len + 1 < size) {
+        out[len++] = ' ';
+        out[len] = 0;
+      }
+      len = append_truncated_name(out, size, len, name,
+                                  DOWNLOAD_ARCHIVE_NAME_LIMIT);
+    }
+  }
+  if(!out[0]) {
+    snprintf(out, size, "download");
+  }
+  snprintf(out + strlen(out), size - strlen(out), ".tar");
+}
+
+static void
+download_file_name(char *out, size_t size, const char *path) {
+  path_basename_copy(path, out, size);
+  if(!out[0]) {
+    snprintf(out, size, "download");
+  }
+}
+
+static size_t
+header_quoted_filename(char *out, size_t size, const char *name) {
+  size_t len = 0;
+
+  while(*name && len + 1 < size) {
+    unsigned char c = (unsigned char)*name++;
+    if(c < 0x20 || c == 0x7f || c == '"' || c == '\\') {
+      c = '_';
+    }
+    out[len++] = (char)c;
+  }
+  out[len] = 0;
+  return len;
+}
+
+static size_t
+header_percent_filename(char *out, size_t size, const char *name) {
+  static const char hex[] = "0123456789ABCDEF";
+  size_t len = 0;
+
+  while(*name && len + 1 < size) {
+    unsigned char c = (unsigned char)*name++;
+    int safe = (c >= '0' && c <= '9') || (c >= 'A' && c <= 'Z') ||
+               (c >= 'a' && c <= 'z') || c == '.' || c == '_' || c == '-';
+    if(safe) {
+      out[len++] = (char)c;
+    } else {
+      if(len + 3 >= size) {
+        break;
+      }
+      out[len++] = '%';
+      out[len++] = hex[c >> 4];
+      out[len++] = hex[c & 15];
+    }
+  }
+  out[len] = 0;
+  return len;
+}
+
+static void
+add_download_filename_header(struct MHD_Response *resp, const char *name) {
+  char quoted[PATH_MAX];
+  char encoded[PATH_MAX * 3];
+  char header[PATH_MAX * 4];
+
+  header_quoted_filename(quoted, sizeof(quoted), name);
+  header_percent_filename(encoded, sizeof(encoded), name);
+  snprintf(header, sizeof(header),
+           "attachment; filename=\"%s\"; filename*=UTF-8''%s",
+           quoted, encoded);
+  MHD_add_response_header(resp, "Content-Disposition", header);
+}
+
+static enum MHD_Result
+create_download_task_response(struct MHD_Connection *conn, char **paths,
+                              size_t count) {
+  file_task_t *task = calloc(1, sizeof(file_task_t));
+  strbuf_t b = {0};
+  struct stat st;
+  size_t i;
+
+  if(!task) {
+    free_paths(paths, count);
+    return send_json_error(conn, MHD_HTTP_INTERNAL_SERVER_ERROR, "out of memory");
+  }
+  if(!count) {
+    return download_task_request_error(conn, task, paths, count,
+                                       MHD_HTTP_BAD_REQUEST, "no source paths");
+  }
+  for(i = 0; i < count; i++) {
+    if(lstat(paths[i], &st)) {
+      return download_task_request_error(conn, task, paths, count,
+                                         MHD_HTTP_NOT_FOUND, "file not found");
+    }
+    if(!S_ISREG(st.st_mode) && !S_ISDIR(st.st_mode)) {
+      return download_task_request_error(conn, task, paths, count,
+                                         MHD_HTTP_BAD_REQUEST, "invalid path");
+    }
+  }
+  task->op = TASK_DOWNLOAD;
+  task->state = TASK_QUEUED;
+  task->srcs = paths;
+  task->src_count = count;
+  snprintf(task->src, sizeof(task->src), "%s%s", paths[0],
+           count > 1 ? " ..." : "");
+  snprintf(task->current, sizeof(task->current), "%s", task->src);
+  task->created_at = time(NULL);
+  task->updated_at = task->created_at;
+
+  pthread_mutex_lock(&g_tasks_lock);
+  remove_finished_tasks_locked();
+  if(has_active_task_locked()) {
+    pthread_mutex_unlock(&g_tasks_lock);
+    return download_task_request_error(conn, task, paths, count,
+                                       MHD_HTTP_CONFLICT, "another task is running");
+  }
+  task->id = g_next_task_id++;
+  task->next = g_tasks;
+  g_tasks = task;
+  pthread_mutex_unlock(&g_tasks_lock);
+
+  strbuf_printf(&b, "{\"ok\":true,\"task_id\":%lu}", task->id);
+  return send_buffer(conn, MHD_HTTP_OK, b.data, "application/json");
+}
+
+enum MHD_Result
+api_download_prepare(struct MHD_Connection *conn, const char *body,
+                     size_t body_size) {
+  char *paths_raw = body_form_value(body, body_size, "paths");
+  char **paths = NULL;
+  size_t count = 0;
+
+  if(!paths_raw || parse_paths(paths_raw, &paths, &count)) {
+    free(paths_raw);
+    return send_json_error(conn, MHD_HTTP_BAD_REQUEST, "invalid path");
+  }
+  free(paths_raw);
+  return create_download_task_response(conn, paths, count);
+}
+
+static ssize_t
+download_file_read(void *cls, uint64_t pos, char *buf, size_t max) {
+  download_file_stream_t *s = cls;
+  size_t len;
+  (void)pos;
+
+  if(task_cancel_requested(s->task)) {
+    s->error = ECANCELED;
+    return MHD_CONTENT_READER_END_WITH_ERROR;
+  }
+  if(fseek(s->file, (long)pos, SEEK_SET)) {
+    s->error = errno ? errno : EIO;
+    return MHD_CONTENT_READER_END_WITH_ERROR;
+  }
+  if(!(len = fread(buf, 1, max, s->file))) {
+    if(ferror(s->file)) {
+      s->error = errno ? errno : EIO;
+      return MHD_CONTENT_READER_END_WITH_ERROR;
+    }
+    s->done = 1;
+    return MHD_CONTENT_READER_END_OF_STREAM;
+  }
+  {
+    unsigned long long end = (unsigned long long)pos + (unsigned long long)len;
+    unsigned long long add = end > s->sent ? end - s->sent : 0;
+    if(end > s->sent) {
+      s->sent = end;
+    }
+    if(s->sent >= s->size) {
+      s->done = 1;
+    }
+    task_update(s->task, TASK_RUNNING, s->task->src, add, NULL);
+  }
+  return (ssize_t)len;
+}
+
+static void
+download_file_close(void *cls) {
+  download_file_stream_t *s = cls;
+  int canceled;
+
+  if(!s) {
+    return;
+  }
+  if(s->file) {
+    fclose(s->file);
+  }
+  canceled = task_cancel_requested(s->task);
+  if(canceled) {
+    task_update(s->task, TASK_CANCELED, s->task->src, 0, "canceled");
+  } else if(s->error) {
+    errno = s->error;
+    task_update(s->task, TASK_FAILED, s->task->src, 0, strerror(errno));
+  } else if(s->done) {
+    task_update(s->task, TASK_DONE, s->task->src, 0, NULL);
+  } else {
+    task_update(s->task, TASK_FAILED, s->task->src, 0, "client disconnected");
+  }
+  free(s);
+}
+
+enum MHD_Result
+api_download(struct MHD_Connection *conn) {
+  char *idstr = query_value(conn, "id");
+  unsigned long id = idstr ? strtoul(idstr, NULL, 10) : 0;
+  char **paths = NULL;
+  size_t count = 0;
+  struct stat st;
+  tar_stream_t *stream;
+  struct MHD_Response *resp;
+  enum MHD_Result ret;
+  file_task_t *task;
+  char download_name[PATH_MAX];
+
+  free(idstr);
+  pthread_mutex_lock(&g_tasks_lock);
+  task = find_task_locked(id);
+  if(!task || task->op != TASK_DOWNLOAD || task->state != TASK_QUEUED) {
+    pthread_mutex_unlock(&g_tasks_lock);
+    return send_json_error(conn, MHD_HTTP_NOT_FOUND, "active task not found");
+  }
+  task->state = TASK_RUNNING;
+  task->updated_at = time(NULL);
+  pthread_mutex_unlock(&g_tasks_lock);
+
+  if(prepare_download_task(task)) {
+    char current[PATH_MAX];
+    snprintf(current, sizeof(current), "%s",
+             task->current[0] ? task->current : task->src);
+    if(errno == ECANCELED || task_cancel_requested(task)) {
+      task_update(task, TASK_CANCELED, current, 0, "canceled");
+    } else {
+      task_update(task, TASK_FAILED, current, 0, strerror(errno));
+    }
+    return send_json_error(conn, MHD_HTTP_INTERNAL_SERVER_ERROR, NULL);
+  }
+
+  paths = task->srcs;
+  count = task->src_count;
+  if(count == 1 && !stat(paths[0], &st) && S_ISREG(st.st_mode)) {
+    download_file_stream_t *file_stream = calloc(1, sizeof(*file_stream));
+    if(!file_stream) {
+      task_update(task, TASK_FAILED, task->src, 0, "out of memory");
+      return send_json_error(conn, MHD_HTTP_INTERNAL_SERVER_ERROR, "out of memory");
+    }
+    file_stream->task = task;
+    file_stream->size = (unsigned long long)st.st_size;
+    file_stream->done = file_stream->size == 0;
+    file_stream->file = fopen(paths[0], "rb");
+    if(!file_stream->file) {
+      free(file_stream);
+      task_update(task, TASK_FAILED, task->src, 0, strerror(errno));
+      return send_json_error(conn, MHD_HTTP_NOT_FOUND, "file not found");
+    }
+    resp = MHD_create_response_from_callback((uint64_t)st.st_size, 32 * 0x4000,
+                                             download_file_read, file_stream,
+                                             download_file_close);
+    if(!resp) {
+      download_file_close(file_stream);
+      return MHD_NO;
+    }
+    MHD_add_response_header(resp, MHD_HTTP_HEADER_CONTENT_TYPE,
+                            "application/octet-stream");
+    download_file_name(download_name, sizeof(download_name), paths[0]);
+    add_download_filename_header(resp, download_name);
+    ret = websrv_queue_response(conn, MHD_HTTP_OK, resp);
+    MHD_destroy_response(resp);
+    return ret;
+  }
+  if(!(stream = calloc(1, sizeof(*stream)))) {
+    task_update(task, TASK_FAILED, task->src, 0, "out of memory");
+    return send_json_error(conn, MHD_HTTP_INTERNAL_SERVER_ERROR, "out of memory");
+  }
+  stream->fd = -1;
+  stream->task = task;
+  stream->paths = NULL;
+  stream->path_count = count;
+  stream->paths = calloc(count, sizeof(char *));
+  if(!stream->paths) {
+    tar_close(stream);
+    task_update(task, TASK_FAILED, task->src, 0, "out of memory");
+    return send_json_error(conn, MHD_HTTP_INTERNAL_SERVER_ERROR, "out of memory");
+  }
+  for(size_t i = 0; i < count; i++) {
+    stream->paths[i] = strdup(paths[i]);
+    if(!stream->paths[i]) {
+      stream->path_count = i;
+      tar_close(stream);
+      task_update(task, TASK_FAILED, task->src, 0, "out of memory");
+      return send_json_error(conn, MHD_HTTP_INTERNAL_SERVER_ERROR, "out of memory");
+    }
+  }
+  resp = MHD_create_response_from_callback(MHD_SIZE_UNKNOWN, 32 * 0x4000,
+                                           tar_read, stream, tar_close);
+  if(!resp) {
+    tar_close(stream);
+    return MHD_NO;
+  }
+  MHD_add_response_header(resp, MHD_HTTP_HEADER_CONTENT_TYPE,
+                          "application/x-tar");
+  download_archive_name(download_name, sizeof(download_name), paths, count);
+  add_download_filename_header(resp, download_name);
+  ret = websrv_queue_response(conn, MHD_HTTP_OK, resp);
+  MHD_destroy_response(resp);
+  return ret;
+}
@@ -0,0 +1,68 @@
+#include "filemgr.h"
+
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#include "filemgr_internal.h"
+#include "mime.h"
+#include "path_util.h"
+#include "websrv.h"
+
+static ssize_t
+file_read(void *cls, uint64_t pos, char *buf, size_t max) {
+  FILE *file = cls;
+  size_t len;
+
+  if(fseek(file, (long)pos, SEEK_SET)) {
+    return MHD_CONTENT_READER_END_WITH_ERROR;
+  }
+  if(!(len = fread(buf, 1, max, file))) {
+    return ferror(file) ? MHD_CONTENT_READER_END_WITH_ERROR :
+                          MHD_CONTENT_READER_END_OF_STREAM;
+  }
+  return (ssize_t)len;
+}
+
+static void
+file_close(void *cls) {
+  fclose((FILE *)cls);
+}
+
+enum MHD_Result
+filemgr_fs_request(struct MHD_Connection *conn) {
+  char *path = fs_path_value(query_value(conn, "path"));
+  struct MHD_Response *resp;
+  enum MHD_Result ret = MHD_NO;
+  struct stat st;
+  FILE *file;
+
+  if(has_active_task()) {
+    return send_json_error(conn, MHD_HTTP_CONFLICT, "another task is running");
+  }
+
+  if(!path || stat(path, &st) || !S_ISREG(st.st_mode) ||
+     !(file = fopen(path, "rb"))) {
+    free(path);
+    return send_json_error(conn, MHD_HTTP_NOT_FOUND, "file not found");
+  }
+
+  if((resp = MHD_create_response_from_callback((uint64_t)st.st_size,
+                                               32 * 0x4000, file_read, file,
+                                               file_close))) {
+    const char *mime = mime_get_type(path);
+    if(mime) {
+      MHD_add_response_header(resp, MHD_HTTP_HEADER_CONTENT_TYPE, mime);
+    }
+    ret = websrv_queue_response(conn, MHD_HTTP_OK, resp);
+    MHD_destroy_response(resp);
+    free(path);
+    return ret;
+  }
+
+  fclose(file);
+  free(path);
+  return MHD_NO;
+}
@@ -3,5 +3,12 @@
 #include <microhttpd.h>

 enum MHD_Result filemgr_api_request(struct MHD_Connection *conn,
-                                    const char *url);
+                                    const char *url, const char *method,
+                                    const char *body, size_t body_size);
 enum MHD_Result filemgr_fs_request(struct MHD_Connection *conn);
+
+int filemgr_upload_begin(struct MHD_Connection *conn, void **upload_ctx);
+int filemgr_upload_data(void *upload_ctx, const char *data, size_t size);
+enum MHD_Result filemgr_upload_finish(struct MHD_Connection *conn,
+                                      void *upload_ctx);
+void filemgr_upload_free(void *upload_ctx);
@@ -0,0 +1,120 @@
+#pragma once
+
+#include <limits.h>
+#include <pthread.h>
+#include <stddef.h>
+#include <time.h>
+
+#include <microhttpd.h>
+
+#define ETA_SAMPLE_SLOTS 64
+
+typedef enum task_op {
+  TASK_COPY,
+  TASK_MOVE,
+  TASK_DELETE,
+  TASK_DOWNLOAD,
+  TASK_UPLOAD,
+} task_op_t;
+
+typedef enum task_state {
+  TASK_QUEUED,
+  TASK_RUNNING,
+  TASK_DONE,
+  TASK_FAILED,
+  TASK_CANCELED,
+} task_state_t;
+
+typedef struct task_eta_sample {
+  unsigned long long done;
+  struct timespec time;
+} task_eta_sample_t;
+
+typedef struct file_task {
+  unsigned long id;
+  task_op_t op;
+  task_state_t state;
+  char src[PATH_MAX];
+  char dst[PATH_MAX];
+  char current[PATH_MAX];
+  char error[160];
+  char error_code[64];
+  char error_arg[PATH_MAX + 96];
+  char **srcs;
+  size_t src_count;
+  size_t file_count;
+  size_t dir_count;
+  unsigned long long total;
+  unsigned long long done;
+  unsigned long long speed;
+  unsigned long long eta;
+  unsigned long long speed_sample_done;
+  struct timespec speed_sample_time;
+  task_eta_sample_t eta_samples[ETA_SAMPLE_SLOTS];
+  unsigned int eta_sample_next;
+  unsigned int eta_sample_count;
+  int cancel_requested;
+  time_t created_at;
+  time_t transfer_started_at;
+  time_t updated_at;
+  pthread_t thread;
+  struct file_task *next;
+} file_task_t;
+
+extern pthread_mutex_t g_tasks_lock;
+extern file_task_t *g_tasks;
+extern unsigned long g_next_task_id;
+
+const char *task_op_name(task_op_t op);
+const char *task_state_name(task_state_t state);
+int task_is_active(const file_task_t *task);
+int has_active_task_locked(void);
+int has_active_task(void);
+void free_task(file_task_t *task);
+void remove_finished_tasks_locked(void);
+int task_cancel_requested(file_task_t *task);
+file_task_t *find_task_locked(unsigned long id);
+void task_update(file_task_t *task, task_state_t state, const char *current,
+                 unsigned long long add_done, const char *error);
+void record_task_completion_locked(file_task_t *task, time_t completed_at);
+
+enum MHD_Result send_json_ok(struct MHD_Connection *conn);
+enum MHD_Result send_json_error(struct MHD_Connection *conn,
+                                unsigned int status, const char *msg);
+enum MHD_Result send_json_error_detail(struct MHD_Connection *conn,
+                                       unsigned int status, const char *msg,
+                                       const char *code, const char *arg);
+enum MHD_Result send_buffer(struct MHD_Connection *conn, unsigned int status,
+                            char *data, const char *mime);
+
+int ensure_parent_dirs(const char *base, const char *rel);
+int chmod_path_0777(const char *path);
+int fchmod_0777(int fd);
+int ignore_chmod_error(int err);
+int mode_access(const char *path, int mode);
+int check_target_writable(const char *target, char ***checked_dirs,
+                          size_t *checked_dir_count,
+                          char *error, size_t error_size,
+                          char *code, size_t code_size,
+                          char *arg, size_t arg_size);
+int check_target_space(const char *target, unsigned long long required,
+                       char *error, size_t error_size,
+                       char *code, size_t code_size,
+                       char *arg, size_t arg_size);
+int target_available_space(const char *target, unsigned long long *available);
+int count_task_path_bytes(file_task_t *task, const char *path,
+                          const char *display, unsigned long long *total,
+                          size_t *file_count, size_t *dir_count);
+
+enum MHD_Result api_upload_prepare(struct MHD_Connection *conn,
+                                   const char *body, size_t body_size);
+enum MHD_Result api_upload_finish(struct MHD_Connection *conn);
+enum MHD_Result api_download_prepare(struct MHD_Connection *conn,
+                                     const char *body, size_t body_size);
+enum MHD_Result api_download(struct MHD_Connection *conn);
+enum MHD_Result api_list(struct MHD_Connection *conn);
+enum MHD_Result api_space(struct MHD_Connection *conn);
+enum MHD_Result api_text(struct MHD_Connection *conn);
+enum MHD_Result api_text_create(struct MHD_Connection *conn);
+enum MHD_Result api_text_save(struct MHD_Connection *conn, const char *body,
+                              size_t body_size);
@@ -0,0 +1,356 @@
+#include "filemgr_internal.h"
+
+#include <errno.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/statvfs.h>
+#include <sys/types.h>
+#ifdef __linux__
+#include <sys/vfs.h>
+#else
+#include <sys/mount.h>
+#endif
+#include <time.h>
+#include <unistd.h>
+
+#include "path_util.h"
+
+int
+ignore_chmod_error(int err) {
+  return err == ENOTSUP || err == EPERM || err == EINVAL || err == EROFS;
+}
+
+#ifndef __linux__
+static int
+fs_type_has_unix_modes(const char *type) {
+  return strcmp(type, "exfat") &&
+         strcmp(type, "exfatfs") &&
+         strcmp(type, "msdosfs") &&
+         strcmp(type, "fat") &&
+         strcmp(type, "vfat");
+}
+#endif
+
+static int
+path_has_unix_modes(const char *path) {
+#ifdef __linux__
+  (void)path;
+  return 1;
+#else
+  struct statfs fs;
+
+  if(statfs(path, &fs)) {
+    return 1;
+  }
+  return fs_type_has_unix_modes(fs.f_fstypename);
+#endif
+}
+
+static int
+fd_has_unix_modes(int fd) {
+#ifdef __linux__
+  (void)fd;
+  return 1;
+#else
+  struct statfs fs;
+
+  if(fstatfs(fd, &fs)) {
+    return 1;
+  }
+  return fs_type_has_unix_modes(fs.f_fstypename);
+#endif
+}
+
+int
+chmod_path_0777(const char *path) {
+  if(!path_has_unix_modes(path)) {
+    return 0;
+  }
+  if(chmod(path, 0777) && !ignore_chmod_error(errno)) {
+    return -1;
+  }
+  return 0;
+}
+
+int
+fchmod_0777(int fd) {
+  if(!fd_has_unix_modes(fd)) {
+    return 0;
+  }
+  if(fchmod(fd, 0777) && !ignore_chmod_error(errno)) {
+    return -1;
+  }
+  return 0;
+}
+
+static int
+target_statvfs(const char *target, struct statvfs *vfs) {
+  char parent[PATH_MAX];
+
+  if(!statvfs(target, vfs)) {
+    return 0;
+  }
+  if(path_dirname(target, parent, sizeof(parent))) {
+    return -1;
+  }
+  return statvfs(parent, vfs);
+}
+
+int
+target_available_space(const char *target, unsigned long long *available) {
+  struct statvfs vfs;
+  unsigned long long block_size;
+
+  if(target_statvfs(target, &vfs)) {
+    return -1;
+  }
+  block_size = vfs.f_frsize ? vfs.f_frsize : vfs.f_bsize;
+  *available = (unsigned long long)vfs.f_bavail * block_size;
+  return 0;
+}
+
+int
+check_target_space(const char *target, unsigned long long required,
+                   char *error, size_t error_size,
+                   char *code, size_t code_size,
+                   char *arg, size_t arg_size) {
+  unsigned long long available;
+
+  if(!required) {
+    return 0;
+  }
+  if(target_available_space(target, &available)) {
+    snprintf(error, error_size, "cannot read target free space");
+    snprintf(code, code_size, "space_check_failed");
+    snprintf(arg, arg_size, "%s", target);
+    return -1;
+  }
+  if(available < required) {
+    snprintf(error, error_size,
+             "not enough target space, required %llu bytes, available %llu bytes",
+             required, available);
+    snprintf(code, code_size, "no_space");
+    snprintf(arg, arg_size, "%llu,%llu", required, available);
+    errno = ENOSPC;
+    return -1;
+  }
+  return 0;
+}
+
+static void
+set_error_detail(char *error, size_t error_size, char *code, size_t code_size,
+                 char *arg, size_t arg_size, const char *error_code,
+                 const char *message, const char *path) {
+  snprintf(error, error_size, "%s: %s", message, path);
+  snprintf(code, code_size, "%s", error_code);
+  snprintf(arg, arg_size, "%s", path);
+}
+
+static void
+set_permission_error_detail(char *error, size_t error_size,
+                            char *code, size_t code_size,
+                            char *arg, size_t arg_size,
+                            const char *error_code, const char *message,
+                            const char *path) {
+  struct stat st;
+
+  set_error_detail(error, error_size, code, code_size, arg, arg_size,
+                   error_code, message, path);
+  if(!stat(path, &st)) {
+    snprintf(arg, arg_size, "%s (mode=%04o, uid=%lu, gid=%lu)", path,
+             (unsigned int)(st.st_mode & 07777),
+             (unsigned long)st.st_uid, (unsigned long)st.st_gid);
+  }
+}
+
+static int
+mode_access_stat(const struct stat *st, int mode) {
+  mode_t allowed;
+  uid_t uid = geteuid();
+
+  if(uid == 0) {
+    if(!(mode & X_OK) || !S_ISREG(st->st_mode) ||
+       (st->st_mode & (S_IXUSR | S_IXGRP | S_IXOTH))) {
+      return 0;
+    }
+  } else if(uid == st->st_uid) {
+    allowed = (st->st_mode >> 6) & 7;
+    if((allowed & mode) == (mode_t)mode) {
+      return 0;
+    }
+  } else {
+    gid_t gid = getegid();
+    int group_match = gid == st->st_gid;
+
+    if(!group_match) {
+      int count = getgroups(0, NULL);
+      gid_t *groups = count > 0 ? malloc((size_t)count * sizeof(*groups)) : NULL;
+
+      if(groups && getgroups(count, groups) == count) {
+        int i;
+        for(i = 0; i < count; i++) {
+          if(groups[i] == st->st_gid) {
+            group_match = 1;
+            break;
+          }
+        }
+      }
+      free(groups);
+    }
+    allowed = group_match ? (st->st_mode >> 3) & 7 : st->st_mode & 7;
+    if((allowed & mode) == (mode_t)mode) {
+      return 0;
+    }
+  }
+  errno = EACCES;
+  return -1;
+}
+
+int
+mode_access(const char *path, int mode) {
+  struct stat st;
+
+  return stat(path, &st) ? -1 : mode_access_stat(&st, mode);
+}
+
+static int
+probe_dir_writable(const char *path) {
+  char name[80];
+  char probe[PATH_MAX];
+  int attempt;
+
+  for(attempt = 0; attempt < 16; attempt++) {
+    int fd;
+    int error = 0;
+
+    snprintf(name, sizeof(name), ".web-file-mgr-%ld-%lld-%d.tmp",
+             (long)getpid(), (long long)time(NULL), attempt);
+    if(path_join(probe, sizeof(probe), path, name)) {
+      return -1;
+    }
+    fd = open(probe, O_WRONLY | O_CREAT | O_EXCL, 0600);
+    if(fd < 0) {
+      if(errno == EEXIST) {
+        continue;
+      }
+      return -1;
+    }
+    if(close(fd)) {
+      error = errno;
+    }
+    if(unlink(probe) && !error) {
+      error = errno;
+    }
+    if(error) {
+      errno = error;
+      return -1;
+    }
+    return 0;
+  }
+  errno = EEXIST;
+  return -1;
+}
+
+static int
+probe_file_writable(const char *path) {
+  int fd = open(path, O_WRONLY);
+
+  return fd < 0 ? -1 : close(fd);
+}
+
+static int
+path_seen(char **paths, size_t count, const char *path) {
+  size_t i;
+
+  for(i = 0; i < count; i++) {
+    if(!strcmp(paths[i], path)) {
+      return 1;
+    }
+  }
+  return 0;
+}
+
+static int
+remember_path(char ***paths, size_t *count, const char *path) {
+  char **tmp;
+
+  if(path_seen(*paths, *count, path)) {
+    return 0;
+  }
+  tmp = realloc(*paths, sizeof(char *) * (*count + 1));
+  if(!tmp) {
+    errno = ENOMEM;
+    return -1;
+  }
+  *paths = tmp;
+  (*paths)[*count] = strdup(path);
+  if(!(*paths)[*count]) {
+    errno = ENOMEM;
+    return -1;
+  }
+  (*count)++;
+  return 0;
+}
+
+static int
+probe_dir_once(const char *path, char ***checked, size_t *checked_count) {
+  if(path_seen(*checked, *checked_count, path)) {
+    return 0;
+  }
+  if(probe_dir_writable(path)) {
+    return -1;
+  }
+  return remember_path(checked, checked_count, path);
+}
+
+int
+check_target_writable(const char *target, char ***checked_dirs,
+                      size_t *checked_dir_count, char *error, size_t error_size,
+                      char *code, size_t code_size, char *arg, size_t arg_size) {
+  struct stat st;
+  char parent[PATH_MAX];
+
+  if(!stat(target, &st)) {
+    if(S_ISDIR(st.st_mode)) {
+      if(probe_dir_once(target, checked_dirs, checked_dir_count)) {
+        set_permission_error_detail(error, error_size, code, code_size,
+                                    arg, arg_size, "target_dir_not_writable",
+                                    "target directory is not writable", target);
+        return -1;
+      }
+    } else {
+      if(probe_file_writable(target)) {
+        set_permission_error_detail(error, error_size, code, code_size,
+                                    arg, arg_size, "target_file_not_writable",
+                                    "target file is not writable", target);
+        return -1;
+      }
+      goto check_parent;
+    }
+    return 0;
+  }
+
+  if(errno != ENOENT) {
+    set_error_detail(error, error_size, code, code_size, arg, arg_size,
+                     "target_check_failed", "cannot check target path", target);
+    return -1;
+  }
+
+check_parent:
+  if(path_dirname(target, parent, sizeof(parent))) {
+    set_error_detail(error, error_size, code, code_size, arg, arg_size,
+                     "target_check_failed", "cannot check target path", target);
+    return -1;
+  }
+  if(probe_dir_once(parent, checked_dirs, checked_dir_count)) {
+    set_permission_error_detail(error, error_size, code, code_size,
+                                arg, arg_size, "target_parent_not_writable",
+                                "current directory is not writable", parent);
+    return -1;
+  }
+  return 0;
+}
@@ -0,0 +1,90 @@
+#include "json_util.h"
+
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int
+strbuf_reserve(strbuf_t *b, size_t extra) {
+  size_t need = b->len + extra + 1;
+  char *tmp;
+  size_t cap;
+
+  if(need <= b->cap) {
+    return 0;
+  }
+
+  cap = b->cap ? b->cap : 4096;
+  while(cap < need) {
+    cap *= 2;
+  }
+
+  if(!(tmp = realloc(b->data, cap))) {
+    return -1;
+  }
+
+  b->data = tmp;
+  b->cap = cap;
+  return 0;
+}
+
+int
+strbuf_append(strbuf_t *b, const char *s) {
+  size_t n = strlen(s);
+  if(strbuf_reserve(b, n)) {
+    return -1;
+  }
+  memcpy(b->data + b->len, s, n + 1);
+  b->len += n;
+  return 0;
+}
+
+int
+strbuf_printf(strbuf_t *b, const char *fmt, ...) {
+  va_list ap;
+  va_list cp;
+  int n;
+
+  va_start(ap, fmt);
+  va_copy(cp, ap);
+  n = vsnprintf(NULL, 0, fmt, cp);
+  va_end(cp);
+  if(n < 0 || strbuf_reserve(b, (size_t)n)) {
+    va_end(ap);
+    return -1;
+  }
+
+  vsnprintf(b->data + b->len, b->cap - b->len, fmt, ap);
+  va_end(ap);
+  b->len += (size_t)n;
+  return 0;
+}
+
+int
+json_escape(strbuf_t *b, const char *s) {
+  if(strbuf_append(b, "\"")) return -1;
+  while(*s) {
+    unsigned char c = (unsigned char)*s;
+    switch(c) {
+    case '"': if(strbuf_append(b, "\\\"")) return -1; s++; break;
+    case '\\': if(strbuf_append(b, "\\\\")) return -1; s++; break;
+    case '\b': if(strbuf_append(b, "\\b")) return -1; s++; break;
+    case '\f': if(strbuf_append(b, "\\f")) return -1; s++; break;
+    case '\n': if(strbuf_append(b, "\\n")) return -1; s++; break;
+    case '\r': if(strbuf_append(b, "\\r")) return -1; s++; break;
+    case '\t': if(strbuf_append(b, "\\t")) return -1; s++; break;
+    default:
+      if(c < 0x20 || c >= 0x80) {
+        if(strbuf_printf(b, "\\u%04x", c)) return -1;
+      } else {
+        if(strbuf_reserve(b, 1)) return -1;
+        b->data[b->len++] = (char)c;
+        b->data[b->len] = 0;
+      }
+      s++;
+      break;
+    }
+  }
+  return strbuf_append(b, "\"");
+}
@@ -0,0 +1,14 @@
+#pragma once
+
+#include <stddef.h>
+
+typedef struct strbuf {
+  char *data;
+  size_t len;
+  size_t cap;
+} strbuf_t;
+
+int strbuf_reserve(strbuf_t *b, size_t extra);
+int strbuf_append(strbuf_t *b, const char *s);
+int strbuf_printf(strbuf_t *b, const char *fmt, ...);
+int json_escape(strbuf_t *b, const char *s);
@@ -0,0 +1,84 @@
+#include "filemgr_internal.h"
+
+#include <dirent.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+#include "json_util.h"
+#include "path_util.h"
+
+static char
+mode_type(const struct stat *st) {
+  if(S_ISDIR(st->st_mode)) return 'd';
+  if(S_ISLNK(st->st_mode)) return 'l';
+  if(S_ISCHR(st->st_mode)) return 'c';
+  if(S_ISBLK(st->st_mode)) return 'b';
+  if(S_ISFIFO(st->st_mode)) return 'p';
+  if(S_ISSOCK(st->st_mode)) return 's';
+  return '-';
+}
+
+enum MHD_Result
+api_list(struct MHD_Connection *conn) {
+  char *path = fs_path_value(query_value(conn, "path"));
+  DIR *dir;
+  struct dirent *entry;
+  struct stat st;
+  strbuf_t b = {0};
+  int first = 1;
+
+  if(has_active_task()) {
+    return send_json_error(conn, MHD_HTTP_CONFLICT, "another task is running");
+  }
+
+  if(!path) {
+    path = strdup("/");
+  }
+  if(!(dir = opendir(path))) {
+    free(path);
+    return send_json_error(conn, MHD_HTTP_NOT_FOUND, NULL);
+  }
+
+  strbuf_append(&b, "{\"ok\":true,\"path\":");
+  json_escape(&b, path);
+  strbuf_append(&b, ",\"parent\":");
+  char parent[PATH_MAX];
+  if(path_dirname(path, parent, sizeof(parent))) {
+    strcpy(parent, "/");
+  }
+  json_escape(&b, parent);
+  strbuf_append(&b, ",\"entries\":[");
+
+  while((entry = readdir(dir))) {
+    char child[PATH_MAX];
+
+    if(!strcmp(entry->d_name, ".") || !strcmp(entry->d_name, "..")) {
+      continue;
+    }
+    if(path_join(child, sizeof(child), path, entry->d_name) ||
+       lstat(child, &st)) {
+      continue;
+    }
+
+    if(!first) {
+      strbuf_append(&b, ",");
+    }
+    first = 0;
+    strbuf_append(&b, "{\"name\":");
+    json_escape(&b, entry->d_name);
+    strbuf_append(&b, ",\"path\":");
+    json_escape(&b, child);
+    strbuf_printf(&b, ",\"type\":\"%c\",\"mode\":%u,\"size\":%lld,\"mtime\":%lld}",
+                  mode_type(&st), (unsigned int)(st.st_mode & 07777),
+                  (long long)st.st_size, (long long)st.st_mtime);
+  }
+
+  closedir(dir);
+  free(path);
+  strbuf_append(&b, "]}");
+  return send_buffer(conn, MHD_HTTP_OK, b.data, "application/json");
+}
@@ -150,6 +150,9 @@ main(int argc, char **argv) {
 #endif

    websrv_listen(port);
+    if(websrv_stop_requested()) {
+      break;
+    }
    sleep(3);
  }

@@ -8,8 +8,10 @@ typedef struct mime_entry {
 } mime_entry_t;

 static const mime_entry_t g_mimes[] = {
+  {"bmp", "image/bmp"},
  {"css", "text/css"},
  {"elf", "application/octet-stream"},
+  {"gif", "image/gif"},
  {"html", "text/html"},
  {"jpeg", "image/jpeg"},
  {"jpg", "image/jpeg"},
@@ -20,6 +22,7 @@ static const mime_entry_t g_mimes[] = {
  {"png", "image/png"},
  {"txt", "text/plain"},
  {"xml", "text/xml"},
+  {"webp", "image/webp"},
  {"zip", "application/zip"},
 };

@@ -0,0 +1,401 @@
+#include "path_util.h"
+
+#include <ctype.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+char *
+query_value(struct MHD_Connection *conn, const char *key) {
+  const char *raw = MHD_lookup_connection_value(conn, MHD_GET_ARGUMENT_KIND, key);
+  char *value = raw ? strdup(raw) : NULL;
+
+  if(value && !strcmp(key, "name")) {
+    char *start = value;
+    char *end;
+    while(isspace((unsigned char)*start)) start++;
+    end = start + strlen(start);
+    while(end > start && isspace((unsigned char)end[-1])) end--;
+    memmove(value, start, (size_t)(end - start));
+    value[end - start] = 0;
+  }
+  return value;
+}
+
+char *
+header_value(struct MHD_Connection *conn, const char *key) {
+  const char *raw = MHD_lookup_connection_value(conn, MHD_HEADER_KIND, key);
+  return raw ? form_decode(raw, strlen(raw)) : NULL;
+}
+
+char *
+request_value(struct MHD_Connection *conn, const char *header,
+              const char *query) {
+  char *value = header_value(conn, header);
+  return value ? value : query_value(conn, query);
+}
+
+static int
+hex_value(char c) {
+  if(c >= '0' && c <= '9') return c - '0';
+  if(c >= 'a' && c <= 'f') return c - 'a' + 10;
+  if(c >= 'A' && c <= 'F') return c - 'A' + 10;
+  return -1;
+}
+
+char *
+form_decode(const char *src, size_t len) {
+  char *out = malloc(len + 1);
+  size_t i;
+  size_t j = 0;
+
+  if(!out) {
+    return NULL;
+  }
+  for(i = 0; i < len; i++) {
+    if(src[i] == '+') {
+      out[j++] = ' ';
+    } else if(src[i] == '%' && i + 2 < len) {
+      int hi = hex_value(src[i + 1]);
+      int lo = hex_value(src[i + 2]);
+      if(hi >= 0 && lo >= 0) {
+        out[j++] = (char)((hi << 4) | lo);
+        i += 2;
+      } else {
+        out[j++] = src[i];
+      }
+    } else {
+      out[j++] = src[i];
+    }
+  }
+  out[j] = 0;
+  return out;
+}
+
+char *
+body_form_value(const char *body, size_t body_size, const char *key) {
+  size_t key_len = strlen(key);
+  size_t pos = 0;
+
+  while(body && pos < body_size) {
+    size_t start = pos;
+    size_t end;
+    size_t eq;
+
+    while(pos < body_size && body[pos] != '&') {
+      pos++;
+    }
+    end = pos;
+    if(pos < body_size && body[pos] == '&') {
+      pos++;
+    }
+    eq = start;
+    while(eq < end && body[eq] != '=') {
+      eq++;
+    }
+    if(eq - start == key_len && !strncmp(body + start, key, key_len)) {
+      return form_decode(body + eq + (eq < end), end - eq - (eq < end));
+    }
+  }
+  return NULL;
+}
+
+void
+free_paths(char **paths, size_t count) {
+  size_t i;
+
+  if(!paths) {
+    return;
+  }
+  for(i = 0; i < count; i++) {
+    free(paths[i]);
+  }
+  free(paths);
+}
+
+int
+parse_paths(const char *raw, char ***out_paths, size_t *out_count) {
+  char *copy;
+  char *line;
+  char *save;
+  char **paths = NULL;
+  size_t count = 0;
+  size_t capacity = 0;
+  const char *p;
+  int in_line = 0;
+
+  *out_paths = NULL;
+  *out_count = 0;
+
+  if(!raw || !raw[0]) {
+    errno = EINVAL;
+    return -1;
+  }
+  for(p = raw; *p; p++) {
+    if(*p == '\n') {
+      if(in_line) {
+        capacity++;
+        in_line = 0;
+      }
+      continue;
+    }
+    in_line = 1;
+  }
+  if(in_line) {
+    capacity++;
+  }
+  if(!capacity) {
+    errno = EINVAL;
+    return -1;
+  }
+
+  if(!(paths = calloc(capacity, sizeof(char *))) ||
+     !(copy = strdup(raw))) {
+    free(paths);
+    errno = ENOMEM;
+    return -1;
+  }
+
+  for(line = strtok_r(copy, "\n", &save); line; line = strtok_r(NULL, "\n", &save)) {
+    if(!line[0]) {
+      continue;
+    }
+    if(!(paths[count] = fs_path_value(strdup(line)))) {
+      free_paths(paths, count);
+      free(copy);
+      errno = ENOMEM;
+      return -1;
+    }
+    count++;
+  }
+
+  free(copy);
+  if(!count) {
+    errno = EINVAL;
+    return -1;
+  }
+
+  *out_paths = paths;
+  *out_count = count;
+  return 0;
+}
+
+const char *
+path_basename(const char *path) {
+  const char *end = path + strlen(path);
+  const char *base;
+
+  while(end > path && end[-1] == '/') {
+    end--;
+  }
+  base = end;
+  while(base > path && base[-1] != '/') {
+    base--;
+  }
+  return base;
+}
+
+void
+path_basename_copy(const char *path, char *out, size_t size) {
+  const char *end = path + strlen(path);
+  const char *base;
+  size_t len;
+
+  while(end > path && end[-1] == '/') {
+    end--;
+  }
+  base = end;
+  while(base > path && base[-1] != '/') {
+    base--;
+  }
+  len = (size_t)(end - base);
+  if(!len) {
+    snprintf(out, size, "root");
+    return;
+  }
+  if(len >= size) {
+    len = size - 1;
+  }
+  memcpy(out, base, len);
+  out[len] = 0;
+}
+
+int
+path_dirname(const char *path, char *out, size_t size) {
+  const char *base = path_basename(path);
+  size_t len = (size_t)(base - path);
+
+  while(len > 1 && path[len - 1] == '/') {
+    len--;
+  }
+  if(!len) {
+    len = 1;
+  }
+  if(len >= size) {
+    return -1;
+  }
+  memcpy(out, path, len);
+  out[len] = 0;
+  return 0;
+}
+
+int
+path_join(char *out, size_t size, const char *dir, const char *name) {
+  int n;
+  if(!dir || !name || !dir[0] || !name[0] || strchr(name, '/')) {
+    errno = EINVAL;
+    return -1;
+  }
+  n = snprintf(out, size, "%s%s%s", dir,
+               (strcmp(dir, "/") && dir[strlen(dir) - 1] != '/') ? "/" : "",
+               name);
+  if(n < 0 || (size_t)n >= size) {
+    errno = ENAMETOOLONG;
+    return -1;
+  }
+  return 0;
+}
+
+int
+relative_path_safe(const char *path) {
+  const char *p = path;
+
+  if(!path || !path[0] || path[0] == '/') {
+    errno = EINVAL;
+    return 0;
+  }
+  while(*p) {
+    const char *start = p;
+    size_t len;
+
+    while(*p && *p != '/') {
+      if(*p == '\\') {
+        errno = EINVAL;
+        return 0;
+      }
+      p++;
+    }
+    len = (size_t)(p - start);
+    if(!len || (len == 1 && start[0] == '.') ||
+       (len == 2 && start[0] == '.' && start[1] == '.')) {
+      errno = EINVAL;
+      return 0;
+    }
+    if(*p == '/') {
+      p++;
+    }
+  }
+  return 1;
+}
+
+int
+path_join_relative(char *out, size_t size, const char *dir, const char *rel) {
+  int n;
+
+  if(!relative_path_safe(rel)) {
+    return -1;
+  }
+  n = snprintf(out, size, "%s%s%s", dir,
+               (strcmp(dir, "/") && dir[strlen(dir) - 1] != '/') ? "/" : "",
+               rel);
+  if(n < 0 || (size_t)n >= size) {
+    errno = ENAMETOOLONG;
+    return -1;
+  }
+  return 0;
+}
+
+static int
+utf8_decode_char(const char **ps, unsigned int *out) {
+  const unsigned char *s = (const unsigned char *)*ps;
+  unsigned char c = s[0];
+  unsigned int cp;
+  size_t n;
+  size_t i;
+
+  if(c < 0x80) {
+    *out = c;
+    *ps += 1;
+    return 0;
+  }
+  if((c & 0xe0) == 0xc0) {
+    cp = c & 0x1f;
+    n = 2;
+  } else if((c & 0xf0) == 0xe0) {
+    cp = c & 0x0f;
+    n = 3;
+  } else if((c & 0xf8) == 0xf0) {
+    cp = c & 0x07;
+    n = 4;
+  } else {
+    return -1;
+  }
+
+  for(i = 1; i < n; i++) {
+    unsigned char t = s[i];
+    if(!t || (t & 0xc0) != 0x80) {
+      return -1;
+    }
+    cp = (cp << 6) | (t & 0x3f);
+  }
+  if((n == 2 && cp < 0x80) ||
+     (n == 3 && cp < 0x800) ||
+     (n == 4 && (cp < 0x10000 || cp > 0x10ffff)) ||
+     (cp >= 0xd800 && cp <= 0xdfff)) {
+    return -1;
+  }
+
+  *out = cp;
+  *ps += n;
+  return 0;
+}
+
+char *
+fs_path_value(char *path) {
+  const char *p;
+  char *out;
+  size_t len;
+  size_t pos = 0;
+  int has_byte_token = 0;
+
+  if(!path) {
+    return path;
+  }
+  for(p = path; *p;) {
+    unsigned int cp;
+    const char *next = p;
+
+    if(utf8_decode_char(&next, &cp)) {
+      return path;
+    }
+    if(cp >= 0x80 && cp <= 0xff) {
+      has_byte_token = 1;
+    } else if(cp > 0xff) {
+      return path;
+    }
+    p = next;
+  }
+  if(!has_byte_token) {
+    return path;
+  }
+
+  len = strlen(path);
+  if(!(out = malloc(len + 1))) {
+    return path;
+  }
+  for(p = path; *p;) {
+    unsigned int cp;
+    const char *next = p;
+
+    if(utf8_decode_char(&next, &cp)) {
+      free(out);
+      return path;
+    }
+    out[pos++] = (char)(unsigned char)cp;
+    p = next;
+  }
+  out[pos] = 0;
+  free(path);
+  return out;
+}
@@ -0,0 +1,24 @@
+#pragma once
+
+#include <stddef.h>
+#include <limits.h>
+
+#include <microhttpd.h>
+
+char *query_value(struct MHD_Connection *conn, const char *key);
+char *header_value(struct MHD_Connection *conn, const char *key);
+char *request_value(struct MHD_Connection *conn, const char *header,
+                    const char *query);
+char *form_decode(const char *src, size_t len);
+char *body_form_value(const char *body, size_t body_size, const char *key);
+
+void free_paths(char **paths, size_t count);
+int parse_paths(const char *raw, char ***out_paths, size_t *out_count);
+
+const char *path_basename(const char *path);
+void path_basename_copy(const char *path, char *out, size_t size);
+int path_dirname(const char *path, char *out, size_t size);
+int path_join(char *out, size_t size, const char *dir, const char *name);
+int relative_path_safe(const char *path);
+int path_join_relative(char *out, size_t size, const char *dir, const char *rel);
+char *fs_path_value(char *path);
@@ -0,0 +1,108 @@
+#include "pkg_installer.h"
+
+#ifndef __linux__
+
+#include <limits.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <string.h>
+
+typedef struct pkg_metadata {
+  const char *uri;
+  const char *ex_uri;
+  const char *playgo_scenario_id;
+  const char *content_id;
+  const char *content_name;
+  const char *icon_url;
+} pkg_metadata_t;
+
+typedef struct pkg_info {
+  char content_id[48];
+  int type;
+  int platform;
+} pkg_info_t;
+
+typedef struct playgo_info {
+  char lang[8][30];
+  char scenario_ids[3][64];
+  char content_ids[64];
+  long unknown[810];
+} playgo_info_t;
+
+int sceAppInstUtilInitialize(void);
+int sceAppInstUtilInstallByPackage(const pkg_metadata_t *, pkg_info_t *,
+                                   playgo_info_t *);
+
+static pthread_mutex_t installer_lock = PTHREAD_MUTEX_INITIALIZER;
+static int installer_initialized;
+
+static int
+initialize_locked(void) {
+  int result;
+
+  if(!installer_initialized) {
+    result = sceAppInstUtilInitialize();
+    if(result) return result;
+    installer_initialized = 1;
+  }
+  return 0;
+}
+
+int
+pkg_installer_initialize(void) {
+  int result;
+
+  pthread_mutex_lock(&installer_lock);
+  result = initialize_locked();
+  pthread_mutex_unlock(&installer_lock);
+  return result;
+}
+
+int
+pkg_installer_install(const char *path) {
+  char install_path[PATH_MAX + sizeof("/user")];
+  const char *uri = path;
+  pkg_metadata_t metadata = {
+    .uri = NULL,
+    .ex_uri = "",
+    .playgo_scenario_id = "",
+    .content_id = "",
+    .content_name = "",
+    .icon_url = ""
+  };
+  pkg_info_t pkg_info = {0};
+  playgo_info_t playgo_info = {0};
+  int result;
+
+  if(!path) return -1;
+  if(!strncmp(path, "/data/", 6)) {
+    snprintf(install_path, sizeof(install_path), "/user%s", path);
+    uri = install_path;
+  }
+  metadata.uri = uri;
+
+  pthread_mutex_lock(&installer_lock);
+  result = initialize_locked();
+  if(result) {
+    pthread_mutex_unlock(&installer_lock);
+    return result;
+  }
+  result = sceAppInstUtilInstallByPackage(&metadata, &pkg_info, &playgo_info);
+  pthread_mutex_unlock(&installer_lock);
+  return result;
+}
+
+#else
+
+int
+pkg_installer_initialize(void) {
+  return PKG_INSTALL_UNSUPPORTED;
+}
+
+int
+pkg_installer_install(const char *path) {
+  (void)path;
+  return PKG_INSTALL_UNSUPPORTED;
+}
+
+#endif
@@ -0,0 +1,6 @@
+#pragma once
+
+#define PKG_INSTALL_UNSUPPORTED 0x7fffffff
+
+int pkg_installer_initialize(void);
+int pkg_installer_install(const char *path);
@@ -0,0 +1,128 @@
+#include "filemgr_internal.h"
+
+#include <limits.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/statvfs.h>
+#ifdef __SCE__
+#include <sys/mount.h>
+#endif
+
+#include "json_util.h"
+#include "path_util.h"
+
+static unsigned long long
+vfs_bytes(fsblkcnt_t blocks, unsigned long block_size) {
+  return (unsigned long long)blocks * (unsigned long long)block_size;
+}
+
+#ifdef __SCE__
+static int
+path_is_mounted(const char *path, const struct stat *st) {
+  char parent[PATH_MAX];
+  struct stat parent_st;
+
+  if(!strcmp(path, "/")) {
+    return 1;
+  }
+  if(path_dirname(path, parent, sizeof(parent)) || stat(parent, &parent_st)) {
+    return 0;
+  }
+  return st->st_dev != parent_st.st_dev;
+}
+#endif
+
+enum MHD_Result
+api_space(struct MHD_Connection *conn) {
+#ifdef __SCE__
+  static const struct {
+    const char *label_key;
+    const char *path;
+  } mounts[] = {
+    {"storageInternal", "/data"},
+    {"storageUsb", "/mnt/usb0"},
+    {"storageUsb", "/mnt/usb1"},
+    {"storageUsb", "/mnt/usb2"},
+    {"storageUsb", "/mnt/usb3"},
+    {"storageUsb", "/mnt/usb4"},
+    {"storageUsb", "/mnt/usb5"},
+    {"storageUsb", "/mnt/usb6"},
+    {"storageUsb", "/mnt/usb7"},
+    {"storageM2", "/mnt/ext1"},
+    {"storageExtended", "/mnt/ext0"},
+  };
+#endif
+  char *current = fs_path_value(query_value(conn, "path"));
+  strbuf_t b = {0};
+  int first = 1;
+
+  strbuf_append(&b, "{\"ok\":true,\"spaces\":[");
+#ifdef __SCE__
+  for(size_t i = 0; i < sizeof(mounts) / sizeof(mounts[0]); i++) {
+    struct statvfs vfs;
+    struct stat st;
+    unsigned long block_size;
+    unsigned long long free_bytes;
+    unsigned long long total_bytes;
+    int is_current = 0;
+
+    if(stat(mounts[i].path, &st) || !path_is_mounted(mounts[i].path, &st) ||
+       statvfs(mounts[i].path, &vfs)) {
+      continue;
+    }
+    block_size = vfs.f_frsize ? vfs.f_frsize : vfs.f_bsize;
+    free_bytes = vfs_bytes(vfs.f_bavail, block_size);
+    total_bytes = vfs_bytes(vfs.f_blocks, block_size);
+    if(current) {
+      if(!strcmp(mounts[i].path, "/")) {
+        is_current = !strcmp(current, "/");
+      } else if(!strncmp(current, mounts[i].path, strlen(mounts[i].path)) &&
+                (current[strlen(mounts[i].path)] == 0 ||
+                 current[strlen(mounts[i].path)] == '/')) {
+        is_current = 1;
+      }
+    }
+
+    if(!first) {
+      strbuf_append(&b, ",");
+    }
+    first = 0;
+    strbuf_append(&b, "{\"label_key\":");
+    json_escape(&b, mounts[i].label_key);
+    strbuf_append(&b, ",\"path\":");
+    json_escape(&b, mounts[i].path);
+    strbuf_printf(&b, ",\"free\":%llu,\"total\":%llu,\"current\":%s}",
+                  free_bytes, total_bytes, is_current ? "true" : "false");
+  }
+#else
+  const char *paths[] = {"/", current && strcmp(current, "/") ? current : NULL};
+  const char *labels[] = {"storageRoot", "storageCurrent"};
+  for(size_t i = 0; i < sizeof(paths) / sizeof(paths[0]); i++) {
+    struct statvfs vfs;
+    unsigned long block_size;
+    unsigned long long free_bytes;
+    unsigned long long total_bytes;
+
+    if(!paths[i] || statvfs(paths[i], &vfs)) {
+      continue;
+    }
+    block_size = vfs.f_frsize ? vfs.f_frsize : vfs.f_bsize;
+    free_bytes = vfs_bytes(vfs.f_bavail, block_size);
+    total_bytes = vfs_bytes(vfs.f_blocks, block_size);
+    if(!first) {
+      strbuf_append(&b, ",");
+    }
+    first = 0;
+    strbuf_append(&b, "{\"label_key\":");
+    json_escape(&b, labels[i]);
+    strbuf_append(&b, ",\"path\":");
+    json_escape(&b, paths[i]);
+    strbuf_printf(&b, ",\"free\":%llu,\"total\":%llu,\"current\":%s}",
+                  free_bytes, total_bytes, i ? "true" : "false");
+  }
+#endif
+  free(current);
+  strbuf_append(&b, "]}");
+  return send_buffer(conn, MHD_HTTP_OK, b.data, "application/json");
+}
@@ -0,0 +1,217 @@
+#include <errno.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#include "filemgr_internal.h"
+#include "path_util.h"
+
+#define ETA_AVERAGE_WINDOW_SECONDS 30
+
+pthread_mutex_t g_tasks_lock = PTHREAD_MUTEX_INITIALIZER;
+file_task_t *g_tasks = NULL;
+unsigned long g_next_task_id = 1;
+
+const char *
+task_op_name(task_op_t op) {
+  switch(op) {
+  case TASK_COPY: return "copy";
+  case TASK_MOVE: return "move";
+  case TASK_DELETE: return "delete";
+  case TASK_DOWNLOAD: return "download";
+  case TASK_UPLOAD: return "upload";
+  default: return "unknown";
+  }
+}
+
+const char *
+task_state_name(task_state_t state) {
+  switch(state) {
+  case TASK_QUEUED: return "queued";
+  case TASK_RUNNING: return "running";
+  case TASK_DONE: return "done";
+  case TASK_FAILED: return "failed";
+  case TASK_CANCELED: return "canceled";
+  default: return "unknown";
+  }
+}
+
+int
+task_is_active(const file_task_t *task) {
+  return task->state == TASK_QUEUED || task->state == TASK_RUNNING;
+}
+
+int
+has_active_task_locked(void) {
+  file_task_t *task;
+
+  for(task = g_tasks; task; task = task->next) {
+    if(task_is_active(task)) {
+      return 1;
+    }
+  }
+  return 0;
+}
+
+int
+has_active_task(void) {
+  int active;
+
+  pthread_mutex_lock(&g_tasks_lock);
+  active = has_active_task_locked();
+  pthread_mutex_unlock(&g_tasks_lock);
+  return active;
+}
+
+void
+free_task(file_task_t *task) {
+  if(!task) {
+    return;
+  }
+  free_paths(task->srcs, task->src_count);
+  free(task);
+}
+
+void
+remove_finished_tasks_locked(void) {
+  file_task_t **link = &g_tasks;
+
+  while(*link) {
+    file_task_t *task = *link;
+
+    if(task_is_active(task)) {
+      link = &task->next;
+      continue;
+    }
+
+    *link = task->next;
+    free_task(task);
+  }
+}
+
+int
+task_cancel_requested(file_task_t *task) {
+  int cancel;
+
+  pthread_mutex_lock(&g_tasks_lock);
+  cancel = task->cancel_requested;
+  pthread_mutex_unlock(&g_tasks_lock);
+  if(cancel) {
+    errno = ECANCELED;
+  }
+  return cancel;
+}
+
+file_task_t *
+find_task_locked(unsigned long id) {
+  file_task_t *task;
+
+  for(task = g_tasks; task; task = task->next) {
+    if(task->id == id) {
+      return task;
+    }
+  }
+  return NULL;
+}
+
+static long long
+timespec_delta_ns(const struct timespec *end, const struct timespec *start) {
+  return (long long)(end->tv_sec - start->tv_sec) * 1000000000LL +
+         (long long)(end->tv_nsec - start->tv_nsec);
+}
+
+static void
+task_update_eta_locked(file_task_t *task, const struct timespec *now_mono) {
+  task_eta_sample_t *sample;
+  task_eta_sample_t *base = NULL;
+  unsigned int i;
+
+  if(!task->total || !task->done || task->done >= task->total) {
+    task->eta = 0;
+    return;
+  }
+
+  sample = &task->eta_samples[task->eta_sample_next];
+  sample->done = task->done;
+  sample->time = *now_mono;
+  task->eta_sample_next = (task->eta_sample_next + 1) % ETA_SAMPLE_SLOTS;
+  if(task->eta_sample_count < ETA_SAMPLE_SLOTS) {
+    task->eta_sample_count++;
+  }
+
+  for(i = 0; i < task->eta_sample_count; i++) {
+    task_eta_sample_t *candidate = &task->eta_samples[i];
+    long long age_ns;
+
+    if(!candidate->time.tv_sec || candidate->done >= task->done) {
+      continue;
+    }
+    age_ns = timespec_delta_ns(now_mono, &candidate->time);
+    if(age_ns <= 0 || age_ns > (long long)ETA_AVERAGE_WINDOW_SECONDS * 1000000000LL) {
+      continue;
+    }
+    if(!base || age_ns > timespec_delta_ns(now_mono, &base->time)) {
+      base = candidate;
+    }
+  }
+
+  if(base) {
+    long long elapsed_ns = timespec_delta_ns(now_mono, &base->time);
+    unsigned long long delta = task->done - base->done;
+    unsigned long long remaining = task->total - task->done;
+    if(delta && elapsed_ns > 0) {
+      long double seconds = (long double)elapsed_ns / 1000000000.0L;
+      long double eta = ((long double)remaining / (long double)delta) * seconds;
+      task->eta = eta > 0 ? (unsigned long long)(eta + 0.999999L) : 0;
+      return;
+    }
+  }
+
+  task->eta = task->speed ? (task->total - task->done + task->speed - 1) / task->speed : 0;
+}
+
+void
+task_update(file_task_t *task, task_state_t state, const char *current,
+            unsigned long long add_done, const char *error) {
+  struct timespec now_mono;
+  time_t now;
+
+  clock_gettime(CLOCK_MONOTONIC, &now_mono);
+  now = time(NULL);
+
+  pthread_mutex_lock(&g_tasks_lock);
+  task->state = state;
+  if(current) {
+    snprintf(task->current, sizeof(task->current), "%s", current);
+  }
+  if(add_done) {
+    if(!task->transfer_started_at) {
+      task->transfer_started_at = now;
+    }
+    task->done += add_done;
+    if(task->total && task->done > task->total) {
+      task->done = task->total;
+    }
+    if(task->speed_sample_time.tv_sec) {
+      long long elapsed_ns = timespec_delta_ns(&now_mono, &task->speed_sample_time);
+      if(elapsed_ns >= 250000000LL) {
+        unsigned long long delta = task->done - task->speed_sample_done;
+        task->speed = (unsigned long long)((delta * 1000000000ULL) /
+                                           (unsigned long long)elapsed_ns);
+        task->speed_sample_done = task->done;
+        task->speed_sample_time = now_mono;
+      }
+    } else {
+      task->speed_sample_done = task->done;
+      task->speed_sample_time = now_mono;
+    }
+    task_update_eta_locked(task, &now_mono);
+  }
+  if(error) {
+    snprintf(task->error, sizeof(task->error), "%s", error);
+  }
+  task->updated_at = now;
+  pthread_mutex_unlock(&g_tasks_lock);
+}
@@ -0,0 +1,445 @@
+#include "filemgr_internal.h"
+
+#include <errno.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <strings.h>
+#include <sys/stat.h>
+#include <time.h>
+#include <unistd.h>
+
+#include "json_util.h"
+#include "path_util.h"
+#include "websrv.h"
+
+#define TEXT_FILE_MAX_SIZE (1024 * 1024)
+
+typedef enum text_newline {
+  TEXT_NEWLINE_LF,
+  TEXT_NEWLINE_CRLF,
+  TEXT_NEWLINE_CR,
+} text_newline_t;
+
+static enum MHD_Result
+send_json_version(struct MHD_Connection *conn, unsigned long long version) {
+  char *data;
+
+  if(asprintf(&data, "{\"ok\":true,\"version\":\"%016llx\"}", version) < 0) {
+    return MHD_NO;
+  }
+  return send_buffer(conn, MHD_HTTP_OK, data, "application/json");
+}
+
+static int
+text_extension_allowed(const char *path) {
+  static const char *extensions[] = {
+    ".txt", ".json", ".xml", ".ini", ".cfg", ".conf", ".md",
+    ".log", ".lua", ".js", ".css", ".html", ".htm", ".c", ".h",
+    ".cpp", ".hpp", ".sh", ".csv", ".yaml", ".yml", ".shn"
+  };
+  const char *extension = strrchr(path, '.');
+  size_t i;
+
+  if(!extension) {
+    return 0;
+  }
+  for(i = 0; i < sizeof(extensions) / sizeof(extensions[0]); i++) {
+    if(!strcasecmp(extension, extensions[i])) {
+      return 1;
+    }
+  }
+  return 0;
+}
+
+static int
+valid_utf8(const unsigned char *data, size_t size) {
+  size_t i = 0;
+
+  while(i < size) {
+    unsigned char c = data[i++];
+    size_t trailing;
+    unsigned int codepoint;
+
+    if(!c) return 0;
+    if(c < 0x80) continue;
+    if(c >= 0xc2 && c <= 0xdf) {
+      trailing = 1;
+      codepoint = c & 0x1f;
+    } else if(c >= 0xe0 && c <= 0xef) {
+      trailing = 2;
+      codepoint = c & 0x0f;
+    } else if(c >= 0xf0 && c <= 0xf4) {
+      trailing = 3;
+      codepoint = c & 0x07;
+    } else {
+      return 0;
+    }
+    if(trailing > size - i) return 0;
+    while(trailing--) {
+      unsigned char next = data[i++];
+      if((next & 0xc0) != 0x80) return 0;
+      codepoint = (codepoint << 6) | (next & 0x3f);
+    }
+    if((codepoint >= 0xd800 && codepoint <= 0xdfff) || codepoint > 0x10ffff ||
+       (codepoint < 0x800 && c >= 0xe0) ||
+       (codepoint < 0x10000 && c >= 0xf0)) {
+      return 0;
+    }
+  }
+  return 1;
+}
+
+static unsigned long long
+text_version(const unsigned char *data, size_t size) {
+  unsigned long long hash = 1469598103934665603ULL;
+  size_t i;
+
+  for(i = 0; i < size; i++) {
+    hash ^= data[i];
+    hash *= 1099511628211ULL;
+  }
+  return hash;
+}
+
+static text_newline_t
+detect_text_newline(const unsigned char *data, size_t size) {
+  size_t crlf = 0;
+  size_t lf = 0;
+  size_t cr = 0;
+  size_t i;
+
+  for(i = 0; i < size; i++) {
+    if(data[i] == '\r') {
+      if(i + 1 < size && data[i + 1] == '\n') {
+        crlf++;
+        i++;
+      } else {
+        cr++;
+      }
+    } else if(data[i] == '\n') {
+      lf++;
+    }
+  }
+  if(crlf > lf && crlf >= cr) return TEXT_NEWLINE_CRLF;
+  if(cr > lf && cr > crlf) return TEXT_NEWLINE_CR;
+  return TEXT_NEWLINE_LF;
+}
+
+static int
+format_text_for_save(const char *body, size_t body_size,
+                     const unsigned char *current, size_t current_size,
+                     char **output, size_t *output_size) {
+  static const unsigned char bom[] = {0xef, 0xbb, 0xbf};
+  int keep_bom = current_size >= sizeof(bom) &&
+                 !memcmp(current, bom, sizeof(bom));
+  text_newline_t newline = detect_text_newline(
+    current + (keep_bom ? sizeof(bom) : 0),
+    current_size - (keep_bom ? sizeof(bom) : 0));
+  const unsigned char *input = (const unsigned char *)(body ? body : "");
+  size_t input_size = body_size;
+  size_t capacity = body_size * (newline == TEXT_NEWLINE_CRLF ? 2 : 1) +
+                    sizeof(bom) + 1;
+  char *formatted;
+  size_t i;
+  size_t len = 0;
+
+  if(input_size >= sizeof(bom) && !memcmp(input, bom, sizeof(bom))) {
+    input += sizeof(bom);
+    input_size -= sizeof(bom);
+  }
+  if(!(formatted = malloc(capacity))) {
+    errno = ENOMEM;
+    return -1;
+  }
+  if(keep_bom) {
+    memcpy(formatted + len, bom, sizeof(bom));
+    len += sizeof(bom);
+  }
+  for(i = 0; i < input_size; i++) {
+    unsigned char c = input[i];
+
+    if(c != '\r' && c != '\n') {
+      formatted[len++] = (char)c;
+      continue;
+    }
+    if(c == '\r' && i + 1 < input_size && input[i + 1] == '\n') {
+      i++;
+    }
+    if(newline == TEXT_NEWLINE_CRLF) {
+      formatted[len++] = '\r';
+      formatted[len++] = '\n';
+    } else {
+      formatted[len++] = newline == TEXT_NEWLINE_CR ? '\r' : '\n';
+    }
+  }
+  if(len > TEXT_FILE_MAX_SIZE) {
+    free(formatted);
+    errno = EFBIG;
+    return -1;
+  }
+  formatted[len] = 0;
+  *output = formatted;
+  *output_size = len;
+  return 0;
+}
+
+static int
+read_text_file(const char *path, char **data, size_t *size,
+               struct stat *st) {
+  FILE *file;
+  size_t read_size;
+
+  *data = NULL;
+  *size = 0;
+  if(lstat(path, st) || !S_ISREG(st->st_mode)) {
+    return -1;
+  }
+  if(st->st_size < 0 || (unsigned long long)st->st_size > TEXT_FILE_MAX_SIZE) {
+    errno = EFBIG;
+    return -1;
+  }
+  if(!(file = fopen(path, "rb"))) {
+    return -1;
+  }
+  if(!(*data = malloc((size_t)st->st_size + 1))) {
+    fclose(file);
+    errno = ENOMEM;
+    return -1;
+  }
+  read_size = fread(*data, 1, (size_t)st->st_size, file);
+  if(read_size != (size_t)st->st_size || ferror(file)) {
+    free(*data);
+    *data = NULL;
+    fclose(file);
+    return -1;
+  }
+  fclose(file);
+  (*data)[read_size] = 0;
+  *size = read_size;
+  return 0;
+}
+
+static enum MHD_Result
+send_text_file(struct MHD_Connection *conn, char *data, size_t size,
+               unsigned long long version) {
+  struct MHD_Response *resp;
+  enum MHD_Result ret;
+  char version_text[24];
+
+  if(!(resp = MHD_create_response_from_buffer(size, data,
+                                               MHD_RESPMEM_MUST_FREE))) {
+    free(data);
+    return MHD_NO;
+  }
+  snprintf(version_text, sizeof(version_text), "%016llx", version);
+  MHD_add_response_header(resp, MHD_HTTP_HEADER_CONTENT_TYPE,
+                          "text/plain; charset=utf-8");
+  MHD_add_response_header(resp, "X-Text-Version", version_text);
+  ret = websrv_queue_response(conn, MHD_HTTP_OK, resp);
+  MHD_destroy_response(resp);
+  return ret;
+}
+
+enum MHD_Result
+api_text(struct MHD_Connection *conn) {
+  char *path = fs_path_value(query_value(conn, "path"));
+  char *data;
+  size_t size;
+  struct stat st;
+  unsigned long long version;
+
+  if(has_active_task()) {
+    free(path);
+    return send_json_error(conn, MHD_HTTP_CONFLICT, "another task is running");
+  }
+  if(!path || !text_extension_allowed(path)) {
+    free(path);
+    return send_json_error(conn, MHD_HTTP_BAD_REQUEST,
+                           "file type is not editable");
+  }
+  if(read_text_file(path, &data, &size, &st)) {
+    int error = errno;
+    free(path);
+    if(error == EFBIG) {
+      return send_json_error(conn, MHD_HTTP_CONTENT_TOO_LARGE,
+                             "text file is too large");
+    }
+    errno = error;
+    return send_json_error(conn, MHD_HTTP_NOT_FOUND, "file not found");
+  }
+  free(path);
+  if(!valid_utf8((const unsigned char *)data, size)) {
+    free(data);
+    return send_json_error(conn, MHD_HTTP_UNSUPPORTED_MEDIA_TYPE,
+                           "file is not valid UTF-8");
+  }
+  version = text_version((const unsigned char *)data, size);
+  return send_text_file(conn, data, size, version);
+}
+
+enum MHD_Result
+api_text_create(struct MHD_Connection *conn) {
+  char *path = fs_path_value(query_value(conn, "path"));
+  char *name = fs_path_value(query_value(conn, "name"));
+  char target[PATH_MAX];
+  int fd = -1;
+  int ret = -1;
+  int error = 0;
+  int created = 0;
+
+  if(has_active_task()) {
+    free(path); free(name);
+    return send_json_error(conn, MHD_HTTP_CONFLICT, "another task is running");
+  }
+  if(!path || !name || path_join(target, sizeof(target), path, name)) {
+    free(path); free(name);
+    return send_json_error(conn, MHD_HTTP_BAD_REQUEST, "invalid path");
+  }
+  if(mode_access(path, W_OK | X_OK)) {
+    free(path); free(name);
+    return send_json_error(conn, MHD_HTTP_FORBIDDEN,
+                           "text file is not writable");
+  }
+  if((fd = open(target, O_WRONLY | O_CREAT | O_EXCL, 0777)) >= 0) {
+    created = 1;
+    ret = fchmod_0777(fd);
+    if(close(fd) && !ret) ret = -1;
+    fd = -1;
+  }
+  if(ret) {
+    error = errno;
+    if(fd >= 0) close(fd);
+    if(created) unlink(target);
+  }
+  free(path); free(name);
+  if(!ret) {
+    return send_json_version(conn,
+                             text_version((const unsigned char *)"", 0));
+  }
+  errno = error;
+  return error == EEXIST ?
+    send_json_error(conn, MHD_HTTP_CONFLICT, "file already exists") :
+    send_json_error(conn, MHD_HTTP_INTERNAL_SERVER_ERROR, NULL);
+}
+
+static int
+write_text_atomic(const char *path, const char *body, size_t body_size,
+                  mode_t mode) {
+  struct timespec now;
+  char temp[PATH_MAX];
+  size_t written = 0;
+  int fd = -1;
+  int ret = -1;
+  int n;
+
+  clock_gettime(CLOCK_MONOTONIC, &now);
+  n = snprintf(temp, sizeof(temp), "%s.wfm-%ld-%ld.tmp", path,
+               (long)getpid(), now.tv_nsec);
+  if(n < 0 || (size_t)n >= sizeof(temp)) {
+    errno = ENAMETOOLONG;
+    return -1;
+  }
+  if((fd = open(temp, O_WRONLY | O_CREAT | O_EXCL, 0600)) < 0) {
+    return -1;
+  }
+  while(written < body_size) {
+    ssize_t count = write(fd, body + written, body_size - written);
+    if(count <= 0) {
+      goto done;
+    }
+    written += (size_t)count;
+  }
+  if(fchmod(fd, mode & 07777) && !ignore_chmod_error(errno)) {
+    goto done;
+  }
+  if(fsync(fd)) {
+    goto done;
+  }
+  if(close(fd)) {
+    fd = -1;
+    goto done;
+  }
+  fd = -1;
+  if(rename(temp, path)) {
+    goto done;
+  }
+  ret = 0;
+
+done:
+  if(fd >= 0) close(fd);
+  if(ret) unlink(temp);
+  return ret;
+}
+
+enum MHD_Result
+api_text_save(struct MHD_Connection *conn, const char *body,
+              size_t body_size) {
+  char *path = fs_path_value(query_value(conn, "path"));
+  char *expected = query_value(conn, "version");
+  char *current = NULL;
+  size_t current_size = 0;
+  struct stat st;
+  char version_text[24];
+  char parent[PATH_MAX];
+  char *formatted = NULL;
+  size_t formatted_size = 0;
+  int ret;
+
+  if(has_active_task()) {
+    free(path); free(expected);
+    return send_json_error(conn, MHD_HTTP_CONFLICT, "another task is running");
+  }
+  if(!path || !expected) {
+    free(path); free(expected);
+    return send_json_error(conn, MHD_HTTP_BAD_REQUEST, "invalid path");
+  }
+  if(body_size > TEXT_FILE_MAX_SIZE) {
+    free(path); free(expected);
+    return send_json_error(conn, MHD_HTTP_CONTENT_TOO_LARGE,
+                           "text file is too large");
+  }
+  if(!valid_utf8((const unsigned char *)(body ? body : ""), body_size)) {
+    free(path); free(expected);
+    return send_json_error(conn, MHD_HTTP_UNSUPPORTED_MEDIA_TYPE,
+                           "file is not valid UTF-8");
+  }
+  if(read_text_file(path, &current, &current_size, &st)) {
+    free(path); free(expected);
+    return send_json_error(conn, MHD_HTTP_NOT_FOUND, "file not found");
+  }
+  snprintf(version_text, sizeof(version_text), "%016llx",
+           text_version((const unsigned char *)current, current_size));
+  if(strcmp(expected, version_text)) {
+    free(current);
+    free(path); free(expected);
+    return send_json_error(conn, MHD_HTTP_CONFLICT,
+                           "file changed since it was opened");
+  }
+  if(path_dirname(path, parent, sizeof(parent)) ||
+     mode_access(path, W_OK) || mode_access(parent, W_OK | X_OK)) {
+    free(current);
+    free(path); free(expected);
+    return send_json_error(conn, MHD_HTTP_FORBIDDEN,
+                           "text file is not writable");
+  }
+  if(format_text_for_save(body, body_size, (const unsigned char *)current,
+                          current_size, &formatted, &formatted_size)) {
+    int error = errno;
+    free(current);
+    free(path); free(expected);
+    errno = error;
+    return error == EFBIG ?
+      send_json_error(conn, MHD_HTTP_CONTENT_TOO_LARGE,
+                      "text file is too large") :
+      send_json_error(conn, MHD_HTTP_INTERNAL_SERVER_ERROR, NULL);
+  }
+  free(current);
+  ret = write_text_atomic(path, formatted, formatted_size, st.st_mode);
+  free(formatted);
+  free(path); free(expected);
+  return ret ? send_json_error(conn, MHD_HTTP_INTERNAL_SERVER_ERROR, NULL)
+             : send_json_ok(conn);
+}
@@ -0,0 +1,480 @@
+#include "filemgr.h"
+
+#include <errno.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <time.h>
+#include <unistd.h>
+
+#include "filemgr_internal.h"
+#include "json_util.h"
+#include "path_util.h"
+
+typedef struct upload_context {
+  file_task_t *task;
+  int fd;
+  char temp[PATH_MAX];
+  char target[PATH_MAX];
+  unsigned long long expected;
+  unsigned long long written;
+  int failed;
+  int error;
+  int task_done;
+} upload_context_t;
+
+static void
+finish_upload_task(file_task_t *task, task_state_t state, const char *current,
+                   const char *error) {
+  if(!task) {
+    return;
+  }
+  pthread_mutex_lock(&g_tasks_lock);
+  if(task_is_active(task)) {
+    time_t completed_at = time(NULL);
+    task->state = state;
+    if(current) {
+      snprintf(task->current, sizeof(task->current), "%s", current);
+    }
+    if(state == TASK_DONE && task->total) {
+      task->done = task->total;
+    }
+    if(state == TASK_DONE) {
+      record_task_completion_locked(task, completed_at);
+    }
+    if(error) {
+      snprintf(task->error, sizeof(task->error), "%s", error);
+    }
+    task->updated_at = completed_at;
+  }
+  pthread_mutex_unlock(&g_tasks_lock);
+}
+
+static file_task_t *
+upload_task_from_conn(struct MHD_Connection *conn) {
+  char *idstr = request_value(conn, "X-WFM-Task-ID", "task_id");
+  unsigned long id = idstr ? strtoul(idstr, NULL, 10) : 0;
+  file_task_t *task = NULL;
+
+  free(idstr);
+  if(!id) {
+    return NULL;
+  }
+  pthread_mutex_lock(&g_tasks_lock);
+  task = find_task_locked(id);
+  if(!task || task->op != TASK_UPLOAD || !task_is_active(task)) {
+    task = NULL;
+  }
+  pthread_mutex_unlock(&g_tasks_lock);
+  return task;
+}
+
+static int
+check_upload_manifest_space(const char *base, const char *rels,
+                            const char *sizes, unsigned long long fallback_total,
+                            char *error, size_t error_size,
+                            char *code, size_t code_size,
+                            char *arg, size_t arg_size) {
+  char *rels_copy = NULL;
+  char *sizes_copy = NULL;
+  char *rel;
+  char *size_text;
+  char *rel_save;
+  char *size_save;
+  unsigned long long available;
+  int ret = -1;
+
+  if(!rels || !sizes) {
+    return check_target_space(base, fallback_total, error, error_size,
+                              code, code_size, arg, arg_size);
+  }
+  if(target_available_space(base, &available)) {
+    snprintf(error, error_size, "cannot read target free space");
+    snprintf(code, code_size, "space_check_failed");
+    snprintf(arg, arg_size, "%s", base);
+    return -1;
+  }
+  if(!(rels_copy = strdup(rels)) || !(sizes_copy = strdup(sizes))) {
+    errno = ENOMEM;
+    goto done;
+  }
+
+  rel = strtok_r(rels_copy, "\n", &rel_save);
+  size_text = strtok_r(sizes_copy, "\n", &size_save);
+  while(rel || size_text) {
+    char target[PATH_MAX];
+    unsigned long long size;
+
+    if(!rel || !size_text || path_join_relative(target, sizeof(target), base, rel)) {
+      snprintf(error, error_size, "invalid path");
+      snprintf(code, code_size, "invalid_path");
+      snprintf(arg, arg_size, "%s", rel ? rel : "");
+      errno = EINVAL;
+      goto done;
+    }
+
+    size = strtoull(size_text, NULL, 10);
+    if(available < size) {
+      snprintf(error, error_size,
+               "not enough target space, required %llu bytes, available %llu bytes",
+               size, available);
+      snprintf(code, code_size, "no_space");
+      snprintf(arg, arg_size, "%llu,%llu", size, available);
+      errno = ENOSPC;
+      goto done;
+    }
+
+    available -= size;
+
+    rel = strtok_r(NULL, "\n", &rel_save);
+    size_text = strtok_r(NULL, "\n", &size_save);
+  }
+
+  ret = 0;
+
+done:
+  free(rels_copy);
+  free(sizes_copy);
+  return ret;
+}
+
+enum MHD_Result
+api_upload_prepare(struct MHD_Connection *conn, const char *body,
+                   size_t body_size) {
+  char *path = fs_path_value(body_form_value(body, body_size, "path"));
+  char *src = body_form_value(body, body_size, "src");
+  char *total_text = body_form_value(body, body_size, "total");
+  char *count_text = body_form_value(body, body_size, "count");
+  char *rels = body_form_value(body, body_size, "rels");
+  char *sizes = body_form_value(body, body_size, "sizes");
+  char *overwrite = body_form_value(body, body_size, "overwrite");
+  file_task_t *task = calloc(1, sizeof(*task));
+  strbuf_t b = {0};
+  unsigned long long total = total_text ? strtoull(total_text, NULL, 10) : 0;
+  size_t count = count_text ? (size_t)strtoull(count_text, NULL, 10) : 0;
+  char error[128] = {0};
+  char code[64] = {0};
+  char arg[PATH_MAX + 96] = {0};
+
+  if(!task) {
+    free(path); free(src); free(total_text); free(count_text);
+    free(rels); free(sizes); free(overwrite);
+    return send_json_error(conn, MHD_HTTP_INTERNAL_SERVER_ERROR, "out of memory");
+  }
+  if(!path || !src || !count) {
+    free_task(task);
+    free(path); free(src); free(total_text); free(count_text);
+    free(rels); free(sizes); free(overwrite);
+    return send_json_error(conn, MHD_HTTP_BAD_REQUEST, "invalid path");
+  }
+
+  pthread_mutex_lock(&g_tasks_lock);
+  remove_finished_tasks_locked();
+  if(has_active_task_locked()) {
+    pthread_mutex_unlock(&g_tasks_lock);
+    free_task(task);
+    free(path); free(src); free(total_text); free(count_text);
+    free(rels); free(sizes); free(overwrite);
+    return send_json_error(conn, MHD_HTTP_CONFLICT, "another task is running");
+  }
+  pthread_mutex_unlock(&g_tasks_lock);
+
+  if(check_upload_manifest_space(path, rels, sizes, total, error, sizeof(error),
+                                 code, sizeof(code), arg, sizeof(arg))) {
+    free_task(task);
+    free(path); free(src); free(total_text); free(count_text);
+    free(rels); free(sizes); free(overwrite);
+    return send_json_error_detail(conn,
+                                  errno == ENOSPC ? MHD_HTTP_INSUFFICIENT_STORAGE :
+                                  MHD_HTTP_INTERNAL_SERVER_ERROR,
+                                  error[0] ? error : NULL,
+                                  code[0] ? code : NULL,
+                                  arg[0] ? arg : NULL);
+  }
+
+  task->op = TASK_UPLOAD;
+  task->state = TASK_RUNNING;
+  task->src_count = count;
+  task->file_count = count;
+  task->total = total;
+  snprintf(task->src, sizeof(task->src), "%s", src);
+  snprintf(task->dst, sizeof(task->dst), "%s", path);
+  snprintf(task->current, sizeof(task->current), "%s", src);
+  task->created_at = time(NULL);
+  task->updated_at = task->created_at;
+
+  pthread_mutex_lock(&g_tasks_lock);
+  remove_finished_tasks_locked();
+  if(has_active_task_locked()) {
+    pthread_mutex_unlock(&g_tasks_lock);
+    free_task(task);
+    free(path); free(src); free(total_text); free(count_text);
+    free(rels); free(sizes); free(overwrite);
+    return send_json_error(conn, MHD_HTTP_CONFLICT, "another task is running");
+  }
+  task->id = g_next_task_id++;
+  task->next = g_tasks;
+  g_tasks = task;
+  pthread_mutex_unlock(&g_tasks_lock);
+
+  free(path); free(src); free(total_text); free(count_text);
+  free(rels); free(sizes); free(overwrite);
+  strbuf_printf(&b, "{\"ok\":true,\"task_id\":%lu}", task->id);
+  return send_buffer(conn, MHD_HTTP_OK, b.data, "application/json");
+}
+
+enum MHD_Result
+api_upload_finish(struct MHD_Connection *conn) {
+  file_task_t *task = upload_task_from_conn(conn);
+
+  if(!task) {
+    return send_json_error(conn, MHD_HTTP_NOT_FOUND, "active task not found");
+  }
+  if(task_cancel_requested(task)) {
+    finish_upload_task(task, TASK_CANCELED,
+                       task->current[0] ? task->current : task->src,
+                       "canceled");
+    return send_json_error(conn, MHD_HTTP_CONFLICT, "canceled");
+  }
+  finish_upload_task(task, TASK_DONE,
+                     task->current[0] ? task->current : task->src, NULL);
+  return send_json_ok(conn);
+}
+
+int
+filemgr_upload_begin(struct MHD_Connection *conn, void **upload_ctx) {
+  upload_context_t *ctx;
+  char *base = fs_path_value(request_value(conn, "X-WFM-Path", "path"));
+  char *rel = request_value(conn, "X-WFM-Rel", "rel");
+  char *overwrite = request_value(conn, "X-WFM-Overwrite", "overwrite");
+  char *size_text = request_value(conn, "X-WFM-Size", "size");
+  file_task_t *task = upload_task_from_conn(conn);
+  char **checked_dirs = NULL;
+  size_t checked_dir_count = 0;
+  struct stat st;
+  char error[128] = {0};
+  char code[64] = {0};
+  char arg[PATH_MAX + 96] = {0};
+  int n;
+
+  *upload_ctx = NULL;
+  if(!(ctx = calloc(1, sizeof(*ctx)))) {
+    free(base); free(rel); free(overwrite); free(size_text);
+    errno = ENOMEM;
+    return -1;
+  }
+  ctx->fd = -1;
+  *upload_ctx = ctx;
+
+  if(size_text) {
+    ctx->expected = strtoull(size_text, NULL, 10);
+  }
+  ctx->task = task;
+  if(task && task_cancel_requested(task)) {
+    ctx->failed = 1;
+    ctx->error = ECANCELED;
+    goto fail;
+  }
+  if(!task && has_active_task()) {
+    ctx->failed = 1;
+    ctx->error = EBUSY;
+    goto fail;
+  }
+  if(!base || !rel || path_join_relative(ctx->target, sizeof(ctx->target),
+                                         base, rel)) {
+    ctx->failed = 1;
+    ctx->error = errno ? errno : EINVAL;
+    goto fail;
+  }
+  if(ensure_parent_dirs(base, rel)) {
+    ctx->failed = 1;
+    ctx->error = errno ? errno : EACCES;
+    goto fail;
+  }
+  if(!lstat(ctx->target, &st)) {
+    if(S_ISDIR(st.st_mode) || !overwrite || strcmp(overwrite, "1")) {
+      ctx->failed = 1;
+      ctx->error = S_ISDIR(st.st_mode) ? EISDIR : EEXIST;
+      goto fail;
+    }
+  } else if(errno != ENOENT) {
+    ctx->failed = 1;
+    ctx->error = errno;
+    goto fail;
+  }
+  if(check_target_writable(ctx->target, &checked_dirs, &checked_dir_count,
+                           error, sizeof(error), code, sizeof(code),
+                           arg, sizeof(arg))) {
+    ctx->failed = 1;
+    ctx->error = errno ? errno : EACCES;
+    goto fail;
+  }
+  if(check_target_space(ctx->target, ctx->expected, error, sizeof(error),
+                        code, sizeof(code), arg, sizeof(arg))) {
+    ctx->failed = 1;
+    ctx->error = errno ? errno : ENOSPC;
+    goto fail;
+  }
+  n = snprintf(ctx->temp, sizeof(ctx->temp), "%s.wfm-upload-%ld-%lld.tmp",
+               ctx->target, (long)getpid(), (long long)time(NULL));
+  if(n < 0 || (size_t)n >= sizeof(ctx->temp)) {
+    ctx->failed = 1;
+    ctx->error = ENAMETOOLONG;
+    goto fail;
+  }
+  ctx->fd = open(ctx->temp, O_WRONLY | O_CREAT | O_TRUNC, 0600);
+  if(ctx->fd < 0) {
+    ctx->failed = 1;
+    ctx->error = errno;
+    goto fail;
+  }
+
+fail:
+  free_paths(checked_dirs, checked_dir_count);
+  free(base); free(rel); free(overwrite); free(size_text);
+  if(ctx->failed) {
+    if(ctx->task) {
+      finish_upload_task(ctx->task,
+                         ctx->error == ECANCELED ? TASK_CANCELED : TASK_FAILED,
+                         ctx->target[0] ? ctx->target : ctx->task->current,
+                         ctx->error == ECANCELED ? "canceled" : strerror(ctx->error ? ctx->error : EIO));
+      ctx->task_done = 1;
+    }
+    if(ctx->fd >= 0) {
+      close(ctx->fd);
+      ctx->fd = -1;
+    }
+    if(ctx->temp[0]) {
+      unlink(ctx->temp);
+    }
+    errno = ctx->error ? ctx->error : EIO;
+    return -1;
+  }
+  return 0;
+}
+
+int
+filemgr_upload_data(void *upload_ctx, const char *data, size_t size) {
+  upload_context_t *ctx = upload_ctx;
+  size_t written = 0;
+
+  if(!ctx || ctx->failed) {
+    return -1;
+  }
+  if(ctx->task && task_cancel_requested(ctx->task)) {
+    ctx->failed = 1;
+    ctx->error = ECANCELED;
+    return -1;
+  }
+  while(written < size) {
+    ssize_t n = write(ctx->fd, data + written, size - written);
+    if(n <= 0) {
+      ctx->failed = 1;
+      ctx->error = errno ? errno : EIO;
+      return -1;
+    }
+    written += (size_t)n;
+    ctx->written += (unsigned long long)n;
+    if(ctx->task) {
+      task_update(ctx->task, TASK_RUNNING, ctx->target,
+                  (unsigned long long)n, NULL);
+    }
+  }
+  return 0;
+}
+
+enum MHD_Result
+filemgr_upload_finish(struct MHD_Connection *conn, void *upload_ctx) {
+  upload_context_t *ctx = upload_ctx;
+  int ret = -1;
+
+  if(!ctx) {
+    return send_json_error(conn, MHD_HTTP_BAD_REQUEST, "invalid path");
+  }
+  if(ctx->failed) {
+    if(ctx->task && !ctx->task_done) {
+      finish_upload_task(ctx->task,
+                         ctx->error == ECANCELED ? TASK_CANCELED : TASK_FAILED,
+                         ctx->target[0] ? ctx->target : ctx->task->current,
+                         ctx->error == ECANCELED ? "canceled" : strerror(ctx->error ? ctx->error : EIO));
+      ctx->task_done = 1;
+    }
+    errno = ctx->error ? ctx->error : EIO;
+    return send_json_error(conn, errno == EEXIST ? MHD_HTTP_CONFLICT :
+                           errno == EBUSY ? MHD_HTTP_CONFLICT :
+                           errno == ECANCELED ? MHD_HTTP_CONFLICT :
+                           errno == ENOSPC ? MHD_HTTP_INSUFFICIENT_STORAGE :
+                           MHD_HTTP_INTERNAL_SERVER_ERROR, NULL);
+  }
+  if(ctx->expected && ctx->written != ctx->expected) {
+    ctx->error = EIO;
+    goto done;
+  }
+  if(fchmod_0777(ctx->fd)) {
+    ctx->error = errno;
+    goto done;
+  }
+  if(fsync(ctx->fd)) {
+    ctx->error = errno;
+    goto done;
+  }
+  if(close(ctx->fd)) {
+    ctx->fd = -1;
+    ctx->error = errno;
+    goto done;
+  }
+  ctx->fd = -1;
+  if(rename(ctx->temp, ctx->target)) {
+    ctx->error = errno;
+    goto done;
+  }
+  ret = 0;
+
+done:
+  if(ctx->fd >= 0) {
+    close(ctx->fd);
+    ctx->fd = -1;
+  }
+  if(ret) {
+    if(ctx->temp[0]) {
+      unlink(ctx->temp);
+    }
+    if(ctx->task && !ctx->task_done) {
+      finish_upload_task(ctx->task,
+                         ctx->error == ECANCELED ? TASK_CANCELED : TASK_FAILED,
+                         ctx->target[0] ? ctx->target : ctx->task->current,
+                         ctx->error == ECANCELED ? "canceled" : strerror(ctx->error ? ctx->error : EIO));
+      ctx->task_done = 1;
+    }
+    errno = ctx->error ? ctx->error : EIO;
+    return send_json_error(conn, errno == ECANCELED ? MHD_HTTP_CONFLICT :
+                           MHD_HTTP_INTERNAL_SERVER_ERROR, NULL);
+  }
+  return send_json_ok(conn);
+}
+
+void
+filemgr_upload_free(void *upload_ctx) {
+  upload_context_t *ctx = upload_ctx;
+
+  if(!ctx) {
+    return;
+  }
+  if(ctx->fd >= 0) {
+    close(ctx->fd);
+    if(ctx->temp[0]) {
+      unlink(ctx->temp);
+    }
+    if(ctx->task && !ctx->task_done) {
+      int canceled = task_cancel_requested(ctx->task);
+      finish_upload_task(ctx->task, canceled ? TASK_CANCELED : TASK_FAILED,
+                         ctx->target[0] ? ctx->target : ctx->task->current,
+                         canceled ? "canceled" : "client disconnected");
+      ctx->task_done = 1;
+    }
+  }
+  free(ctx);
+}
@@ -13,6 +13,39 @@
 #include "filemgr.h"
 #include "websrv.h"

+#define REQUEST_BODY_MAX (4 * 1024 * 1024)
+
+static volatile sig_atomic_t g_stop_requested;
+static int g_listen_fd = -1;
+
+typedef struct request_context {
+  char *body;
+  size_t size;
+  int too_large;
+  int upload_stream;
+  void *upload_ctx;
+} request_context_t;
+
+static enum MHD_Result
+websrv_body_too_large(struct MHD_Connection *conn) {
+  static const char json[] =
+    "{\"ok\":false,\"error\":\"request body is too large\","
+    "\"error_code\":\"request_body_too_large\",\"error_arg\":\"\"}";
+  struct MHD_Response *resp =
+    MHD_create_response_from_buffer(sizeof(json) - 1, (void *)json,
+                                    MHD_RESPMEM_PERSISTENT);
+  enum MHD_Result ret;
+
+  if(!resp) {
+    return MHD_NO;
+  }
+  MHD_add_response_header(resp, MHD_HTTP_HEADER_CONTENT_TYPE,
+                          "application/json");
+  ret = websrv_queue_response(conn, MHD_HTTP_CONTENT_TOO_LARGE, resp);
+  MHD_destroy_response(resp);
+  return ret;
+}
+
 enum MHD_Result
 websrv_queue_response(struct MHD_Connection *conn, unsigned int status,
                      struct MHD_Response *resp) {
@@ -21,15 +54,27 @@ websrv_queue_response(struct MHD_Connection *conn, unsigned int status,
  return MHD_queue_response(conn, status, resp);
 }

+void
+websrv_stop(void) {
+  g_stop_requested = 1;
+  if(g_listen_fd >= 0) {
+    shutdown(g_listen_fd, SHUT_RDWR);
+  }
+}
+
+int
+websrv_stop_requested(void) {
+  return g_stop_requested;
+}
+
 static enum MHD_Result
 websrv_on_request(void *cls, struct MHD_Connection *conn, const char *url,
                  const char *method, const char *version,
                  const char *upload_data, size_t *upload_data_size,
                  void **con_cls) {
+  request_context_t *ctx = *con_cls;
  (void)cls;
  (void)version;
-  (void)upload_data;
-  (void)upload_data_size;

  if(strcmp(method, MHD_HTTP_METHOD_GET) &&
     strcmp(method, MHD_HTTP_METHOD_POST) &&
@@ -37,13 +82,62 @@ websrv_on_request(void *cls, struct MHD_Connection *conn, const char *url,
    return MHD_NO;
  }

-  if(!*con_cls) {
-    *con_cls = (void *)1;
+  if(!ctx) {
+    if(!(ctx = calloc(1, sizeof(*ctx)))) {
+      return MHD_NO;
+    }
+    ctx->upload_stream = !strcmp(url, "/api/upload-file") &&
+                         !strcmp(method, MHD_HTTP_METHOD_POST);
+    *con_cls = ctx;
    return MHD_YES;
  }

+  if(*upload_data_size) {
+    size_t chunk_size = *upload_data_size;
+
+    if(ctx->upload_stream) {
+      if(!ctx->upload_ctx && filemgr_upload_begin(conn, &ctx->upload_ctx)) {
+        ctx->too_large = 1;
+      }
+      if(ctx->upload_ctx && filemgr_upload_data(ctx->upload_ctx, upload_data,
+                                                chunk_size)) {
+        ctx->too_large = 1;
+      }
+      *upload_data_size = 0;
+      return MHD_YES;
+    }
+
+    if(chunk_size > REQUEST_BODY_MAX - ctx->size) {
+      ctx->too_large = 1;
+    } else if(!ctx->too_large) {
+      char *body = realloc(ctx->body, ctx->size + chunk_size + 1);
+      if(!body) {
+        return MHD_NO;
+      }
+      ctx->body = body;
+      memcpy(ctx->body + ctx->size, upload_data, chunk_size);
+      ctx->size += chunk_size;
+      ctx->body[ctx->size] = 0;
+    }
+    *upload_data_size = 0;
+    return MHD_YES;
+  }
+
+  if(ctx->too_large) {
+    return ctx->upload_stream ?
+      filemgr_upload_finish(conn, ctx->upload_ctx) :
+      websrv_body_too_large(conn);
+  }
+
+  if(ctx->upload_stream) {
+    if(!ctx->upload_ctx && filemgr_upload_begin(conn, &ctx->upload_ctx)) {
+      return filemgr_upload_finish(conn, ctx->upload_ctx);
+    }
+    return filemgr_upload_finish(conn, ctx->upload_ctx);
+  }
+
  if(!strncmp(url, "/api/", 5)) {
-    return filemgr_api_request(conn, url);
+    return filemgr_api_request(conn, url, method, ctx->body, ctx->size);
  }
  if(!strcmp(url, "/fs")) {
    return filemgr_fs_request(conn);
@@ -51,6 +145,9 @@ websrv_on_request(void *cls, struct MHD_Connection *conn, const char *url,
  if(!strcmp(url, "/") || !url[0]) {
    return asset_request(conn, "/index.html");
  }
+  if(!strcmp(url, "/favicon.ico")) {
+    return asset_request(conn, "/icon0.png");
+  }
  return asset_request(conn, url);
 }

@@ -60,6 +157,15 @@ websrv_on_completed(void *cls, struct MHD_Connection *connection,
  (void)cls;
  (void)connection;
  (void)toe;
+  request_context_t *ctx = *con_cls;
+
+  if(ctx) {
+    if(ctx->upload_ctx) {
+      filemgr_upload_free(ctx->upload_ctx);
+    }
+    free(ctx->body);
+    free(ctx);
+  }
  *con_cls = NULL;
 }

@@ -100,6 +206,8 @@ websrv_listen(unsigned short port) {
    close(srvfd);
    return -1;
  }
+  g_stop_requested = 0;
+  g_listen_fd = srvfd;

  if(!(httpd = MHD_start_daemon(MHD_USE_THREAD_PER_CONNECTION | MHD_USE_ITC |
                                MHD_USE_NO_LISTEN_SOCKET | MHD_USE_DEBUG |
@@ -112,10 +220,10 @@ websrv_listen(unsigned short port) {
    return -1;
  }

-  while(1) {
+  while(!g_stop_requested) {
    addr_len = sizeof(client_addr);
    if((connfd = accept(srvfd, (struct sockaddr *)&client_addr, &addr_len)) < 0) {
-      perror("accept");
+      if(!g_stop_requested) perror("accept");
      break;
    }
    if(MHD_add_connection(httpd, connfd, (struct sockaddr *)&client_addr,
@@ -127,5 +235,6 @@ websrv_listen(unsigned short port) {
  }

  MHD_stop_daemon(httpd);
+  g_listen_fd = -1;
  return close(srvfd);
 }
@@ -23,3 +23,5 @@ enum MHD_Result websrv_queue_response(struct MHD_Connection *conn,
 				      struct MHD_Response *resp);

 int websrv_listen(unsigned short port);
+void websrv_stop(void);
+int websrv_stop_requested(void);
Author	SHA1	Message	Date
owendswang	939257eda0	Fixed PKG install from internal storage. Adjust back button display effects	2026-08-09 12:38:23 +08:00
owendswang	3efaf24385	Highlight specific directories' icon. Moved the back button to the header of the name column.	2026-08-08 17:47:54 +08:00
owendswang	5302e971f9	Enhance credits with PKG install function reference Updated the credits section to include PKG install function in the websrv reference.	2026-08-06 21:18:15 +08:00
owendswang	582d154cdf	Changed the way to end the daemon process	2026-08-06 14:51:43 +08:00
owendswang	a61ac54e1f	Added PKG install function	2026-08-06 14:33:02 +08:00
owendswang	6a110f95ae	v1.1	2026-08-03 23:35:41 +08:00
owendswang	b463c3f86b	Small optimization of directory deletion	2026-08-01 00:11:46 +08:00
owendswang	f9be83061d	Update README.md	2026-07-29 23:18:19 +08:00
owendswang	ae23c8fdaf	Optimization phase 2	2026-07-29 23:12:49 +08:00
owendswang	2dc1ff2c42	Optimization phase 1	2026-07-26 19:12:37 +08:00
owendswang	9d56cd5039	Add upload/download	2026-07-24 23:51:26 +08:00
owendswang	5dba332ad4	Added list sorting and browser caching for path and sorting	2026-07-19 17:57:23 +08:00
owendswang	1a24160b8b	Release v0.9	2026-07-19 00:20:15 +08:00
owendswang	3696468611	Fixed display for available spacee of interal M.2	2026-07-18 09:58:05 +08:00
owendswang	777bb4abd4	Release v0.8	2026-07-14 18:49:24 +08:00
owendswang	76f8fe21d2	Release v0.7	2026-07-09 20:09:02 +08:00
owendswang	5a91067c2e	Release v0.6	2026-06-24 01:19:18 +08:00
owendswang	ba0704d48c	Release v0.5	2026-06-22 02:33:23 +08:00
owendswang	4e10dee5fb	Update README.md	2026-06-20 23:45:21 +08:00
owendswang	259d0a6434	Release v0.4	2026-06-20 23:23:25 +08:00
owendswang	6f46847df2	Release v0.3	2026-06-19 13:23:00 +08:00
owendswang	91375e0537	Added screenshots	2026-06-18 23:05:34 +08:00