@viralspin/mcp 0.5.4 → 0.5.5

package/dist/organize-watch.js

@@ -249,7 +249,7 @@ function startThumbServer(log) {
                 return res.end();
             }
             if (route === "/receive/stop") {
-                (0, phoneReceive_1.stopReceive)(log);
+                (0, phoneReceive_1.stopReceive)();
                 res.setHeader("Content-Type", "application/json");
                 return res.end(JSON.stringify((0, phoneReceive_1.receiveStatus)()));
             }
@@ -706,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/phoneReceive.js

@@ -3,25 +3,31 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RECEIVE_PORT = void 0;
-exports.lanAddresses = lanAddresses;
+exports.stopReceive = exports.startReceive = exports.defaultDest = exports.RECEIVE_PORT = void 0;
 exports.isPrivate = isPrivate;
 exports.safePart = safePart;
-exports.targetPath = targetPath;
-exports.defaultDest = defaultDest;
+exports.freePath = freePath;
+exports.lanAddresses = lanAddresses;
+exports.receiveRoot = receiveRoot;
 exports.receiveStatus = receiveStatus;
-exports.stopReceive = stopReceive;
-exports.startReceive = startReceive;
+exports.setReceiveRoot = setReceiveRoot;
+exports.startLanReceiver = startLanReceiver;
+exports.stopLanReceiver = stopLanReceiver;
 /**
- * RECEIVE FROM AN IPHONE, over the home network. The iPhone app sends the ORIGINAL photos and videos of the topics the creator ticked, straight
- * to this computer, into <folder>/<topic>/<file name>: nothing goes through ViralSpin's servers.
+ * 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):
  *
- * The web page starts a session over loopback (POST /receive/start, ViralSpin origins only, like every other loopback route). Only then does
- * this open a second, small server on the LAN (RECEIVE_PORT), which answers only:
- *   - requests carrying the session's one-time token (shown to the phone in a QR code), and
- *   - from private-network addresses (10/8, 172.16/12, 192.168/16, link-local, loopback),
- * and it closes itself after IDLE_MS without a request, or when the page stops it. A name or topic is reduced to a plain file name, so nothing
- * is ever written outside the chosen folder.
+ *   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"));
@@ -29,21 +35,7 @@ const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
 const crypto_1 = __importDefault(require("crypto"));
 exports.RECEIVE_PORT = 47840;
-const IDLE_MS = 30 * 60000;
-let session = null;
-/** This computer's addresses a phone on the same Wi-Fi can reach: private IPv4s, wired/wireless first, no virtual adapters' link-local. */
-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)];
-}
-/** Is this a private / local address (the only ones the LAN server answers)? */
+/** 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")
@@ -55,145 +47,242 @@ function isPrivate(ip) {
     }
     return /^fe80:/i.test(v) || /^f[cd][0-9a-f]{2}:/i.test(v);
 }
-/** A topic or file name as one safe path part: no separators, no "..", no characters Windows refuses, never empty. */
+/** 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); // no leading dots, no trailing dot or space (Windows)
+    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;
 }
-/** Where a file of a topic lands: <dest>/<topic>/<name>, inside dest whatever the request said. */
-function targetPath(dest, topic, name) {
-    const p = path_1.default.join(dest, safePart(topic, "Other"), safePart(name, "photo"));
-    if (!path_1.default.resolve(p).startsWith(path_1.default.resolve(dest) + path_1.default.sep))
-        throw new Error("outside the folder");
+/** 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;
 }
-function defaultDest() { return path_1.default.join(os_1.default.homedir(), "Pictures", "From iPhone"); }
-function receiveStatus() {
-    if (!session)
-        return { active: false, received: 0, skipped: 0, bytes: 0 };
-    const { dest, port, hosts, token, received, skipped, bytes, last, phone, startedAt } = session;
-    return { active: true, dest, port, hosts, token, received, skipped, bytes, last, phone, startedAt };
+/** 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)];
 }
-function stopReceive(log) {
-    if (!session)
-        return;
-    clearTimeout(session.idle);
-    session.server.close();
-    log?.(`[receive] stopped: ${session.received} file(s) received, ${session.skipped} already there`);
-    session = null;
+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");
 }
-function touch(log) {
-    if (!session)
-        return;
-    session.lastAt = Date.now();
-    clearTimeout(session.idle);
-    session.idle = setTimeout(() => stopReceive(log), IDLE_MS);
+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 (or restart into another folder) a receive session. Resolves once the LAN server listens. */
-function startReceive(destIn, log) {
-    const dest = path_1.default.resolve(destIn && destIn.trim() ? destIn.trim() : defaultDest());
-    fs_1.default.mkdirSync(dest, { recursive: true });
-    if (session && session.dest === dest) {
-        touch(log);
+/** 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());
-    }
-    stopReceive(log);
-    const token = crypto_1.default.randomBytes(12).toString("base64url");
-    const server = http_1.default.createServer((req, res) => handle(req, res, log));
+    const server = http_1.default.createServer((req, res) => void handle(req, res));
     return new Promise((resolve, reject) => {
-        let port = exports.RECEIVE_PORT;
+        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 < exports.RECEIVE_PORT + 5) {
+        server.on("error", (e) => { if (e.code === "EADDRINUSE" && port < first + 5) {
             port++;
             tryListen();
         }
         else
             reject(e); });
         server.on("listening", () => {
-            session = { token, dest, server, port, hosts: lanAddresses(), received: 0, skipped: 0, bytes: 0, lastAt: Date.now(), startedAt: Date.now(), idle: setTimeout(() => stopReceive(log), IDLE_MS) };
-            log(`[receive] waiting for an iPhone on ${session.hosts.join(", ") || "this network"}:${port}, saving into ${dest}`);
+            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 json(res, code, body) { res.statusCode = code; res.setHeader("Content-Type", "application/json"); res.end(JSON.stringify(body)); }
-function handle(req, res, log) {
-    const s = session;
-    const ip = String(req.socket.remoteAddress ?? "");
-    const url = new URL(req.url || "/", "http://x");
-    if (!s || !isPrivate(ip))
-        return json(res, 403, { error: "not receiving" });
-    const tok = url.searchParams.get("t") ?? String(req.headers["x-viralspin-token"] ?? "");
-    if (!tok || tok.length !== s.token.length || !crypto_1.default.timingSafeEqual(Buffer.from(tok), Buffer.from(s.token)))
-        return json(res, 403, { error: "wrong code" });
-    touch(log);
-    s.phone = ip.replace(/^::ffff:/, "");
-    // the phone checks it found the right computer
-    if (url.pathname === "/hello" && req.method === "GET")
-        return json(res, 200, { ok: true, computer: os_1.default.hostname(), folder: path_1.default.basename(s.dest) });
-    // which of these are here already: [{ topic, name, size? }] -> [true/false]. A file of that name in that topic (and size, when given) is skipped
-    if (url.pathname === "/have" && req.method === "POST") {
+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 > 4000000)
+        req.on("data", (c) => { raw += c; if (raw.length > max)
             req.destroy(); });
-        req.on("end", () => {
-            try {
-                const files = (JSON.parse(raw).files ?? []);
-                const have = files.slice(0, 5000).map((f) => {
-                    try {
-                        const st = fs_1.default.statSync(targetPath(s.dest, f.topic, f.name));
-                        return !f.size || st.size === f.size;
-                    }
-                    catch {
-                        return false;
-                    }
-                });
-                s.skipped += have.filter(Boolean).length;
-                json(res, 200, { have });
+        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}`);
             }
-            catch {
-                json(res, 400, { error: "bad list" });
+            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;
             }
-        });
-        return;
+        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 });
     }
-    // one file: PUT /file?topic=&name=&taken=<unix seconds>, the bytes as the body. Written to a .part file and renamed when complete
-    if (url.pathname === "/file" && req.method === "PUT") {
-        let to;
+    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 {
-            to = targetPath(s.dest, url.searchParams.get("topic") ?? "", url.searchParams.get("name") ?? "");
+            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 {
-            return json(res, 400, { error: "bad name" });
+        catch (e) {
+            fs_1.default.rm(tmp, { force: true }, () => undefined);
+            return json(res, 500, { error: e.message });
         }
-        fs_1.default.mkdirSync(path_1.default.dirname(to), { recursive: true });
-        const part = `${to}.part`;
-        const out = fs_1.default.createWriteStream(part);
-        let n = 0;
-        req.on("data", (c) => { n += c.length; });
-        req.pipe(out);
-        out.on("finish", () => {
-            try {
-                fs_1.default.renameSync(part, to);
-                const taken = Number(url.searchParams.get("taken"));
-                if (taken > 0) {
-                    const d = new Date(taken * 1000);
-                    fs_1.default.utimesSync(to, d, d);
-                } // the photo's own date, so the folder sorts by when it was taken
-                s.received++;
-                s.bytes += n;
-                s.last = path_1.default.relative(s.dest, to);
-                json(res, 200, { ok: true });
+    }
+    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) });
             }
-            catch (e) {
-                json(res, 500, { error: e.message });
+            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) });
             }
-        });
-        const fail = () => { out.destroy(); fs_1.default.rm(part, { force: true }, () => undefined); };
-        req.on("aborted", fail);
-        out.on("error", () => { fail(); json(res, 500, { error: "could not write" }); });
+        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: "unknown" });
+    json(res, 404, { error: "no such route" });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@viralspin/mcp",
-  "version": "0.5.4",
+  "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": {