fix: QA sweep - tool routes, security, i18n, a11y, + AI bundle install hardening (#393)

* fix(api): correct format/filename/container handling across tool routes

Found during a comprehensive QA sweep exercising every tool against its
full accepted-format matrix:

- watermark-image, compose: preserve the requested output format and a
  matching download filename/extension instead of always emitting the
  source format
- compose: crop oversized overlays to the visible base area instead of
  crashing Sharp's composite, and reject only overlays fully outside the
  base image instead of any oversized one
- compare, vectorize: switch to the shared image input handler so
  filenames and formats like .svgz/.tga/RAW survive validation instead
  of being rejected pre-processing
- tool-factory, images-to-video: normalize frames through Sharp before
  handing them to FFmpeg, fixing GIF/AVIF/RAW image-to-video jobs that
  previously failed or hung
- media-tool, replace-audio, embed-subtitles: fix legacy container
  MIME/codec handling for MPEG sources and subtitle remux cases
- files: expand download MIME mapping for text/data/document/video/audio
  outputs that were falling back to a generic content type
- convert-document/presentation/spreadsheet: same-format conversions now
  return the original validated file instead of erroring or producing
  corrupt tiny output

Claude-Session: https://claude.ai/code/session_019fpSXhLGLXWwfyZY2tWhLG

* fix(web): dropzone a11y, stale localStorage getter, dead code

- dropzone: stop making the whole drop-zone section clickable/focusable.
  A section acting as an interactive element around a real upload button
  is a nested-interactive-element anti-pattern that confuses screen
  readers; drag-and-drop doesn't need focus semantics, only the button
  fallback does. Keeps that button semantic and keyboard-reachable.
  Updates the two e2e call sites that clicked the section directly.
- api, use-auth: read through window.localStorage via the existing API
  storage helper instead of the bare global, which resolves to Node's
  experimental localStorage getter under Vitest and threw
- find-duplicates-settings, info-settings, login-page: remove dead code
  (unused zip-download handler, a stale mount-only effect dependency
  that left cached info stuck at reused indices, an unused response
  variable)

Claude-Session: https://claude.ai/code/session_019fpSXhLGLXWwfyZY2tWhLG

* fix(i18n): pt-BR, zh-CN, zh-TW were silently falling back to English

The locale loader looked up dynamic-import exports by the raw locale
code (mod["pt-BR"], mod["zh-CN"], mod["zh-TW"]), but those three modules
export camelCased bindings (ptBR, zhCN, zhTW) since identifiers can't
contain hyphens. The lookup returned undefined and every consumer
silently fell back to English for these three locales. Replaces the
generic lookup with explicit per-locale loaders so the mapping can't
drift out of sync again.

Also updates the dropzone helper copy across all 21 locales to match
the drag-only dropzone wording from the previous commit.

Claude-Session: https://claude.ai/code/session_019fpSXhLGLXWwfyZY2tWhLG

* fix(docs): clear build warnings in the VitePress site

- config.mts: add an onwarn handler for the @vueuse INVALID_ANNOTATION
  warnings emitted during the docs build
- deployment.md: the caddyfile code fence language isn't a shiki grammar
  VitePress ships with, so it warned on every build; use txt instead

Claude-Session: https://claude.ai/code/session_019fpSXhLGLXWwfyZY2tWhLG

* test(qa): update QA harness for the drag-only dropzone and regen metadata

- api-sweep, qa-helpers, verify-ai: add JSON-body tools, multi-input
  secondary fixtures, async polling for slow valid jobs, 501
  FEATURE_NOT_INSTALLED skip handling, and safer per-tool settings
- input-preview, pipeline-ui specs: update upload flow for the
  drag-only dropzone surface
- add tests/fixtures/data/valid/chart.json, a valid chart fixture the
  updated helpers route to
- regenerate tools-meta.json against current TOOLS[]

Claude-Session: https://claude.ai/code/session_019fpSXhLGLXWwfyZY2tWhLG

* fix(security): close a login timing side-channel, harden zip-slip tests

Found during a black-box security sweep of the real auth-enabled
production container: a nonexistent username returned 401 in ~3-10ms,
while a wrong password for a real user took ~35-42ms, because scrypt
verification only ran when a user row existed. That timing gap lets an
attacker enumerate valid usernames without ever guessing a password.
Now runs verification against a cached dummy hash on the unknown-user
path too, so both cases cost the same regardless of outcome.

extract-zip already had a relative-traversal regression test
(../evil.txt), but its absolute-path rejection branches
(name.startsWith("/") / startsWith("\\")) had none. Added the three
missing cases: deep relative traversal, absolute Unix path, and
Windows-style absolute path.

Claude-Session: https://claude.ai/code/session_019fpSXhLGLXWwfyZY2tWhLG

* test(qa): add UI-driven AI bundle install scripts

QA_PROMPT.md's Phase 2 requires installing AI models the way a user
does -- through the UI, on demand from HuggingFace -- and treats the
curl-based admin install endpoint as fallback-only. Nothing in the
harness actually drove that flow; tests/qa/seed-ai-models.sh installs
via docker exec + pip, which is further from a real user than even the
API fallback.

install-ai-bundles-ui.mts logs in, opens Settings > AI Features,
screenshots the pre-install state, clicks Install All, and screenshots
progress -- then exits, since installs continue server-side once
triggered. verify-ai-install-complete.mts polls bundle status,
screenshots the completed state, and runs one real tool per installed
bundle to prove the freshly-downloaded model actually executes.

Claude-Session: https://claude.ai/code/session_019fpSXhLGLXWwfyZY2tWhLG

* fix(qa): correct the apiToolPath import in the AI verify script

Dynamic import of the package name failed under tsx's module resolution
from apps/api's node_modules context; use the same relative-path import
api-sweep.mts already uses successfully.

Claude-Session: https://claude.ai/code/session_019fpSXhLGLXWwfyZY2tWhLG

* fix(web): correct AI bundle size estimates shown before install

Measured real downloads during GPU-node QA verification: photo-restoration
pulls ~4.4GB (was advertised as 800MB-1GB, off by 4-5x) and ocr pulls
~5.5GB (was advertised as 3-4GB). Both estimates only accounted for model
weights, not the pip dependencies (torch/paddle) that come down with them.
Updated to reflect actual total download size, since that's what a user
deciding whether they have the disk/bandwidth actually needs to know.

Claude-Session: https://claude.ai/code/session_019fpSXhLGLXWwfyZY2tWhLG

* fix(web): make desktop Settings reachable when auth is disabled

AvatarDropdown (the only desktop entry point to Settings) was gated
behind `!isMobile && authEnabled`. With AUTH_ENABLED=false the synthetic
anonymous admin user should have full Settings access per how auth.ts
documents this mode -- and the mobile bottom nav already worked this way,
showing Settings unconditionally. Desktop just had a stray extra gate the
component doesn't need: AvatarDropdown already resolves its own username
internally (falling back to "admin") and reads authEnabled itself where
it actually matters (hiding the Logout button). Removed the outer gate;
verified end-to-end against a fresh AUTH_ENABLED=false instance -- avatar
now renders, Settings opens, shows the anonymous/Admin identity correctly.

Also documents (not changes) a related finding in install_feature.py:
detect_arch() always resolves amd64 hosts to the GPU-bundled archive
variant regardless of actual GPU presence, since no CPU-only amd64
archive is published to the bundle repo yet. Left as a code comment
rather than a behavior change, since requesting an unpublished archive
key would hard-fail installs entirely -- worse than the current
oversized-but-working download. Full detail in the QA report.

Claude-Session: https://claude.ai/code/session_019fpSXhLGLXWwfyZY2tWhLG

* fix(ai): stop logging expected dispatcher reloads as crashes

After each AI bundle install the Python dispatcher reloads because the
venv changed, and after every app shutdown it's SIGTERMed. Both took the
close handler's `code !== 0` branch (SIGTERM makes the exit code null),
so they were counted as crashes -- producing an alarming "crash" line in
the logs and a pointless ~1s recovery backoff after each of 7 installs.
A `stopping` flag set in shutdown() lets the close handler tell an
intentional stop apart from a real crash. The request-timeout kill path
deliberately does not set it, so a genuinely hung script still records a
crash and the 5-in-60s permanent-disable threshold is untouched.

Claude-Session: https://claude.ai/code/session_019fpSXhLGLXWwfyZY2tWhLG

* fix(api): return a clean message when content-aware resize times out

Carving a very high-resolution image down to a tiny target could exceed
the caire subprocess timeout, and the raw error forwarded to the user was
caire's terminal output -- ANSI color codes and progress-spinner control
characters -- instead of anything actionable. Now: the timeout path
throws a clear "timed out; try a smaller image or larger target" message
(keeping the raw stderr as `cause` for server logs); friendlyError()
strips ANSI/control chars centrally so any subprocess dump surfaced
through the shared sanitizer is plain text; and the content-aware-resize
route (a custom route that bypassed the sanitizer) now routes its error
paths through friendlyError like every other tool.

Claude-Session: https://claude.ai/code/session_019fpSXhLGLXWwfyZY2tWhLG

* fix(ai): stop bundle installs from exhausting host disk

Installing an AI bundle on a tight-disk host could push the root
filesystem to zero bytes free after the preflight check had already
passed. Two root causes:

- move_tree used copytree+rmtree, so during the move the extracted
  payload existed in both staging and the venv at once -- a full
  transient doubling on disk. Rewrote it to rename entries (a cheap
  metadata op on the same filesystem, no copy), falling back to a copy
  only across filesystems.
- the preflight budget used the manifest's extractedSize verbatim, which
  is 0 for several archives, collapsing the estimate to just the
  compressed size. Added a conservative fallback (3x compressed) so a
  missing value can't under-reserve.

Also added a real-on-disk re-check immediately before the first
destructive venv write (measuring the actual extracted payload and
whether the move needs extra space for a cross-filesystem copy), which
also now covers the offline-import path that previously skipped the disk
check entirely; wrapped the moves so an out-of-space failure returns a
clean actionable error instead of a traceback; and made the disk check
resolve the nearest existing ancestor so it never throws on a
not-yet-created venv path.

Claude-Session: https://claude.ai/code/session_019fpSXhLGLXWwfyZY2tWhLG

* feat(web): show the real per-arch AI bundle download size

The bundle cards and install prompt showed a hardcoded, architecture-blind
estimatedSize string. That's misleading: amd64 hosts always pull the
CUDA-inclusive archive (there's no CPU-only amd64 variant published), so a
bundle labelled "1-2 GB" can actually download several times that, while
arm64 pulls a much smaller archive for the same label. The manifest
already carries the real per-arch compressedSize (and extractedSize where
measured), so surface those: a new optional downloadBytes/installedBytes
on FeatureBundleState, populated in getFeatureStates() for this host's
arch (resolver mirrors install_feature.py detect_arch), shown by the UI
when present with estimatedSize kept as the fallback label. Also nudged
upscale-enhance's fallback string (4-5 -> 5-6 GB) to match its real
compressed size, consistent with the earlier photo-restoration/ocr fixes.

Fields are optional so demo/mock and existing tests stay compiling; the
manifest's extractedSize is 0 for a few archives, which now surfaces as
null rather than a bogus 0.

Claude-Session: https://claude.ai/code/session_019fpSXhLGLXWwfyZY2tWhLG

* fix(web): move the AI install queue to the server so it survives tab close

Installing multiple bundles could silently lose all but the first. The
server rejected a concurrent install with 409, so the client worked
around it by queueing the rest in browser-local state and only POSTing
each once it saw the previous finish. A single POSTed install is durable
(the installer child is detached from the request), but a queued one had
zero server footprint -- close the tab mid-queue and those installs
vanished with no error, while the UI still showed them "Queued". The
client "mutex" didn't even serialize: the queued bundles' local waits all
resolved at once and raced into concurrent POSTs that 409'd each other.

Now the queue lives on the server (a small in-memory FIFO leaf module).
The install endpoint enqueues instead of 409-ing and returns
202 {jobId, queued}; a pump starts the next bundle when the current one's
child exits (and after an offline import releases the lock), all behind
the existing venv + file locks, which are unchanged. The client just
POSTs every bundle immediately and reflects the server-reported
queued/installing status; Install All fires all POSTs and lets the server
serialize them, keeping the one-shot retry-on-failure. Adds "queued" to
FeatureStatus (the bundle card already rendered that state) and surfaces
it from getFeatureStates. In-memory is deliberate: it matches the
existing contract (survives a tab close, not a server restart, which
already clears the lock on boot).

Claude-Session: https://claude.ai/code/session_019fpSXhLGLXWwfyZY2tWhLG

* fix(qa): don't log env-derived credentials in the AI-install script

CodeQL flagged clear-text logging of sensitive information: the login
status line interpolated the QA base URL and username (both read from
the process environment) into a console.log. Replaced with a static
message. QA helper only, but it's a real hygiene issue and cleared the
high-severity code-scanning alert on the PR.

Claude-Session: https://claude.ai/code/session_019fpSXhLGLXWwfyZY2tWhLG

packages/ai/python/install_feature.py

@@ -12,6 +12,7 @@ Progress is reported via JSON lines on stderr (parsed by the Node bridge).
 Final result is a JSON object on stdout.
 """
 
+import errno
 import glob
 import hashlib
 import json
@@ -45,7 +46,19 @@ def fail(message: str) -> None:
 # -- Architecture detection --
 
 def detect_arch() -> str:
-    """Return 'amd64-gpu' or 'arm64-cpu' based on host + GPU."""
+    """Return the bundle archive key for this host.
+
+    Only two archive variants are currently published to the bundle repo:
+    'amd64-gpu' and 'arm64-cpu' (see deepsafe/feature-bundles). There is no
+    CPU-only amd64 variant yet, so amd64 hosts always resolve to 'amd64-gpu'
+    even when no GPU is present -- this downloads working CUDA-capable
+    packages, just larger than a CPU-only host strictly needs. Do not change
+    this to branch on GPU presence without first publishing an 'amd64-cpu'
+    archive for every bundle; requesting a key that doesn't exist in the
+    manifest fails the install outright (see the archives.get(arch) lookup
+    below), which would be worse than the current oversized-but-working
+    download.
+    """
     machine = platform.machine().lower()
     if machine in ("aarch64", "arm64"):
         return "arm64-cpu"
@@ -54,9 +67,21 @@ def detect_arch() -> str:
 
 # -- Disk space --
 
+def _existing_ancestor(path: str) -> str:
+    """Nearest existing ancestor of path (so disk_usage never raises on a
+    not-yet-created dir like the venv)."""
+    p = os.path.abspath(path)
+    while p and not os.path.exists(p):
+        parent = os.path.dirname(p)
+        if parent == p:
+            break
+        p = parent
+    return p or "/"
+
+
 def check_disk_space(path: str, needed_bytes: int) -> None:
-    """Fail if insufficient disk space."""
-    usage = shutil.disk_usage(path)
+    """Fail if insufficient disk space on the filesystem holding path."""
+    usage = shutil.disk_usage(_existing_ancestor(path))
     if usage.free < needed_bytes:
         free_gb = usage.free / (1024 ** 3)
         need_gb = needed_bytes / (1024 ** 3)
@@ -67,6 +92,37 @@ def check_disk_space(path: str, needed_bytes: int) -> None:
         )
 
 
+def estimate_extracted(compressed: int, extracted: int) -> int:
+    """Extracted-size estimate for the disk preflight. When the manifest omits
+    extractedSize (0), the budget would otherwise collapse to just the
+    compressed size and under-reserve for the extracted payload; fall back to a
+    conservative 3x of compressed (measured extracted/compressed ratios reach
+    ~3x). This is only the early sanity bail -- the accurate guard is the
+    real-on-disk re-check just before the destructive venv write."""
+    return extracted if extracted > 0 else compressed * 3
+
+
+def dir_size(path: str) -> int:
+    """Total size in bytes of all files under path (best-effort)."""
+    total = 0
+    for root, _dirs, files in os.walk(path):
+        for f in files:
+            try:
+                total += os.path.getsize(os.path.join(root, f))
+            except OSError:
+                pass
+    return total
+
+
+def same_filesystem(a: str, b: str) -> bool:
+    """True if paths a and b live on the same filesystem (so a rename between
+    them is a cheap metadata op rather than a full copy)."""
+    try:
+        return os.stat(_existing_ancestor(a)).st_dev == os.stat(_existing_ancestor(b)).st_dev
+    except OSError:
+        return False
+
+
 # -- Venv site-packages discovery --
 
 def get_site_packages_dir(venv_path: str) -> str:
@@ -214,10 +270,39 @@ def safe_extract(tar_path: str, staging_dir: str) -> None:
 # -- File move --
 
 def move_tree(src: str, dst: str) -> None:
-    """Recursively merge src into dst, overwriting existing files."""
-    if os.path.isdir(src):
-        shutil.copytree(src, dst, dirs_exist_ok=True)
-        shutil.rmtree(src)
+    """Merge src into dst, overwriting existing files. Renames entries where
+    possible so that on the same filesystem no copy (and thus no transient
+    doubling of the payload on disk) occurs; falls back to a copy only across
+    filesystems. The old copytree+rmtree approach duplicated the whole tree on
+    disk during the move, which could exhaust the host on a tight-disk node."""
+    if not os.path.isdir(src):
+        return
+    os.makedirs(dst, exist_ok=True)
+    for name in os.listdir(src):
+        s = os.path.join(src, name)
+        d = os.path.join(dst, name)
+        if os.path.isdir(s) and os.path.isdir(d):
+            # Both dirs exist: merge recursively rather than replace.
+            move_tree(s, d)
+            continue
+        if os.path.exists(d):
+            if os.path.isdir(d):
+                shutil.rmtree(d)
+            else:
+                os.remove(d)
+        try:
+            os.rename(s, d)
+        except OSError as e:
+            if getattr(e, "errno", None) == errno.EXDEV:
+                # Cross-filesystem: rename isn't allowed, fall back to a copy.
+                if os.path.isdir(s):
+                    shutil.copytree(s, d)
+                else:
+                    shutil.copy2(s, d)
+            else:
+                raise
+    # Remove whatever remains of src (emptied by renames, or copied originals).
+    shutil.rmtree(src, ignore_errors=True)
 
 
 # -- Fixups (NCCL wheel) --
@@ -338,8 +423,12 @@ def main() -> None:
         bundle_repo = manifest.get("bundleRepo", "deepsafe/feature-bundles")
         url = f"https://huggingface.co/{bundle_repo}/resolve/main/{archive_file}"
 
-        # Disk space check
-        needed = compressed_size + extracted_size + 500 * 1024 * 1024  # 500 MB buffer
+        # Disk space check (early sanity bail before a multi-GB download).
+        # estimate_extracted covers the extractedSize:0 case so the budget can't
+        # collapse to just the compressed size; the accurate guard is the
+        # real-on-disk re-check just before the destructive venv write below.
+        needed = compressed_size + estimate_extracted(compressed_size, extracted_size)
+        needed += 500 * 1024 * 1024  # 500 MB buffer
         if needed > 0:
             check_disk_space(ai_dir, needed)
 
@@ -407,20 +496,41 @@ def main() -> None:
     version = bundle_meta.get("version", manifest.get("imageVersion", "unknown"))
     model_ids = bundle_meta.get("models", [])
 
+    # -- Disk re-check before the first destructive venv write --
+    # The upfront check ran before the download and used an estimate; now the
+    # payload is really on disk, so measure it and verify there's room to place
+    # it before we start writing into the venv. On the same filesystem the move
+    # is a rename (no extra space needed, just a safety floor); across
+    # filesystems it is a copy that transiently needs the payload's size again.
+    # Running here (after the local/remote branches merge) also covers the
+    # offline-import path, which skipped the upfront check entirely.
+    staging_real = dir_size(staging_dir)
+    if same_filesystem(staging_dir, venv_path):
+        recheck_needed = 1024 ** 3  # 1 GB floor for fixups / installed.json / slack
+    else:
+        recheck_needed = staging_real + 1024 ** 3
+    check_disk_space(ai_dir, recheck_needed)
+
     # -- Move site-packages --
     emit_progress(92, "Installing packages...")
     site_packages_dir = get_site_packages_dir(venv_path)
     staging_sp = os.path.join(staging_dir, "site-packages")
 
-    if os.path.isdir(staging_sp) and site_packages_dir:
-        move_tree(staging_sp, site_packages_dir)
+    try:
+        if os.path.isdir(staging_sp) and site_packages_dir:
+            move_tree(staging_sp, site_packages_dir)
 
-    # -- Move models --
-    emit_progress(95, "Installing models...")
-    staging_models = os.path.join(staging_dir, "models")
-    if os.path.isdir(staging_models):
-        os.makedirs(models_dir, exist_ok=True)
-        move_tree(staging_models, models_dir)
+        # -- Move models --
+        emit_progress(95, "Installing models...")
+        staging_models = os.path.join(staging_dir, "models")
+        if os.path.isdir(staging_models):
+            os.makedirs(models_dir, exist_ok=True)
+            move_tree(staging_models, models_dir)
+    except OSError as e:
+        shutil.rmtree(staging_dir, ignore_errors=True)
+        if getattr(e, "errno", None) == errno.ENOSPC:
+            fail("Ran out of disk space while installing the bundle. Free up space and retry.")
+        fail(f"Failed to install bundle files: {e}")
 
     # -- Apply fixups --
     emit_progress(97, "Finalizing...")