@viralspin/mcp 0.4.0 → 0.5.2

package/dist/organize-watch.js

@@ -0,0 +1,699 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.embFile = exports.THUMB_PORT = void 0;
+exports.warmFolderPicker = warmFolderPicker;
+exports.pickFolder = pickFolder;
+exports.clipFile = clipFile;
+exports.startThumbServer = startThumbServer;
+exports.resultOf = resultOf;
+exports.organizeTick = organizeTick;
+exports.organizeLoop = organizeLoop;
+exports.organizeDelay = organizeDelay;
+/**
+ * THE CONNECTOR'S ORGANIZER: while `viralspin-mcp watch` runs, a "Sort a folder" asked from the web app (My Story ▸ Organized) is done HERE, on the creator's own computer.
+ * It scans the folder (read-only, nothing moved), reports progress and the bucket names + counts, and serves the small thumbnails to the web page over loopback
+ * (127.0.0.1, only to ViralSpin's own origins), so the animation can show the creator's real pictures without any of them being uploaded. Adding the folder to My Story
+ * (the opt-in upload of thumbnails + tags) happens only when the web app asks for it.
+ */
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const http_1 = __importDefault(require("http"));
+const path_1 = __importDefault(require("path"));
+const organize_js_1 = require("./tools/organize.js");
+const plan_js_1 = require("./organizer/plan.js");
+const scan_js_1 = require("./organizer/scan.js");
+const edit_js_1 = require("./organizer/edit.js");
+const topics_js_1 = require("./organizer/topics.js");
+const images_js_1 = require("./organizer/images.js");
+exports.THUMB_PORT = 47831;
+const ORIGIN_OK = /^(https:\/\/([\w-]+\.)?viralspin\.ai|http:\/\/localhost:\d+|http:\/\/127\.0\.0\.1:\d+)$/;
+/**
+ * Windows: ONE PowerShell kept running with the forms library already loaded, so "Choose a folder…" opens at once instead of after a cold start; it
+ * reads "pick" lines and answers each with the chosen path ("" = cancelled). The window is Windows' own folder picker (the Explorer dialog with
+ * folders only and a "Sort this folder" button, via IFileOpenDialog + FOS_PICKFOLDERS), forced to the front: a background process can not normally take the foreground, which left the
+ * old dialog hidden behind the browser and looking like it took forever.
+ */
+const WIN_PICKER = String.raw `
+[Console]::OutputEncoding=[Text.Encoding]::UTF8
+Add-Type -AssemblyName System.Windows.Forms
+Add-Type -TypeDefinition @'
+using System;
+using System.Runtime.InteropServices;
+[ComImport, Guid("DC1C5A9C-E88A-4dde-A5A1-60F82A20AEF7")] class VsFileOpenDialogRCW {}
+[ComImport, Guid("43826D1E-E718-42EE-BC55-A1E261C37BFE"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+interface IVsShellItem {
+  void BindToHandler(IntPtr pbc, ref Guid bhid, ref Guid riid, out IntPtr ppv);
+  void GetParent(out IVsShellItem p);
+  void GetDisplayName(uint sigdn, [MarshalAs(UnmanagedType.LPWStr)] out string name);
+  void GetAttributes(uint m, out uint a);
+  void Compare(IVsShellItem i, uint h, out int o);
+}
+[ComImport, Guid("d57c7288-d4ad-4768-be02-9d969532d960"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+interface IVsFileOpenDialog {
+  [PreserveSig] int Show(IntPtr parent);
+  void SetFileTypes(uint c, IntPtr f); void SetFileTypeIndex(uint i); void GetFileTypeIndex(out uint i);
+  void Advise(IntPtr e, out uint c); void Unadvise(uint c);
+  void SetOptions(uint fos); void GetOptions(out uint fos);
+  void SetDefaultFolder(IVsShellItem i); void SetFolder(IVsShellItem i); void GetFolder(out IVsShellItem i); void GetCurrentSelection(out IVsShellItem i);
+  void SetFileName([MarshalAs(UnmanagedType.LPWStr)] string n); void GetFileName([MarshalAs(UnmanagedType.LPWStr)] out string n);
+  void SetTitle([MarshalAs(UnmanagedType.LPWStr)] string t); void SetOkButtonLabel([MarshalAs(UnmanagedType.LPWStr)] string t);
+  void SetFileNameLabel([MarshalAs(UnmanagedType.LPWStr)] string t);
+  void GetResult(out IVsShellItem i);
+  void AddPlace(IVsShellItem i, int fdap); void SetDefaultExtension([MarshalAs(UnmanagedType.LPWStr)] string e);
+  void Close(int hr); void SetClientGuid(ref Guid g); void ClearClientData(); void SetFilter(IntPtr f);
+  void GetResults(out IntPtr e); void GetSelectedItems(out IntPtr e);
+}
+public static class VsPick {
+  [DllImport("user32.dll")] public static extern bool SetForegroundWindow(IntPtr h);
+  [DllImport("user32.dll")] public static extern void keybd_event(byte k, byte s, int f, int e);
+  public static string Pick(IntPtr owner, string title) {
+    IVsFileOpenDialog d = (IVsFileOpenDialog)new VsFileOpenDialogRCW();
+    uint o; d.GetOptions(out o);
+    d.SetOptions(o | 0x20 | 0x40);
+    d.SetTitle(title); d.SetOkButtonLabel("Sort this folder");
+    if (d.Show(owner) != 0) return "";
+    IVsShellItem r; d.GetResult(out r);
+    string p; r.GetDisplayName(0x80058000, out p);
+    return p;
+  }
+}
+'@
+[Console]::Out.WriteLine("ready"); [Console]::Out.Flush()
+while ($true) {
+  $line = [Console]::In.ReadLine(); if ($line -eq $null) { break }
+  $o = New-Object System.Windows.Forms.Form
+  $o.TopMost = $true; $o.ShowInTaskbar = $false; $o.FormBorderStyle = 'None'; $o.StartPosition = 'Manual'
+  $o.Location = New-Object System.Drawing.Point(-3000, -3000); $o.Size = New-Object System.Drawing.Size(1, 1)
+  $o.Show(); [VsPick]::keybd_event(0x12, 0, 0, 0); [VsPick]::keybd_event(0x12, 0, 2, 0); [void][VsPick]::SetForegroundWindow($o.Handle); $o.Activate()
+  $r = ''; try { $r = [VsPick]::Pick($o.Handle, 'Choose a folder of pictures and clips to sort') } catch { $r = '' }
+  $o.Close(); $o.Dispose(); [Console]::Out.WriteLine('PICKED:' + $r); [Console]::Out.Flush()
+}
+`;
+let winPicker = null;
+function winPickerProc() {
+    if (winPicker && winPicker.child.exitCode === null)
+        return winPicker;
+    const file = path_1.default.join(os_1.default.tmpdir(), "viralspin-folder-picker.ps1");
+    fs_1.default.writeFileSync(file, WIN_PICKER);
+    const child = (0, child_process_1.spawn)("powershell.exe", ["-NoProfile", "-STA", "-ExecutionPolicy", "Bypass", "-File", file], { windowsHide: true });
+    const me = { child, waiting: [] };
+    let buf = "";
+    child.stdout.on("data", (d) => { buf += d; let i; while ((i = buf.indexOf("\n")) >= 0) {
+        const l = buf.slice(0, i).trim();
+        buf = buf.slice(i + 1);
+        if (l.startsWith("PICKED:"))
+            me.waiting.shift()?.(l.slice(7));
+    } });
+    child.on("exit", () => { me.waiting.splice(0).forEach((f) => f("")); if (winPicker === me)
+        winPicker = null; });
+    child.on("error", () => { me.waiting.splice(0).forEach((f) => f("")); });
+    winPicker = me;
+    return me;
+}
+/** Start the Windows picker ahead of time, so the first click is fast too. */
+function warmFolderPicker() { if (process.platform === "win32") {
+    try {
+        winPickerProc();
+    }
+    catch { /* the first click starts it */ }
+} }
+/** The computer's own "choose a folder" window. Resolves to the path, or "" when cancelled. A web page cannot learn a folder's real path, so the connector asks the OS. */
+function pickFolder() {
+    const done = (resolve) => (err, out) => resolve(err ? "" : String(out).trim());
+    return new Promise((resolve) => {
+        if (process.platform === "win32") {
+            const p = winPickerProc();
+            p.waiting.push(resolve);
+            p.child.stdin?.write("pick\n");
+        }
+        else if (process.platform === "darwin") {
+            (0, child_process_1.execFile)("osascript", ["-e", 'POSIX path of (choose folder with prompt "Choose a folder of pictures and clips to sort")'], { timeout: 300000 }, done(resolve));
+        }
+        else
+            (0, child_process_1.execFile)("zenity", ["--file-selection", "--directory", "--title=Choose a folder to sort"], { timeout: 300000 }, done(resolve));
+    });
+}
+/** The sort running on this computer right now: its previews in the order they were made (the page builds its live pile from these). */
+const live = { job: "", thumbs: [], at: new Map(), cards: [] };
+const clipJobs = new Map();
+/**
+ * A plan, parsed once and kept while its file is unchanged. A big sort's plan is tens of MB; the replay asks for a thousand thumbnails at once,
+ * and parsing the plan for each one held every thumbnail up for minutes (the page drew colour tiles where the pictures should be).
+ */
+const planCache = new Map();
+function readPlan(planId) {
+    const f = (0, organize_js_1.planFile)(planId);
+    const st = fs_1.default.statSync(f);
+    const hit = planCache.get(planId);
+    if (hit && hit.mtimeMs === st.mtimeMs && hit.size === st.size)
+        return hit.plan;
+    const plan = JSON.parse(fs_1.default.readFileSync(f, "utf8"));
+    planCache.set(planId, { mtimeMs: st.mtimeMs, size: st.size, plan });
+    if (planCache.size > 4)
+        planCache.delete(planCache.keys().next().value);
+    return plan;
+}
+/** The playable clip for a plan item (cached): the Live Photo's paired clip, or the first 10 s of a video, as H.264 + AAC, at most 1080 px tall. */
+function clipFile(planId, i) {
+    const key = `${planId}:${i}`;
+    if (!clipJobs.has(key))
+        clipJobs.set(key, (async () => {
+            const plan = readPlan(planId);
+            const it = plan.items?.[i];
+            const src = it?.live ? path_1.default.join(plan.root, it.live) : it?.kind === "video" ? path_1.default.join(plan.root, it.rel) : null;
+            if (!src || !fs_1.default.existsSync(src))
+                return null;
+            const dir = path_1.default.join(organize_js_1.STATE_DIR, `${planId}-clips`);
+            const out = path_1.default.join(dir, `${i}.mp4`);
+            if (fs_1.default.existsSync(out) && fs_1.default.statSync(out).size > 0)
+                return out;
+            fs_1.default.mkdirSync(dir, { recursive: true });
+            const ok = await new Promise((done) => {
+                (0, child_process_1.execFile)((0, images_js_1.ffmpegPath)(), ["-v", "error", "-y", "-i", src, "-t", "10", "-vf", "scale=-2:'min(1080,ih)'", "-c:v", "libx264", "-preset", "veryfast", "-crf", "23", "-pix_fmt", "yuv420p", "-c:a", "aac", "-b:a", "128k", "-movflags", "+faststart", out], { timeout: 120000 }, (e) => done(!e && fs_1.default.existsSync(out)));
+            });
+            if (!ok) {
+                clipJobs.delete(key);
+                return null;
+            }
+            return out;
+        })());
+    return clipJobs.get(key);
+}
+/** Loopback server for thumbnails: GET /thumb/<planId>/<index>.jpg. Only the app's own origins get a CORS grant; plan ids are random. */
+function startThumbServer(log) {
+    const server = http_1.default.createServer((req, res) => {
+        const origin = String(req.headers.origin || "");
+        // Vary on EVERY answer, granted or not: a plain <img> (no Origin) cached without it was handed by the browser to the 3D space's CORS
+        // request for the same preview, which then failed, and every card in it stayed a colour block
+        res.setHeader("Vary", "Origin");
+        if (ORIGIN_OK.test(origin)) {
+            res.setHeader("Access-Control-Allow-Origin", origin);
+            res.setHeader("Access-Control-Allow-Private-Network", "true");
+        }
+        if (req.method === "OPTIONS") {
+            res.statusCode = 204;
+            return res.end();
+        }
+        const route = (req.url || "").split("?")[0];
+        // the running sort's previews: /live/<job> -> { count }, /live/<job>/<n>.jpg -> the n-th preview made
+        // the cards so far, in the order they were placed: /live/<job>/cards/<from> -> { rows: [[preview n, card], ...] }
+        const lc = /^\/live\/([\w-]{4,60})\/cards\/(\d{1,6})$/.exec(route);
+        if (lc) {
+            if (!ORIGIN_OK.test(origin)) {
+                res.statusCode = 403;
+                return res.end();
+            }
+            res.setHeader("Content-Type", "application/json");
+            return res.end(JSON.stringify({ rows: lc[1] === live.job ? live.cards.slice(Number(lc[2]), Number(lc[2]) + 500) : [] }));
+        }
+        const lm = /^\/live\/([\w-]{4,60})(?:\/(\d{1,6})\.jpg)?$/.exec(route);
+        if (lm) {
+            if (!ORIGIN_OK.test(origin)) {
+                res.statusCode = 403;
+                return res.end();
+            }
+            if (lm[1] !== live.job) {
+                res.setHeader("Content-Type", "application/json");
+                return res.end(JSON.stringify({ count: 0 }));
+            }
+            if (lm[2] === undefined) {
+                res.setHeader("Content-Type", "application/json");
+                return res.end(JSON.stringify({ count: live.thumbs.length, cards: live.cards.length }));
+            }
+            const f = live.thumbs[Number(lm[2])];
+            if (!f || !fs_1.default.existsSync(f)) {
+                res.statusCode = 404;
+                return res.end();
+            }
+            res.setHeader("Content-Type", "image/jpeg");
+            res.setHeader("Cache-Control", "private, max-age=3600");
+            return void fs_1.default.createReadStream(f).pipe(res);
+        }
+        if (route === "/ping") {
+            res.setHeader("Content-Type", "application/json");
+            return res.end(JSON.stringify({ ok: true, items: 1 }));
+        }
+        // a sorted folder's pictures, for browsing and using them on this computer without uploading anything: one row per picture with a preview
+        // open the sorted folder (/reveal/<plan>) or one file of it, selected (/reveal/<plan>/<i>), in Explorer or Finder. Sorting moves nothing,
+        // so a sort's folders are not on disk: this shows each file where it really is. Only paths in the plan, and only for a ViralSpin page (POST
+        // with an allowed Origin), so no other site can open windows on this computer
+        const rv = /^\/reveal\/([\w-]{4,40})(?:\/(\d{1,6}))?$/.exec(route);
+        if (rv) {
+            if (req.method !== "POST" || !ORIGIN_OK.test(origin)) {
+                res.statusCode = 403;
+                return res.end();
+            }
+            try {
+                const plan = readPlan(rv[1]);
+                const it = rv[2] !== undefined ? plan.items?.[Number(rv[2])] : null;
+                const file = it ? path_1.default.join(plan.root, it.rel) : null;
+                const sel = file && fs_1.default.existsSync(file) ? file : null, dir = sel ? null : file && fs_1.default.existsSync(path_1.default.dirname(file)) ? path_1.default.dirname(file) : plan.root;
+                if (!sel && !fs_1.default.existsSync(dir)) {
+                    res.statusCode = 404;
+                    return res.end();
+                }
+                // explorer wants /select,"path" exactly: Node's own quoting of the whole argument breaks it on a path with spaces
+                const [cmd, args] = process.platform === "win32" ? ["explorer.exe", sel ? [`/select,"${sel}"`] : [`"${dir}"`]]
+                    : process.platform === "darwin" ? ["open", sel ? ["-R", sel] : [dir]] : ["xdg-open", [sel ? path_1.default.dirname(sel) : dir]];
+                (0, child_process_1.spawn)(cmd, args, { detached: true, stdio: "ignore", windowsVerbatimArguments: process.platform === "win32" }).on("error", () => undefined).unref();
+                res.setHeader("Content-Type", "application/json");
+                return res.end(JSON.stringify({ ok: true }));
+            }
+            catch {
+                res.statusCode = 404;
+                return res.end();
+            }
+        }
+        // a file served with Range, so a <video> starts at once and seeks without reading the whole file
+        const ranged = (file) => {
+            const size = fs_1.default.statSync(file).size;
+            const m = /bytes=(\d*)-(\d*)/.exec(String(req.headers.range || ""));
+            res.setHeader("Content-Type", "video/mp4");
+            res.setHeader("Accept-Ranges", "bytes");
+            res.setHeader("Cache-Control", "private, max-age=3600");
+            if (m && size > 0) {
+                const start = m[1] ? Math.min(Number(m[1]), size - 1) : Math.max(0, size - Number(m[2] || 0)), end = m[1] && m[2] ? Math.min(Number(m[2]), size - 1) : size - 1;
+                res.statusCode = 206;
+                res.setHeader("Content-Range", `bytes ${start}-${end}/${size}`);
+                res.setHeader("Content-Length", String(end - start + 1));
+                fs_1.default.createReadStream(file, { start, end }).pipe(res);
+            }
+            else {
+                res.setHeader("Content-Length", String(size));
+                fs_1.default.createReadStream(file).pipe(res);
+            }
+        };
+        // a video (or a Live Photo's clip) as it is on disk, for playing it in full at once: nothing converted. A browser that can't decode it (HEVC
+        // without hardware support) says so, and the page falls back to /clip
+        const vm = /^\/video\/([\w-]{4,40})\/(\d{1,6})$/.exec(route);
+        if (vm) {
+            if (!ORIGIN_OK.test(origin)) {
+                res.statusCode = 403;
+                return res.end();
+            }
+            try {
+                const plan = readPlan(vm[1]);
+                const it = plan.items?.[Number(vm[2])];
+                const src = it?.live ? path_1.default.join(plan.root, it.live) : it?.kind === "video" ? path_1.default.join(plan.root, it.rel) : null;
+                if (!src || !fs_1.default.existsSync(src)) {
+                    res.statusCode = 404;
+                    return res.end();
+                }
+                return ranged(src);
+            }
+            catch {
+                res.statusCode = 404;
+                return res.end();
+            }
+        }
+        // a Live Photo's clip, or the first seconds of a video, converted once to H.264 (iPhone clips are HEVC, which most browsers on Windows
+        // can't play) and kept next to the previews; served with Range so the reel picker can show and seek it
+        const cm = /^\/clip\/([\w-]{4,40})\/(\d{1,6})\.mp4$/.exec(route);
+        if (cm) {
+            if (!ORIGIN_OK.test(origin)) {
+                res.statusCode = 403;
+                return res.end();
+            }
+            void clipFile(cm[1], Number(cm[2])).then((file) => {
+                if (!file) {
+                    res.statusCode = 404;
+                    return res.end();
+                }
+                ranged(file);
+            }).catch(() => { res.statusCode = 500; res.end(); });
+            return;
+        }
+        // search a sort by meaning ("tennis skirt"): the words against every picture's kept embedding, best first; nothing is read again
+        const sm = /^\/plan\/([\w-]{4,40})\/search$/.exec(route);
+        if (sm) {
+            if (!ORIGIN_OK.test(origin)) {
+                res.statusCode = 403;
+                return res.end();
+            }
+            const q = (new URL(req.url || "", "http://x").searchParams.get("q") || "").trim().slice(0, 80);
+            res.setHeader("Content-Type", "application/json");
+            void searchPlan(sm[1], q).then((r) => res.end(JSON.stringify(r))).catch((e) => res.end(JSON.stringify({ q, items: [], error: e.message })));
+            return;
+        }
+        const pm = /^\/plan\/([\w-]{4,40})\/items$/.exec(route);
+        if (pm) {
+            if (!ORIGIN_OK.test(origin)) {
+                res.statusCode = 403;
+                return res.end();
+            }
+            try {
+                const plan = readPlan(pm[1]);
+                const where = new Map();
+                for (const b of plan.buckets)
+                    if (b.kind !== "duplicates")
+                        for (const i of b.items)
+                            where.set(i, b);
+                const rows = [...where.entries()].filter(([i]) => plan.items[i]?.thumb).map(([i, b]) => {
+                    const it = plan.items[i];
+                    return { i, bucket: b.name, media: b.media ?? null, key: (0, organize_js_1.bucketKey)(b), tags: it.tags ?? [], month: it.month ?? null, live: !!it.live, kind: it.kind, file: path_1.default.basename(it.rel), dir: (path_1.default.dirname(it.rel) === "." ? "" : path_1.default.dirname(it.rel)).split(path_1.default.sep).join("/"), clip: !!it.live || it.kind === "video" };
+                });
+                res.setHeader("Content-Type", "application/json");
+                return res.end(JSON.stringify({ plan: plan.id, root: path_1.default.basename(plan.root), items: rows }));
+            }
+            catch {
+                res.statusCode = 404;
+                return res.end();
+            }
+        }
+        if (route === "/pick-folder") { // only ViralSpin's own pages may ask for the window (a page with no allowed Origin gets nothing)
+            if (!ORIGIN_OK.test(origin)) {
+                res.statusCode = 403;
+                return res.end();
+            }
+            void pickFolder().then((p) => { res.setHeader("Content-Type", "application/json"); res.end(JSON.stringify({ path: p })); });
+            return;
+        }
+        // the picture itself at screen size (up to PREVIEW_W px wide), made once from the original and kept next to the previews; for a clip, a frame
+        // about a second in (what the viewer shows before it plays). 404 for a file that is gone, and the page falls back to the small preview
+        const pv = /^\/photo\/([\w-]{4,40})\/(\d{1,6})\.jpg$/.exec(route);
+        if (pv) {
+            if (!ORIGIN_OK.test(origin)) {
+                res.statusCode = 403;
+                return res.end();
+            }
+            void (async () => {
+                try {
+                    const plan = readPlan(pv[1]);
+                    const it = plan.items?.[Number(pv[2])];
+                    const src = it && (it.kind === "image" || it.kind === "video") ? path_1.default.join(plan.root, it.rel) : null;
+                    if (!src || !fs_1.default.existsSync(src)) {
+                        res.statusCode = 404;
+                        return res.end();
+                    }
+                    const dir = path_1.default.join(organize_js_1.STATE_DIR, `${pv[1]}-photos2400`), out = path_1.default.join(dir, `${pv[2]}.jpg`); // a new folder: the old one holds 1600 px copies
+                    if (!(fs_1.default.existsSync(out) && fs_1.default.statSync(out).size > 0)) {
+                        fs_1.default.mkdirSync(dir, { recursive: true });
+                        if (!(await (0, images_js_1.makePreview)(src, out, it.kind))) {
+                            res.statusCode = 404;
+                            return res.end();
+                        }
+                    }
+                    res.setHeader("Content-Type", "image/jpeg");
+                    res.setHeader("Cache-Control", "private, max-age=3600");
+                    fs_1.default.createReadStream(out).pipe(res);
+                }
+                catch {
+                    res.statusCode = 404;
+                    res.end();
+                }
+            })();
+            return;
+        }
+        // one file's details for the viewer: name, folder, size, dates, pixel size, a clip's length (GET /meta/<plan>/<i>)
+        const mm = /^\/meta\/([\w-]{4,40})\/(\d{1,6})$/.exec(route);
+        if (mm) {
+            if (!ORIGIN_OK.test(origin)) {
+                res.statusCode = 403;
+                return res.end();
+            }
+            void (async () => {
+                try {
+                    const plan = readPlan(mm[1]);
+                    const it = plan.items?.[Number(mm[2])];
+                    const src = it ? path_1.default.join(plan.root, it.rel) : null;
+                    if (!it || !src || !fs_1.default.existsSync(src)) {
+                        res.statusCode = 404;
+                        return res.end();
+                    }
+                    const st = fs_1.default.statSync(src), px = await (0, images_js_1.fileMeta)(src, it.kind);
+                    res.setHeader("Content-Type", "application/json");
+                    res.end(JSON.stringify({ file: path_1.default.basename(it.rel), dir: path_1.default.dirname(it.rel) === "." ? "" : path_1.default.dirname(it.rel).split(path_1.default.sep).join("/"), root: plan.root, kind: it.kind, live: !!it.live, size: st.size, modified: st.mtime.toISOString(), month: it.month ?? null, tags: it.tags ?? [], ...px }));
+                }
+                catch {
+                    res.statusCode = 404;
+                    res.end();
+                }
+            })();
+            return;
+        }
+        // the original file itself, for zooming in to its real pixels: only formats every browser can show (a HEIC or RAW gets 404 and the viewer
+        // stays on /photo); served from this computer to this computer, nothing is uploaded
+        const om = /^\/original\/([\w-]{4,40})\/(\d{1,6})$/.exec(route);
+        if (om) {
+            if (!ORIGIN_OK.test(origin)) {
+                res.statusCode = 403;
+                return res.end();
+            }
+            try {
+                const plan = readPlan(om[1]);
+                const it = plan.items?.[Number(om[2])];
+                const src = it && it.kind === "image" ? path_1.default.join(plan.root, it.rel) : null;
+                const type = src ? { ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".png": "image/png", ".webp": "image/webp", ".gif": "image/gif" }[path_1.default.extname(src).toLowerCase()] : undefined;
+                if (!src || !type || !fs_1.default.existsSync(src)) {
+                    res.statusCode = 404;
+                    return res.end();
+                }
+                res.setHeader("Content-Type", type);
+                res.setHeader("Cache-Control", "private, max-age=3600");
+                return void fs_1.default.createReadStream(src).pipe(res);
+            }
+            catch {
+                res.statusCode = 404;
+                return res.end();
+            }
+        }
+        const m = /^\/thumb\/([\w-]{4,40})\/(\d{1,6})\.jpg$/.exec((req.url || "").split("?")[0]);
+        if (!m) {
+            res.statusCode = 404;
+            return res.end();
+        }
+        try {
+            const plan = readPlan(m[1]);
+            const t = plan.items?.[Number(m[2])]?.thumb;
+            if (!t || !fs_1.default.existsSync(t)) {
+                res.statusCode = 404;
+                return res.end();
+            }
+            res.setHeader("Content-Type", "image/jpeg");
+            res.setHeader("Cache-Control", "private, max-age=3600");
+            fs_1.default.createReadStream(t).pipe(res);
+        }
+        catch {
+            res.statusCode = 404;
+            res.end();
+        }
+    });
+    return new Promise((resolve, reject) => {
+        let port = exports.THUMB_PORT;
+        const tryListen = () => server.listen(port, "127.0.0.1");
+        server.on("error", (e) => { if (e.code === "EADDRINUSE" && port < exports.THUMB_PORT + 5) {
+            port++;
+            tryListen();
+        }
+        else
+            reject(e); });
+        server.on("listening", () => { warmFolderPicker(); log(`[organize] thumbnails are served to ViralSpin on 127.0.0.1:${port} (this computer only)`); resolve(port); });
+        tryListen();
+    });
+}
+/** The pictures of a sort that best match some words, best first: the closest and anything nearly as close (up to 200). */
+async function searchPlan(planId, q) {
+    if (!q)
+        return { q, items: [] };
+    const plan = readPlan(planId);
+    const ef = (0, exports.embFile)(planId);
+    if (!fs_1.default.existsSync(ef))
+        return { q, items: [], error: "This sort has no picture fingerprints yet. Make one change to it first (add a label), then search." };
+    // a word the vocabulary knows keeps its descriptive prompt ("tennis" -> "a person playing tennis or a tennis court")
+    const p = (0, topics_js_1.labelSet)([q]).prompts[0] ?? q;
+    const T = await (0, topics_js_1.textEmbeddings)({ prompts: [p], names: [q], groups: [q], custom: new Set([q]) });
+    if (!T)
+        return { q, items: [], error: "The picture model is not available on this computer." };
+    const t = T[0], d = t.length;
+    const raw = fs_1.default.readFileSync(ef);
+    const E = new Float32Array(raw.buffer, raw.byteOffset, Math.floor(raw.byteLength / 4));
+    const where = new Map();
+    for (const b of plan.buckets)
+        if (b.kind !== "duplicates")
+            for (const i of b.items)
+                where.set(i, b);
+    const scored = [];
+    plan.items.forEach((it, i) => {
+        if (!it.thumb || it.dupOf !== undefined || (i + 1) * d > E.length || !where.has(i))
+            return;
+        let s = 0;
+        for (let k = 0; k < d; k++)
+            s += E[i * d + k] * t[k];
+        if (s)
+            scored.push({ i, s });
+    });
+    scored.sort((a, b) => b.s - a.s);
+    const top = scored[0]?.s ?? 0;
+    const keep = scored.filter((x, k) => k < 12 || (x.s >= top - 0.035 && x.s >= 0.22)).slice(0, 200);
+    return { q, items: keep.map(({ i, s }) => { const it = plan.items[i], b = where.get(i); return { i, score: Math.round(s * 1000) / 1000, bucket: b.name, media: b.media ?? null, month: it.month ?? null, file: path_1.default.basename(it.rel), clip: !!it.live || it.kind === "video" }; }) };
+}
+/** What the web page gets back for a plan: totals, the move preview and each bucket with a sample of previews. */
+function resultOf(plan, port) {
+    return {
+        totals: { ...plan.totals, live: plan.items.filter((it) => it.live).length }, by: plan.by, port, thumbs: true, root: path_1.default.basename(plan.root), labels: (0, edit_js_1.labelsAfter)(plan.labels ?? [], plan.ops ?? []),
+        preview: { moves: plan.moves.length, into: path_1.default.join(plan.root, "_Organized"), sample: plan.moves.slice(0, 8).map((m) => ({ from: path_1.default.relative(plan.root, m.from), to: path_1.default.relative(plan.root, m.to) })) },
+        buckets: plan.buckets.map((b) => ({ name: b.name, kind: b.kind, media: b.media ?? null, count: b.items.length, sample: b.items.filter((i) => plan.items[i].thumb).slice(0, 40) })),
+    };
+}
+const embFile = (id) => (0, organize_js_1.planFile)(id).replace(/\.json$/, ".emb");
+exports.embFile = embFile;
+async function runJob(d, base, job, port) {
+    const patch = (b) => d.req("PATCH", `${base}/v1/organize/jobs/${job.id}`, b);
+    fs_1.default.mkdirSync(organize_js_1.STATE_DIR, { recursive: true });
+    const tmp = Date.now().toString(36);
+    let last = 0;
+    // ONE PROGRESS WRITE AT A TIME, at most every 2 s. They were fired every 0.9 s without waiting, so when the database slowed they piled up
+    // into a stream of 504s on the same row and made it slower still (2026-10-31).
+    let inFlight = false;
+    try {
+        if (!(await (0, images_js_1.canReadPictures)()))
+            throw new Error("This computer can't read pictures yet (no image library or ffmpeg). Reinstall the ViralSpin connector.");
+        live.job = job.id;
+        live.thumbs = [];
+        live.at = new Map();
+        live.cards = [];
+        const plan = await (0, scan_js_1.organizeScan)(job.folder, {
+            onThumb: (f) => { live.at.set(Number(path_1.default.basename(f, ".jpg")), live.thumbs.length); live.thumbs.push(f); },
+            onLabel: (i, card) => { const n = live.at.get(i); if (n !== undefined)
+                live.cards.push([n, card]); }, by: job.by, vision: job.vision, labels: job.labels ?? [], embFile: path_1.default.join(organize_js_1.STATE_DIR, `${tmp}.emb`), thumbs: path_1.default.join(organize_js_1.STATE_DIR, `${tmp}-thumbs`), onProgress: (p) => {
+                if (p.phase !== "done" && (inFlight || Date.now() - last < 2000))
+                    return;
+                last = Date.now();
+                inFlight = true;
+                void patch({ phase: p.phase, done: p.done ?? 0, total: p.total ?? 0, eta_ms: p.etaMs ?? 0, ...(p.phase === "found" ? { files_found: p.total ?? 0 } : {}) }).catch(() => { }).finally(() => { inFlight = false; });
+            }
+        });
+        fs_1.default.writeFileSync((0, organize_js_1.planFile)(plan.id), JSON.stringify(plan));
+        try {
+            fs_1.default.renameSync(path_1.default.join(organize_js_1.STATE_DIR, `${tmp}.emb`), (0, exports.embFile)(plan.id));
+        }
+        catch { /* sorted by folder or month: no embeddings */ }
+        const result = resultOf(plan, port);
+        await patch({ status: "done", plan_id: plan.id, result });
+        d.log(`[organize] sorted ${plan.totals.files} file(s) from ${job.folder} into ${plan.buckets.length} bucket(s)`);
+    }
+    catch (e) {
+        await patch({ status: "failed", error: e.message }).catch(() => { });
+        d.log(`[organize] ${job.folder} failed: ${e.message}`);
+    }
+}
+/** One pass: take a pending job, or do the My Story upload a done job asked for. Returns whether it did anything. */
+async function organizeTick(d, base, port) {
+    const { jobs } = await d.req("GET", `${base}/v1/organize/jobs`);
+    const pending = jobs.find((j) => j.status === "pending");
+    if (pending) {
+        try {
+            await d.req("PATCH", `${base}/v1/organize/jobs/${pending.id}`, { claim: true });
+        }
+        catch {
+            return false;
+        } // another computer took it
+        d.log(`[organize] sorting ${pending.folder}`);
+        await runJob(d, base, pending, port);
+        return true;
+    }
+    const edit = jobs.find((j) => j.status === "done" && j.plan_id && Array.isArray(j.pending_ops) && j.pending_ops.length);
+    if (edit) {
+        const patch = (b) => d.req("PATCH", `${base}/v1/organize/jobs/${edit.id}`, b);
+        try {
+            let last = 0;
+            const { plan, note } = await (0, edit_js_1.applyOps)((0, organize_js_1.planFile)(edit.plan_id), (0, exports.embFile)(edit.plan_id), edit.pending_ops, (done, total, etaMs) => {
+                if (Date.now() - last < 3000 && done < total)
+                    return;
+                last = Date.now();
+                void patch({ phase: "relabel", done, total, eta_ms: etaMs }).catch(() => { });
+            });
+            await patch({ result: resultOf(plan, port), pending_ops: [], ops_note: note, plan_id: plan.id });
+            d.log(`[organize] ${note}`);
+        }
+        catch (e) {
+            await patch({ pending_ops: [], ops_note: e.message }).catch(() => { });
+            d.log(`[organize] change failed: ${e.message}`);
+        }
+        return true;
+    }
+    const story = jobs.find((j) => j.status === "done" && j.want_story && !j.story_status && j.plan_id);
+    if (story) {
+        const patch = (b) => d.req("PATCH", `${base}/v1/organize/jobs/${story.id}`, b);
+        await patch({ story_status: "running" });
+        try {
+            let last = 0;
+            await (0, organize_js_1.addPlanToStory)((0, organize_js_1.planFile)(story.plan_id), { post: (ep, b) => d.req("POST", base + ep, b) }, (done, total) => {
+                if (Date.now() - last < 2000 && done < total)
+                    return;
+                last = Date.now();
+                void patch({ phase: "story", done, total }).catch(() => { });
+            }, story.story_buckets);
+            await patch({ story_status: "done" });
+            d.log(`[organize] added ${story.folder} to My Story`);
+        }
+        catch (e) {
+            await patch({ story_status: "failed", error: e.message }).catch(() => { });
+            d.log(`[organize] My Story upload failed: ${e.message}`);
+        }
+        return true;
+    }
+    const move = jobs.find((j) => j.status === "done" && j.plan_id && ((j.want_apply && !j.apply_status) || (j.want_undo && j.apply_status === "applied")));
+    if (move) {
+        const patch = (b) => d.req("PATCH", `${base}/v1/organize/jobs/${move.id}`, b);
+        const undo = move.want_undo && move.apply_status === "applied";
+        await patch({ apply_status: "running" });
+        try {
+            const plan = JSON.parse(fs_1.default.readFileSync((0, organize_js_1.planFile)(move.plan_id), "utf8"));
+            if (undo) {
+                const r = (0, plan_js_1.undoMoves)(path_1.default.join(plan.root, "_Organized", `.viralspin-undo-${plan.id}.json`));
+                await patch({ apply_status: "undone", apply_result: { restored: r.restored, left: r.left } });
+                d.log(`[organize] put back ${r.restored} file(s) in ${move.folder}`);
+            }
+            else {
+                const r = (0, plan_js_1.applyMoves)(plan.root, plan.moves, plan.id);
+                await patch({ apply_status: "applied", apply_result: { moved: r.moved, skipped: r.skipped } });
+                d.log(`[organize] moved ${r.moved} file(s) in ${move.folder} (undo is one click in the app)`);
+            }
+        }
+        catch (e) {
+            await patch({ apply_status: "failed", error: e.message }).catch(() => { });
+            d.log(`[organize] move failed: ${e.message}`);
+        }
+        return true;
+    }
+    return false;
+}
+/** Runs beside the render watch loop until aborted. Asks every 4 s (the web app is waiting on it), a little slower after errors. */
+async function organizeLoop(d, base, signal) {
+    let port = 0;
+    try {
+        port = await startThumbServer(d.log);
+    }
+    catch (e) {
+        d.log(`[organize] no thumbnail server (${e.message}); sorting still works, the web page will show placeholders`);
+    }
+    let errors = 0;
+    let idle = 0;
+    while (!signal.aborted) {
+        let did = false;
+        try {
+            did = await organizeTick(d, base, port);
+            errors = 0;
+        }
+        catch (e) {
+            if (errors++ === 0)
+                d.log(`[organize] ${e.message}`);
+        }
+        idle = did ? 0 : idle + 1;
+        await new Promise((r) => setTimeout(r, organizeDelay(did, idle, errors)));
+    }
+}
+/** 4 s while sorting is going on, easing to 12 s after about a minute with nothing asked (a new sort is still picked up within 12 s); much longer
+ *  while ViralSpin is unreachable. Every 4 s around the clock was ~21,600 requests a day per computer, each one a database read. */
+function organizeDelay(did, idle, errors) {
+    if (did)
+        return 500;
+    if (errors)
+        return Math.min(60000, 4000 * 2 ** Math.min(errors, 4));
+    return Math.min(12000, 4000 + Math.max(0, idle - 15) * 1000);
+}