web-edit 0.1a0__tar.gz → 0.1a2__tar.gz

{web_edit-0.1a0/web_edit.egg-info → web_edit-0.1a2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: web-edit
-Version: 0.1a0
+Version: 0.1a2
 Summary: Web app for editing files in a folder
 Author: Simon Willison
 License-Expression: Apache-2.0
@@ -66,14 +66,14 @@ To protect against [DNS rebinding attacks](https://tailscale.com/docs/reference/
 - Browse folders with inline previews of images smaller than 2 MB.
 - Create and edit UTF-8 text files with bundled CodeMirror 6, including on mobile.
 - Save explicitly, with unsaved-change warnings and checks for external edits.
+- Copy text to the clipboard, and images under 16 megapixels as PNG over HTTPS or localhost.
 - Upload multiple files with custom paths and names, individual progress bars, and retries.
 - Download files, or delete files and folders with inline confirmation.
 
 ## Development
 
 ```bash
-uv sync --extra test
-uv run web-edit .
+uv run web-edit --help
 uv run pytest
 ```
 

{web_edit-0.1a0 → web_edit-0.1a2}/README.md

@@ -44,14 +44,14 @@ To protect against [DNS rebinding attacks](https://tailscale.com/docs/reference/
 - Browse folders with inline previews of images smaller than 2 MB.
 - Create and edit UTF-8 text files with bundled CodeMirror 6, including on mobile.
 - Save explicitly, with unsaved-change warnings and checks for external edits.
+- Copy text to the clipboard, and images under 16 megapixels as PNG over HTTPS or localhost.
 - Upload multiple files with custom paths and names, individual progress bars, and retries.
 - Download files, or delete files and folders with inline confirmation.
 
 ## Development
 
 ```bash
-uv sync --extra test
-uv run web-edit .
+uv run web-edit --help
 uv run pytest
 ```
 

{web_edit-0.1a0 → web_edit-0.1a2}/frontend/app.js

@@ -18,6 +18,10 @@ const apiURL = (endpoint, path) => `./api/${endpoint}?path=${encodeURIComponent(
 let currentFolder = "", rootName = "Files", editor = null, editingPath = "", fileVersion = null;
 let savedText = "", isNew = false, saving = false, currentHash = "", navigation = 0;
 const language = new Compartment();
+// Images reach the clipboard as PNG, which needs the async clipboard API (HTTPS or localhost).
+const canCopyImages = Boolean(navigator.clipboard?.write && window.ClipboardItem);
+// The largest canvas iOS Safari allows; keeps PNG conversion consistent across browsers.
+const COPY_PIXEL_LIMIT = 4096 * 4096;
 
 function element(tag, className, text) {
   const node = document.createElement(tag);
@@ -59,6 +63,46 @@ async function api(endpoint, options = {}) {
   if (!response.ok) throw Object.assign(new Error(data.error || `Request failed (${response.status}).`), { status: response.status, data });
   return data;
 }
+async function copyText(text) {
+  if (navigator.clipboard?.writeText) return navigator.clipboard.writeText(text);
+  // Plain HTTP, such as a Tailscale IP address, has no async clipboard API.
+  const focused = document.activeElement;
+  const area = element("textarea");
+  area.value = text; area.readOnly = true;
+  area.style.cssText = "position: fixed; top: 0; left: -9999px; font-size: 16px;";
+  document.body.append(area);
+  area.select(); area.setSelectionRange(0, text.length);
+  const copied = document.execCommand("copy");
+  area.remove(); focused?.focus({ preventScroll: true });
+  if (!copied) throw new Error("Copy failed.");
+}
+function imagePNG(image) {
+  return new Promise((resolve, reject) => {
+    const canvas = element("canvas");
+    canvas.width = image.naturalWidth; canvas.height = image.naturalHeight;
+    canvas.getContext("2d").drawImage(image, 0, 0);
+    canvas.toBlob((blob) => blob ? resolve(blob) : reject(new Error("Conversion failed.")), "image/png");
+  });
+}
+async function copyImage() {
+  const image = $("viewer-content").querySelector("img");
+  const path = $("viewer-title").textContent;
+  const pixels = image.naturalWidth * image.naturalHeight;
+  if (!pixels) { notify("This image has no fixed size, so it cannot be copied.", true); return; }
+  if (pixels > COPY_PIXEL_LIMIT) { notify("Images over 16 megapixels are too large to copy. You can download it instead.", true); return; }
+  // Safari only allows clipboard writes started directly by the click, so pass promises.
+  const types = { "image/png": imagePNG(image) };
+  if (/\.svg$/i.test(path)) {
+    types["text/plain"] = fetch(apiURL("image", path)).then(async (response) => {
+      if (!response.ok) throw new Error("Request failed.");
+      return new Blob([await response.text()], { type: "text/plain" });
+    });
+  }
+  try {
+    await navigator.clipboard.write([new ClipboardItem(types)]);
+    notify(`Copied ${path} to the clipboard.`);
+  } catch { notify("Could not copy this image to the clipboard.", true); }
+}
 function dirty() { return editor && editor.state.doc.toString() !== savedText; }
 function updateSaveState() {
   $("save-state").textContent = saving ? "Saving…" : dirty() ? "Unsaved changes" : isNew ? "New file · not saved yet" : "All changes saved";
@@ -218,15 +262,20 @@ function openViewer(path, message, preview) {
   $("viewer-title").textContent = path;
   $("viewer-download").href = apiURL("download", path);
   $("viewer-content").replaceChildren();
+  $("viewer-copy").hidden = !preview || !canCopyImages;
+  $("viewer-copy").disabled = true;
   if (preview) {
     const loading = loadingState("Loading image…");
     const image = element("img");
     image.alt = path; image.hidden = true;
-    image.addEventListener("load", () => { loading.remove(); image.hidden = false; });
+    image.addEventListener("load", () => {
+      if (!image.isConnected) return;
+      loading.remove(); image.hidden = false; $("viewer-copy").disabled = false;
+    });
     image.addEventListener("error", () => {
       if (!image.isConnected) return;
       loading.replaceWith(element("p", "", "This image cannot be previewed. You can download it instead."));
-      image.remove();
+      image.remove(); $("viewer-copy").hidden = true;
     });
     $("viewer-content").append(loading, image);
     image.src = apiURL("image", path);
@@ -397,6 +446,12 @@ $("new-file").addEventListener("click", () => { location.hash = routeURL("new",
 $("refresh").addEventListener("click", route);
 for (const id of ["back", "viewer-back"]) $(id).addEventListener("click", () => { location.hash = routeURL("browse", currentFolder); });
 $("save").addEventListener("click", save);
+$("editor-copy").addEventListener("click", async () => {
+  if (!editor) return;
+  try { await copyText(editor.state.doc.toString()); notify("Copied to the clipboard."); }
+  catch { notify("Could not copy to the clipboard.", true); }
+});
+$("viewer-copy").addEventListener("click", copyImage);
 $("new-path").addEventListener("input", () => { if (editor) { const [name, support] = languageFor($("new-path").value); $("language-label").textContent = name; editor.dispatch({ effects: language.reconfigure(support) }); } });
 window.addEventListener("hashchange", route);
 window.addEventListener("beforeunload", (event) => { if (dirty() || saving || activeUploads) { event.preventDefault(); event.returnValue = ""; } });

{web_edit-0.1a0 → web_edit-0.1a2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "web-edit"
-version = "0.1a0"
+version = "0.1a2"
 description = "Web app for editing files in a folder"
 readme = "README.md"
 authors = [{name = "Simon Willison"}]

{web_edit-0.1a0 → web_edit-0.1a2}/scripts/check_wheel.py

@@ -1,15 +1,19 @@
 """Install a built wheel away from the checkout and exercise its packaged app.
 
-Usage: uv run scripts/check_wheel.py dist/web_edit-0.1-py3-none-any.whl
+Usage: uv run scripts/check_wheel.py dist/*.whl
 """
 
+import argparse
 import subprocess
 import sys
 import tempfile
 import zipfile
 from pathlib import Path
 
-wheel = Path(sys.argv[1]).resolve()
+parser = argparse.ArgumentParser(description=__doc__)
+parser.add_argument("wheel", type=Path, help="Path to the single wheel to verify")
+wheel = parser.parse_args().wheel.resolve()
+print(f"Verifying {wheel.name}", flush=True)
 required = {
     "web_edit/static/index.html",
     "web_edit/static/app.css",

{web_edit-0.1a0 → web_edit-0.1a2}/tests/test_app.py

@@ -1,3 +1,4 @@
+import hashlib
 import json
 import os
 import stat
@@ -8,7 +9,13 @@ import pytest
 from starlette.testclient import TestClient
 
 from web_edit.app import create_app
-from web_edit.files import IMAGE_LIMIT, TEXT_LIMIT, FileError, FileStore
+from web_edit.files import (
+    IMAGE_LIMIT,
+    TEXT_LIMIT,
+    FileError,
+    FileStore,
+    preserve_endings,
+)
 
 
 @pytest.fixture
@@ -55,6 +62,16 @@ def test_browse(client, tmp_path):
     assert client.get("/api/browse", params={"path": "missing"}).status_code == 404
 
 
+def test_browse_nested_paths(client, tmp_path):
+    (tmp_path / "a" / "b").mkdir(parents=True)
+    (tmp_path / "a" / "b" / "c.txt").write_text("c")
+    root = client.get("/api/browse").json()
+    assert [entry["path"] for entry in root["entries"]] == ["a"]
+    nested = client.get("/api/browse", params={"path": "a//b/"}).json()
+    assert nested["path"] == "a/b"
+    assert [entry["path"] for entry in nested["entries"]] == ["a/b/c.txt"]
+
+
 def test_create_read_edit_download(client, tmp_path):
     path = "nested/a & #? café.txt"
     created = save(client, path, "Hello 👋\n")
@@ -64,6 +81,8 @@ def test_create_read_edit_download(client, tmp_path):
     changed = save(client, path, "Updated\n", text["version"])
     assert changed.status_code == 200
     assert changed.json()["version"] != text["version"]
+    reread = client.get("/api/text", params={"path": path}).json()
+    assert reread["version"] == changed.json()["version"]
     downloaded = client.get("/api/download", params={"path": path})
     assert downloaded.content == b"Updated\n"
     assert "attachment" in downloaded.headers["content-disposition"]
@@ -96,7 +115,9 @@ def test_invalid_unicode(client):
         (b"one\r\ntwo\r\n", "one\nchanged\n", b"one\r\nchanged\r\n"),
         (b"one\rtwo\r", "one\nchanged\n", b"one\rchanged\r"),
         (b"one\ntwo\n", "one\nchanged\n", b"one\nchanged\n"),
+        (b"one\ntwo\n", "one\r\nchanged\r", b"one\nchanged\n"),
         (b"one\r\ntwo\nthree\r", "one\ntwo\nthree\n", b"one\r\ntwo\nthree\r"),
+        (b"a\r\n\r\nb\n\nc\r\n", "a\n\nb\n\nnew\nc\n", b"a\r\n\r\nb\n\nnew\r\nc\r\n"),
         (b"\xef\xbb\xbfone\r\n", "changed\n", b"\xef\xbb\xbfchanged\r\n"),
         (b"one", "two", b"two"),
         (b"", "new\n", b"new\n"),
@@ -110,6 +131,18 @@ def test_preserves_line_endings_and_bom(client, tmp_path, original, edited, expe
     assert path.read_bytes() == expected
 
 
+def test_preserves_mixed_endings_with_scattered_edits():
+    lines = [(f"line {i}", "\r\n" if i % 3 else "\n") for i in range(3000)]
+    original = "".join(line + ending for line, ending in lines)
+    for i in range(0, len(lines), 7):
+        lines[i] = (f"changed {i}", "\r\n")
+    lines.insert(1500, ("inserted", "\r\n"))
+    del lines[10]
+    edited = "".join(line + "\n" for line, _ in lines)
+    expected = "".join(line + ending for line, ending in lines)
+    assert preserve_endings(original, edited) == expected
+
+
 def test_preserves_permissions(client, tmp_path):
     path = tmp_path / "script.sh"
     path.write_text("echo before\n")
@@ -160,6 +193,7 @@ def test_upload_spooled_file_custom_path_and_binary(client, tmp_path):
     data = b"\x00\xff" * (1024 * 1024)
     response = upload(client, "new/folder/custom.bin", data)
     assert response.status_code == 201
+    assert response.json()["version"] == hashlib.sha256(data).hexdigest()
     assert (tmp_path / "new/folder/custom.bin").read_bytes() == data
     assert (
         client.get("/api/download", params={"path": "new/folder/custom.bin"}).content

{web_edit-0.1a0 → web_edit-0.1a2}/web_edit/files.py

@@ -8,6 +8,7 @@ import shutil
 import stat
 import tempfile
 import threading
+from bisect import bisect_left
 from collections import Counter
 from difflib import SequenceMatcher
 from pathlib import Path, PurePosixPath
@@ -25,6 +26,9 @@ IMAGE_TYPES = {
     "image/vnd.microsoft.icon",
     "image/svg+xml",
 }
+CONTROL_BYTES = bytes([*range(0x09), 0x0B, 0x0C, *range(0x0E, 0x20)])
+# Python 3.13+ can skip the URL parsing that guess_type does for every filename.
+guess_file_type = getattr(mimetypes, "guess_file_type", mimetypes.guess_type)
 
 
 class FileError(Exception):
@@ -53,30 +57,90 @@ def decode_text(data):
         raise FileError(
             "This file is not UTF-8 text. You can download it instead.", 415
         )
-    if re.search(r"[\x00-\x08\x0b\x0c\x0e-\x1f]", text):
+    # UTF-8 only uses these bytes for control characters; translate beats a regex.
+    if len(data.translate(None, CONTROL_BYTES)) != len(data):
         raise FileError(
             "This looks like a binary file. You can download it instead.", 415
         )
     return text
 
 
+def matching_blocks(old, new):
+    """Yield (old index, new index, size) for runs of matching lines.
+
+    SequenceMatcher alone slows down sharply on long files with scattered edits.
+    As in patience diff, lines that occur once in each version anchor the
+    comparison, so SequenceMatcher only aligns the gaps between anchors.
+    """
+    old_counts, new_counts = Counter(old), Counter(new)
+    positions = {line: i for i, line in enumerate(old) if old_counts[line] == 1}
+    candidates = [
+        (positions[line], j)
+        for j, line in enumerate(new)
+        if new_counts[line] == 1 and line in positions
+    ]
+    # Keep the longest series of candidates in the same order in both versions.
+    tails, ends, links = [], [], []
+    for index, (i, _) in enumerate(candidates):
+        length = bisect_left(tails, i)
+        links.append(ends[length - 1] if length else None)
+        if length == len(tails):
+            tails.append(i)
+            ends.append(index)
+        else:
+            tails[length] = i
+            ends[length] = index
+    anchors = [(len(old), len(new), 0)]
+    index = ends[-1] if ends else None
+    while index is not None:
+        anchors.append((*candidates[index], 1))
+        index = links[index]
+    anchors.append((0, 0, 0))
+    a = b = 0
+    for i, j, size in reversed(anchors):
+        if i < a:
+            continue  # Already matched by extending the previous block.
+        # Extend each anchor backward, compare the remaining gap, then extend forward.
+        start_a, start_b = i, j
+        while a < start_a and b < start_b and old[start_a - 1] == new[start_b - 1]:
+            start_a, start_b = start_a - 1, start_b - 1
+        if a < start_a and b < start_b:
+            # SequenceMatcher's autojunk heuristic handles repetitive documents.
+            matcher = SequenceMatcher(None, old[a:start_a], new[b:start_b])
+            for match in matcher.get_matching_blocks():
+                yield a + match.a, b + match.b, match.size
+        a, b = i + size, j + size
+        while a < len(old) and b < len(new) and old[a] == new[b]:
+            a, b = a + 1, b + 1
+        yield start_a, start_b, a - start_a
+
+
 def preserve_endings(original, edited):
     """Keep the endings of unchanged lines, including files with mixed endings."""
-    old_lines = re.split(r"\r\n|\r|\n", original)
-    old_endings = re.findall(r"\r\n|\r|\n", original)
-    new_lines = re.split(r"\r\n|\r|\n", edited)
-    default = Counter(old_endings).most_common(1)[0][0] if old_endings else "\n"
+    edited = edited.replace("\r\n", "\n").replace("\r", "\n")
+    crlf = original.count("\r\n")
+    counts = {
+        "\r\n": crlf,
+        "\r": original.count("\r") - crlf,
+        "\n": original.count("\n") - crlf,
+    }
+    used = [ending for ending, count in counts.items() if count]
+    if len(used) < 2:
+        # Files with one kind of line ending need no comparison.
+        return edited.replace("\n", used[0]) if used else edited
+    parts = re.split(r"(\r\n|\r|\n)", original)
+    old_lines, old_endings = parts[::2], parts[1::2]
+    new_lines = edited.split("\n")
+    default = Counter(old_endings).most_common(1)[0][0]
     endings = [default] * (len(new_lines) - 1)
-    # SequenceMatcher's autojunk heuristic handles repetitive documents.
-    for match in SequenceMatcher(None, old_lines, new_lines).get_matching_blocks():
-        for offset in range(match.size):
-            old_index, new_index = match.a + offset, match.b + offset
-            if old_index < len(old_endings) and new_index < len(endings):
-                endings[new_index] = old_endings[old_index]
-    return "".join(
-        line + (endings[i] if i < len(endings) else "")
-        for i, line in enumerate(new_lines)
-    )
+    for old_index, new_index, size in matching_blocks(old_lines, new_lines):
+        # The final line of each version has no ending.
+        size = min(size, len(old_endings) - old_index, len(endings) - new_index)
+        if size > 0:
+            endings[new_index : new_index + size] = old_endings[
+                old_index : old_index + size
+            ]
+    return "".join(line + ending for line, ending in zip(new_lines, endings + [""]))
 
 
 class FileStore:
@@ -114,7 +178,7 @@ class FileStore:
         return path
 
     def image_type(self, path):
-        mime = mimetypes.guess_type(path.name)[0]
+        mime = guess_file_type(path.name)[0]
         return mime if mime in IMAGE_TYPES else None
 
     def browse(self, relative):
@@ -123,32 +187,36 @@ class FileStore:
             if not folder.exists():
                 raise FileNotFoundError()
             raise FileError("This is not a folder.")
+        path = "" if folder == self.root else folder.relative_to(self.root).as_posix()
+        prefix = f"{path}/" if path else ""
         entries = []
-        for child in folder.iterdir():
-            if child.name.startswith(".web-edit-"):
-                continue
-            try:
-                info = child.lstat()
-            except FileNotFoundError:
-                continue
-            kind = "directory" if stat.S_ISDIR(info.st_mode) else "file"
-            if stat.S_ISLNK(info.st_mode):
-                kind = "symlink"
-            elif not (stat.S_ISDIR(info.st_mode) or stat.S_ISREG(info.st_mode)):
-                kind = "special"
-            entries.append(
-                {
-                    "name": child.name,
-                    "path": child.relative_to(self.root).as_posix(),
-                    "kind": kind,
-                    "size": info.st_size,
-                    "modified": info.st_mtime,
-                    "delete_version": delete_version(info),
-                    "preview": kind == "file"
-                    and info.st_size < IMAGE_LIMIT
-                    and bool(self.image_type(child)),
-                }
-            )
+        # scandir and plain strings avoid creating Path objects for every entry.
+        with os.scandir(folder) as children:
+            for child in children:
+                if child.name.startswith(".web-edit-"):
+                    continue
+                try:
+                    info = child.stat(follow_symlinks=False)
+                except FileNotFoundError:
+                    continue
+                kind = "directory" if stat.S_ISDIR(info.st_mode) else "file"
+                if stat.S_ISLNK(info.st_mode):
+                    kind = "symlink"
+                elif not (stat.S_ISDIR(info.st_mode) or stat.S_ISREG(info.st_mode)):
+                    kind = "special"
+                entries.append(
+                    {
+                        "name": child.name,
+                        "path": prefix + child.name,
+                        "kind": kind,
+                        "size": info.st_size,
+                        "modified": info.st_mtime,
+                        "delete_version": delete_version(info),
+                        "preview": kind == "file"
+                        and info.st_size < IMAGE_LIMIT
+                        and bool(self.image_type(child)),
+                    }
+                )
         entries.sort(
             key=lambda item: (
                 item["kind"] != "directory",
@@ -157,9 +225,7 @@ class FileStore:
             )
         )
         return {
-            "path": ""
-            if folder == self.root
-            else folder.relative_to(self.root).as_posix(),
+            "path": path,
             "root_name": self.root.name or "/",
             "entries": entries,
         }
@@ -192,18 +258,18 @@ class FileStore:
     def text(self, relative):
         with self.lock:
             path = self.regular_file(relative)
-            before = version(path)
             if path.stat().st_size > TEXT_LIMIT:
                 raise FileError(
                     "Text editing is limited to 10 MiB. You can download this file.",
                     413,
                 )
             data = path.read_bytes()
-            if version(path) != before:
+            current = hashlib.sha256(data).hexdigest()
+            if version(path) != current:
                 raise FileError(
                     "The file changed while opening it. Please try again.", 409
                 )
-            return {"path": relative, "content": decode_text(data), "version": before}
+            return {"path": relative, "content": decode_text(data), "version": current}
 
     def check_destination(self, relative, expected):
         path = self.path(relative, file=True)
@@ -233,12 +299,16 @@ class FileStore:
             target.parent.mkdir(parents=True, exist_ok=True)
             self.path(relative, file=True)
             temporary = None
+            # Hash while copying, so the version matches what was written without rereading.
+            digest = hashlib.sha256()
             try:
                 with tempfile.NamedTemporaryFile(
                     prefix=".web-edit-", dir=target.parent, delete=False
                 ) as output:
                     temporary = Path(output.name)
-                    shutil.copyfileobj(source, output, length=1024 * 1024)
+                    while chunk := source.read(1024 * 1024):
+                        digest.update(chunk)
+                        output.write(chunk)
                     output.flush()
                     os.fsync(output.fileno())
                 self.check_destination(relative, expected)
@@ -257,7 +327,7 @@ class FileStore:
             finally:
                 if temporary is not None:
                     temporary.unlink(missing_ok=True)
-            return {"path": relative, "version": version(target)}
+            return {"path": relative, "version": digest.hexdigest()}
 
     def save_text(self, relative, content, expected):
         from io import BytesIO