@viralspin/mcp 0.5.3 → 0.5.5

package/dist/organize-watch.js

@@ -22,6 +22,7 @@ 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 phoneReceive_1 = require("./phoneReceive");
 const path_1 = __importDefault(require("path"));
 const organize_js_1 = require("./tools/organize.js");
 const plan_js_1 = require("./organizer/plan.js");
@@ -233,6 +234,39 @@ function startThumbServer(log) {
             res.setHeader("Cache-Control", "private, max-age=3600");
             return void fs_1.default.createReadStream(f).pipe(res);
         }
+        // receiving from an iPhone over the home network (phoneReceive.ts): the page starts, watches and stops it; the phone talks to the LAN server
+        if (route === "/receive/status") {
+            if (!ORIGIN_OK.test(origin)) {
+                res.statusCode = 403;
+                return res.end();
+            }
+            res.setHeader("Content-Type", "application/json");
+            return res.end(JSON.stringify({ ...(0, phoneReceive_1.receiveStatus)(), defaultDest: (0, phoneReceive_1.defaultDest)() }));
+        }
+        if (route === "/receive/start" || route === "/receive/stop") {
+            if (req.method !== "POST" || !ORIGIN_OK.test(origin)) {
+                res.statusCode = 403;
+                return res.end();
+            }
+            if (route === "/receive/stop") {
+                (0, phoneReceive_1.stopReceive)();
+                res.setHeader("Content-Type", "application/json");
+                return res.end(JSON.stringify((0, phoneReceive_1.receiveStatus)()));
+            }
+            let raw = "";
+            req.on("data", (c) => { raw += c; if (raw.length > 10000)
+                req.destroy(); });
+            req.on("end", () => {
+                let dest;
+                try {
+                    dest = JSON.parse(raw || "{}").dest;
+                }
+                catch { /* the default folder */ }
+                (0, phoneReceive_1.startReceive)(dest, log).then((st) => { res.setHeader("Content-Type", "application/json"); res.end(JSON.stringify(st)); })
+                    .catch((e) => { res.statusCode = 500; res.setHeader("Content-Type", "application/json"); res.end(JSON.stringify({ error: e.message })); });
+            });
+            return;
+        }
         if (route === "/ping") {
             res.setHeader("Content-Type", "application/json");
             return res.end(JSON.stringify({ ok: true, items: 1 }));
@@ -672,6 +706,10 @@ async function organizeLoop(d, base, signal) {
     catch (e) {
         d.log(`[organize] no thumbnail server (${e.message}); sorting still works, the web page will show placeholders`);
     }
+    // "Send to my computer" from the iPhone (phoneReceive.ts): on the Wi-Fi for as long as the connector runs; finished files are recorded on
+    // their My Story rows (the preview row the phone's Add to My Story made), so the web knows where each original now is
+    void (0, phoneReceive_1.startLanReceiver)({ log: d.log, register: (planId, files) => d.req("POST", `${base}/v1/library/organized/local`, { plan_id: planId, device: os_1.default.hostname(), files }).then(() => undefined) })
+        .catch((e) => d.log(`[receive] not listening on the network (${e.message}); "Send to my computer" won't find this computer`));
     let errors = 0;
     let idle = 0;
     while (!signal.aborted) {

package/dist/organizer/edit.js

@@ -17,6 +17,8 @@ const plan_1 = require("./plan");
 const path_1 = __importDefault(require("path"));
 const images_1 = require("./images");
 const topics_1 = require("./topics");
+const images_2 = require("./images");
+const phoneTopics_1 = require("./phoneTopics");
 const same = (a, b) => a.trim().toLowerCase() === b.trim().toLowerCase();
 /** The creator's labels after the ops: the ones the sort started with, plus added ones, minus removed ones. */
 function labelsAfter(start, ops) {
@@ -33,6 +35,15 @@ function labelsAfter(start, ops) {
 function regroup(plan, ops) {
     for (const o of ops) {
         const out = o.op === "exclude" ? new Set(o.items) : null;
+        // the phone's topics, as the pictures they matched: those pictures take that topic (a later merge / rename / hide still applies to it)
+        if (o.op === "assign") {
+            for (const [i, t] of o.items) {
+                const it = plan.items[i];
+                if (it && it.dupOf === undefined)
+                    it.topic = t;
+            }
+            continue;
+        }
         plan.items.forEach((it, i) => {
             if (!it.topic)
                 return;
@@ -83,10 +94,35 @@ async function backfillEmbeddings(plan, embPath, onProgress) {
     }
     fs_1.default.writeFileSync(embPath, Buffer.from((buf ?? new Float32Array(0)).buffer));
 }
+/**
+ * Every picture's fingerprint for matching the phone's: the one the scan kept, else (a HEIC sharp can't read, mostly) one made from the small
+ * preview the sort already saved on this computer. Videos and duplicates get none. Previews made here are kept on the item for next time.
+ */
+async function pictureHashes(plan) {
+    const out = plan.items.map((it) => (it.kind === "image" && it.dupOf === undefined ? it.dhash : undefined));
+    const missing = plan.items.map((it, i) => i).filter((i) => plan.items[i].kind === "image" && plan.items[i].dupOf === undefined && !out[i] && plan.items[i].thumb && fs_1.default.existsSync(plan.items[i].thumb));
+    for (const i of missing) {
+        const h = await (0, images_2.dhash)(plan.items[i].thumb).catch(() => null);
+        if (h) {
+            out[i] = h;
+            plan.items[i].dhash = h;
+        }
+    }
+    return out;
+}
 async function applyOps(planPath, embPath, add, onProgress) {
     const plan = JSON.parse(fs_1.default.readFileSync(planPath, "utf8"));
     if (plan.by !== "topic")
         throw new Error("Changing folders needs a sort By topic.");
+    // the phone's topics arrive as fingerprints: match them against this sort's pictures once, and keep only what matched
+    const filed = new Map();
+    add = await Promise.all(add.map(async (o) => {
+        if (o.op !== "phone_topics")
+            return o;
+        const m = (0, phoneTopics_1.matchPhoneTopics)(await pictureHashes(plan), o.rows ?? []);
+        filed.set(o.source ?? "iPhone", m);
+        return { op: "assign", items: [...m.entries()], source: o.source ?? "iPhone" };
+    }));
     const ops = [...(plan.ops ?? []), ...add];
     const before = new Map();
     for (const it of plan.items)
@@ -141,6 +177,10 @@ async function applyOps(planPath, embPath, add, onProgress) {
             lines.push(`Renamed ${o.from} to ${o.to}`);
         if (o.op === "exclude")
             lines.push(`Took ${o.items.length} out of ${o.bucket}`);
+        if (o.op === "assign") {
+            const m = filed.get(o.source ?? "iPhone");
+            lines.push(o.items.length ? `Filed ${o.items.length.toLocaleString()} pictures under your ${o.source ?? "iPhone"}'s topics${m ? `: ${(0, phoneTopics_1.sayTopics)(m)}` : ""}` : `None of these pictures are in your ${o.source ?? "iPhone"}'s sort`);
+        }
         if (o.op === "hide")
             lines.push(`Hid ${o.bucket} (${(before.get(o.bucket) ?? 0).toLocaleString()} pictures stay on your computer)`);
     }

package/dist/organizer/phoneTopics.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NEAR = void 0;
+exports.matchPhoneTopics = matchPhoneTopics;
+exports.sayTopics = sayTopics;
+/**
+ * FILE THIS COMPUTER'S COPIES UNDER THE PHONE'S TOPICS. The iPhone app sorts the phone's library into topics and (opt-in) sends a small
+ * preview + topic per picture to My Story; the server fingerprints each preview (organized_assets.fp, the same 64-bit difference hash this
+ * organizer keeps per picture as `dhash`). Most people's phone photos are ALSO on their computer (an iCloud folder, an old backup, a camera
+ * roll dump), so a sort of that folder can take the phone's topics for the pictures it shares with the phone: no upload, nothing copied.
+ *
+ * A computer picture takes a phone topic when its hash is within NEAR bits of a phone picture's, the closest one winning. Videos are left
+ * alone (the phone sorts photos), and so are flat pictures (nearly every bit the same: a blank, dark or one-colour frame looks like any other).
+ * Candidates are found through the hash's four 16-bit quarters (two hashes within 3 bits always share one; 4 usually do), so 15k pictures
+ * against 5k phone rows is a few thousand comparisons, not 75 million.
+ */
+const plan_1 = require("./plan");
+exports.NEAR = 4;
+const usable = (h) => !!h && /^[0-9a-f]{16}$/i.test(h);
+const flat = (h) => { const n = (0, plan_1.hamming)(h.toLowerCase(), "0000000000000000"); return n < 6 || n > 58; };
+/**
+ * For each computer picture (by index) with a hash, the phone topic it takes, or nothing. `hashes[i]` is picture i's hash (undefined for a
+ * video, a duplicate, or a picture that could not be read). Pure.
+ */
+function matchPhoneTopics(hashes, rows) {
+    const bands = new Map();
+    const phone = rows.filter((r) => usable(r.fp) && !flat(r.fp) && r.topic && r.topic.trim()).map((r) => ({ fp: r.fp.toLowerCase(), topic: r.topic.trim() }));
+    phone.forEach((r, k) => {
+        for (let b = 0; b < 4; b++) {
+            const key = `${b}${r.fp.slice(b * 4, b * 4 + 4)}`;
+            const l = bands.get(key);
+            if (l)
+                l.push(k);
+            else
+                bands.set(key, [k]);
+        }
+    });
+    const out = new Map();
+    hashes.forEach((h, i) => {
+        if (!usable(h) || flat(h))
+            return;
+        const hh = h.toLowerCase();
+        let best = exports.NEAR + 1, topic = null;
+        const seen = new Set();
+        for (let b = 0; b < 4; b++) {
+            for (const k of bands.get(`${b}${hh.slice(b * 4, b * 4 + 4)}`) ?? []) {
+                if (seen.has(k))
+                    continue;
+                seen.add(k);
+                const d = (0, plan_1.hamming)(hh, phone[k].fp);
+                if (d < best) {
+                    best = d;
+                    topic = phone[k].topic;
+                }
+            }
+        }
+        if (topic)
+            out.set(i, topic);
+    });
+    return out;
+}
+/** "Beach 220 · Family 140 · Tennis 38 · 4 more" for the note the app shows after the change. */
+function sayTopics(m) {
+    const n = new Map();
+    for (const t of m.values())
+        n.set(t, (n.get(t) ?? 0) + 1);
+    const top = [...n.entries()].sort((a, b) => b[1] - a[1]);
+    const shown = top.slice(0, 4).map(([t, c]) => `${t} ${c.toLocaleString()}`).join(" · ");
+    return top.length > 4 ? `${shown} · ${top.length - 4} more` : shown;
+}

package/dist/phoneReceive.js

@@ -0,0 +1,288 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stopReceive = exports.startReceive = exports.defaultDest = exports.RECEIVE_PORT = void 0;
+exports.isPrivate = isPrivate;
+exports.safePart = safePart;
+exports.freePath = freePath;
+exports.lanAddresses = lanAddresses;
+exports.receiveRoot = receiveRoot;
+exports.receiveStatus = receiveStatus;
+exports.setReceiveRoot = setReceiveRoot;
+exports.startLanReceiver = startLanReceiver;
+exports.stopLanReceiver = stopLanReceiver;
+/**
+ * SEND TO MY COMPUTER — the PC end. The iPhone app (Album Sorter ▸ results ▸ "Send to my computer", ComputerSender.swift) finds this computer on
+ * the Wi-Fi over Bonjour (`_viralspin._tcp`), pairs with the 4-digit code shown here and on the web, and sends the ORIGINALS of the ticked groups
+ * into <root>/From iPhone/<Group>/<filename>. Nothing goes through ViralSpin's servers. Protocol (docs/web-parity/MAC-WEB-CHAT.md 2026-11-03
+ * 21:30 / 23:05 and 2026-11-04; the Mac's reference is ViralSpinMobile/qa/demo/receive.py):
+ *
+ *   POST /pair                    {code, device, plan_id}                                  → {token, name} | 403
+ *   POST /receive/manifest        {plan_id, groups:[{name, items:[{rel, filename, bytes, kind}]}]}
+ *   PUT  /receive/file/{plan}/{rel}?part=photo|video|live&filename=&group=   body = the file → {rel, part, bytes, sha256}
+ *   POST /receive/done/{plan}                                                           → {received:[{rel, bytes, sha256, parts}], missing:[rel]}
+ *
+ * The sha256 is of the file AS WRITTEN (read back from disk), because the phone only offers "Free up space" for files whose hash matches what it
+ * read. A file never overwrites another (`name (2).ext`). Only private-network addresses are answered; a token comes only from the code, and the
+ * code changes after 5 wrong tries. When a batch is done the connector records each full file on its organized_assets row (`register`), so the
+ * row behind the phone's preview in My Story knows where the original now is.
+ */
+const http_1 = __importDefault(require("http"));
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const crypto_1 = __importDefault(require("crypto"));
+exports.RECEIVE_PORT = 47840;
+/** Is this a private / local address (the only ones answered)? */
+function isPrivate(ip) {
+    const v = ip.replace(/^::ffff:/, "");
+    if (v === "127.0.0.1" || v === "::1")
+        return true;
+    const m = /^(\d+)\.(\d+)\.\d+\.\d+$/.exec(v);
+    if (m) {
+        const a = +m[1], b = +m[2];
+        return a === 10 || (a === 172 && b >= 16 && b <= 31) || (a === 192 && b === 168) || (a === 169 && b === 254);
+    }
+    return /^fe80:/i.test(v) || /^f[cd][0-9a-f]{2}:/i.test(v);
+}
+/** A group or file name as one safe path part: no separators, no characters Windows refuses, no leading dots, no trailing dot/space, never empty. */
+function safePart(s, fallback) {
+    const t = String(s ?? "").normalize("NFC").replace(/[\\/:*?"<>|\x00-\x1f]/g, " ").replace(/\s+/g, " ").replace(/^[.\s]+|[.\s]+$/g, "").slice(0, 120);
+    return t && t !== "." && t !== ".." ? t : fallback;
+}
+/** A path for this file in this folder that does not exist yet: name.ext, then "name (2).ext", "name (3).ext"… */
+function freePath(folder, filename) {
+    const ext = path_1.default.extname(filename), base = filename.slice(0, filename.length - ext.length);
+    let p = path_1.default.join(folder, filename);
+    for (let k = 2; fs_1.default.existsSync(p) || fs_1.default.existsSync(`${p}.part`); k++)
+        p = path_1.default.join(folder, `${base} (${k})${ext}`);
+    return p;
+}
+/** This computer's addresses a phone on the same Wi-Fi can reach (private IPv4s, no virtual adapters). */
+function lanAddresses() {
+    const out = [];
+    for (const [name, addrs] of Object.entries(os_1.default.networkInterfaces())) {
+        if (/vEthernet|VirtualBox|VMware|WSL|Hyper-V|docker|utun|tailscale|ZeroTier/i.test(name))
+            continue;
+        for (const a of addrs ?? [])
+            if (a.family === "IPv4" && !a.internal && isPrivate(a.address))
+                out.push(a.address);
+    }
+    return [...new Set(out)];
+}
+const STATE = path_1.default.join(os_1.default.homedir(), ".viralspin", "organize");
+/** Where received files go: the folder the creator chose, else the newest sort's folder on this computer, else ~/Pictures/ViralSpin. */
+function receiveRoot() {
+    if (rootOverride)
+        return rootOverride;
+    try {
+        const plans = fs_1.default.readdirSync(STATE).filter((f) => /^[\w-]{4,40}\.json$/.test(f)).map((f) => ({ f, t: fs_1.default.statSync(path_1.default.join(STATE, f)).mtimeMs })).sort((a, b) => b.t - a.t);
+        for (const { f } of plans) {
+            const root = JSON.parse(fs_1.default.readFileSync(path_1.default.join(STATE, f), "utf8")).root;
+            if (root && fs_1.default.existsSync(root))
+                return root;
+        }
+    }
+    catch { /* no sorts yet */ }
+    return path_1.default.join(os_1.default.homedir(), "Pictures", "ViralSpin");
+}
+exports.defaultDest = receiveRoot;
+const friendlyName = () => process.env.VIRALSPIN_PC_NAME || `${(os_1.default.userInfo().username || "My").replace(/^./, (c) => c.toUpperCase())}'s ${process.platform === "darwin" ? "Mac" : "PC"}`;
+const newCode = () => String(crypto_1.default.randomInt(0, 10000)).padStart(4, "0");
+let st = null;
+let rootOverride = null;
+function receiveStatus() {
+    if (!st)
+        return { active: false, received: 0, skipped: 0, bytes: 0, dest: receiveRoot() };
+    return { active: true, name: st.name, device: st.device, code: st.code, port: st.port, hosts: lanAddresses(), dest: receiveRoot(), received: st.received, skipped: 0, bytes: st.bytes, last: st.last, phone: st.phone, paired: st.tokens.size };
+}
+/** The folder received files go into from now on (undefined = back to the newest sort's folder). */
+function setReceiveRoot(dest) {
+    rootOverride = dest && dest.trim() ? path_1.default.resolve(dest.trim()) : null;
+    if (rootOverride)
+        fs_1.default.mkdirSync(rootOverride, { recursive: true });
+    return receiveStatus();
+}
+/** Start listening on the LAN and advertise over Bonjour. Runs for as long as the connector does. */
+function startLanReceiver(o) {
+    if (st)
+        return Promise.resolve(receiveStatus());
+    const server = http_1.default.createServer((req, res) => void handle(req, res));
+    return new Promise((resolve, reject) => {
+        const first = o.port ?? exports.RECEIVE_PORT;
+        let port = first;
+        const tryListen = () => server.listen(port, "0.0.0.0");
+        server.on("error", (e) => { if (e.code === "EADDRINUSE" && port < first + 5) {
+            port++;
+            tryListen();
+        }
+        else
+            reject(e); });
+        server.on("listening", () => {
+            st = { server, port, code: newCode(), wrong: 0, tokens: new Set(), name: friendlyName(), device: os_1.default.hostname(), manifests: new Map(), got: new Map(), received: 0, bytes: 0, register: o.register, log: o.log };
+            if (o.advertise !== false) {
+                try {
+                    // eslint-disable-next-line @typescript-eslint/no-var-requires
+                    const { Bonjour } = require("bonjour-service");
+                    const b = new Bonjour();
+                    b.publish({ name: st.name, type: "viralspin", protocol: "tcp", port, txt: { name: st.name, device: st.device } });
+                    st.bonjour = b;
+                }
+                catch (e) {
+                    o.log(`[receive] not announced on the network (${e.message}); the phone can still use this computer's address`);
+                }
+            }
+            o.log(`[receive] "Send to my computer" from the iPhone: ${st.name} on ${lanAddresses().join(", ") || "this network"}:${port}, code ${st.code}, files into ${path_1.default.join(receiveRoot(), "From iPhone")}`);
+            resolve(receiveStatus());
+        });
+        tryListen();
+    });
+}
+function stopLanReceiver() {
+    if (!st)
+        return;
+    try {
+        st.bonjour?.unpublishAll();
+        st.bonjour?.destroy();
+    }
+    catch { /* already gone */ }
+    st.server.close();
+    st = null;
+}
+// the names the web's loopback routes use (organize-watch.ts)
+const startReceive = (dest, log) => { setReceiveRoot(dest); return st ? Promise.resolve(receiveStatus()) : startLanReceiver({ log }); };
+exports.startReceive = startReceive;
+const stopReceive = () => setReceiveRoot(undefined);
+exports.stopReceive = stopReceive;
+function json(res, code, body) { const b = JSON.stringify(body); res.writeHead(code, { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(b) }); res.end(b); }
+function readJson(req, max = 8000000) {
+    return new Promise((resolve) => {
+        let raw = "";
+        req.on("data", (c) => { raw += c; if (raw.length > max)
+            req.destroy(); });
+        req.on("end", () => { try {
+            resolve(JSON.parse(raw || "{}"));
+        }
+        catch {
+            resolve(null);
+        } });
+        req.on("error", () => resolve(null));
+    });
+}
+function sha256File(p) {
+    return new Promise((resolve, reject) => { const h = crypto_1.default.createHash("sha256"); fs_1.default.createReadStream(p).on("data", (c) => h.update(c)).on("end", () => resolve(h.digest("hex"))).on("error", reject); });
+}
+/** The parts a delivered item needs: a video its video, a Live Photo its photo AND its video half, a photo its photo. */
+const needs = (kind) => (kind === "video" ? ["video"] : kind === "live" ? ["photo", "live"] : ["photo"]);
+async function handle(req, res) {
+    const s = st;
+    if (!s || !isPrivate(String(req.socket.remoteAddress ?? "")))
+        return json(res, 403, { error: "not on this network" });
+    const url = new URL(req.url || "/", "http://x");
+    if (req.method === "POST" && url.pathname === "/pair") {
+        const b = await readJson(req, 10000);
+        if (!b || String(b.code ?? "").trim() !== s.code) {
+            if (++s.wrong >= 5) {
+                s.code = newCode();
+                s.wrong = 0;
+                s.log(`[receive] 5 wrong codes: the code is now ${s.code}`);
+            }
+            return json(res, 403, { error: "wrong code" });
+        }
+        const token = crypto_1.default.randomBytes(16).toString("hex");
+        s.tokens.add(token);
+        s.wrong = 0;
+        s.phone = String(b.device ?? "an iPhone").slice(0, 60);
+        s.log(`[receive] paired with ${s.phone}`);
+        return json(res, 200, { token, name: s.name });
+    }
+    const tok = String(req.headers.authorization ?? "").replace(/^Bearer\s+/i, "");
+    if (!tok || !s.tokens.has(tok))
+        return json(res, 401, { error: "pair first" });
+    if (req.method === "POST" && url.pathname === "/receive/manifest") {
+        const m = await readJson(req);
+        if (!m)
+            return json(res, 400, { error: "bad manifest" });
+        const plan = String(m.plan_id ?? "plan").replace(/[^\w-]/g, "").slice(0, 40) || "plan";
+        const items = new Map();
+        let size = 0;
+        for (const g of m.groups ?? [])
+            for (const it of g.items ?? []) {
+                items.set(String(it.rel), { group: String(g.name ?? "Group"), filename: String(it.filename ?? "file"), kind: String(it.kind ?? "image") });
+                size += Number(it.bytes) || 0;
+            }
+        s.manifests.set(plan, items);
+        s.log(`[receive] ${items.size} file(s), ${(size / 1e6).toFixed(1)} MB in ${(m.groups ?? []).length} group(s) coming from ${s.phone ?? "the iPhone"}`);
+        return json(res, 200, { ok: true });
+    }
+    const fm = /^\/receive\/file\/([^/]+)\/(.+)$/.exec(url.pathname);
+    if (req.method === "PUT" && fm) {
+        const plan = decodeURIComponent(fm[1]).replace(/[^\w-]/g, "").slice(0, 40), rel = decodeURIComponent(fm[2]);
+        const part = (url.searchParams.get("part") ?? "photo").replace(/[^a-z]/g, "") || "photo";
+        const known = s.manifests.get(plan)?.get(rel);
+        const group = safePart(url.searchParams.get("group") ?? known?.group ?? "Group", "Group");
+        const filename = safePart(url.searchParams.get("filename") ?? known?.filename ?? "file", "file");
+        const folder = path_1.default.join(receiveRoot(), "From iPhone", group);
+        fs_1.default.mkdirSync(folder, { recursive: true });
+        const to = freePath(folder, filename), tmp = `${to}.part`;
+        const out = fs_1.default.createWriteStream(tmp);
+        const done = new Promise((resolve) => { out.on("finish", () => resolve(true)); out.on("error", () => resolve(false)); req.on("aborted", () => resolve(false)); });
+        req.pipe(out);
+        if (!(await done)) {
+            out.destroy();
+            fs_1.default.rm(tmp, { force: true }, () => undefined);
+            return json(res, 500, { error: "the file did not arrive whole" });
+        }
+        try {
+            fs_1.default.renameSync(tmp, to);
+            const bytes = fs_1.default.statSync(to).size, sha256 = await sha256File(to); // AS WRITTEN: what the phone checks before offering to free up space
+            const claimed = String(req.headers["x-sha256"] ?? "").toLowerCase();
+            if (claimed && claimed !== sha256)
+                s.log(`[receive] ✗ ${group}/${path_1.default.basename(to)}: hash differs from the phone's`);
+            const rec = { rel, part, bytes, sha256, path: to };
+            const forPlan = s.got.get(plan) ?? new Map();
+            forPlan.set(rel, { ...(forPlan.get(rel) ?? {}), [part]: rec });
+            s.got.set(plan, forPlan);
+            s.received++;
+            s.bytes += bytes;
+            s.last = `${group}/${path_1.default.basename(to)}`;
+            return json(res, 200, { rel, part, bytes, sha256 });
+        }
+        catch (e) {
+            fs_1.default.rm(tmp, { force: true }, () => undefined);
+            return json(res, 500, { error: e.message });
+        }
+    }
+    const dm = /^\/receive\/done\/([^/]+)$/.exec(url.pathname);
+    if (req.method === "POST" && dm) {
+        const plan = decodeURIComponent(dm[1]).replace(/[^\w-]/g, "").slice(0, 40);
+        const want = s.manifests.get(plan) ?? new Map(), got = s.got.get(plan) ?? new Map();
+        const received = [];
+        const missing = [];
+        const summary = (parts) => Object.fromEntries(Object.entries(parts).map(([k, v]) => [k, { bytes: v.bytes, sha256: v.sha256 }]));
+        for (const [rel, info] of want) {
+            const parts = got.get(rel) ?? {};
+            if (needs(info.kind).every((p) => parts[p])) {
+                const main = parts.video ?? parts.photo;
+                received.push({ rel, bytes: main.bytes, sha256: main.sha256, parts: summary(parts) });
+            }
+            else
+                missing.push(rel);
+        }
+        for (const [rel, parts] of got)
+            if (!want.has(rel)) {
+                const main = parts.video ?? parts.photo ?? Object.values(parts)[0];
+                received.push({ rel, bytes: main.bytes, sha256: main.sha256, parts: summary(parts) });
+            }
+        s.log(`[receive] done ${plan}: ${received.length} received, ${missing.length} missing`);
+        json(res, 200, { received, missing });
+        // the full files on their My Story rows (the preview stays; the row now says where the original is)
+        const files = received.map((r) => { const p = got.get(r.rel); const main = p.video ?? p.photo ?? Object.values(p)[0]; return { rel: r.rel, path: main.path, bytes: main.bytes, sha256: main.sha256 }; });
+        if (s.register && files.length)
+            s.register(plan, files).catch((e) => s.log(`[receive] could not record them in My Story: ${e.message}`));
+        return;
+    }
+    json(res, 404, { error: "no such route" });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@viralspin/mcp",
-  "version": "0.5.3",
+  "version": "0.5.5",
   "description": "ViralSpin MCP server — publish local videos and carousels to TikTok, Instagram, and YouTube from Claude Code",
   "main": "dist/index.js",
   "bin": {
@@ -34,6 +34,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.0",
+    "bonjour-service": "^1.4.4",
     "form-data": "^4.0.0"
   },
   "devDependencies": {