Testing

package.json

@@ -1,6 +1,6 @@
 {
   "name": "waterdrop",
-  "version": "0.1.9",
+  "version": "0.1.18",
   "description": "Private AirDrop-style file shelf for Tailscale networks.",
   "main": "src/main/main.js",
   "scripts": {

src/main/main.js

@@ -127,6 +127,42 @@ async function autoPublishServe() {
   }
 }
 
+let httpsRenewTimer = null;
+
+// Stand up the direct HTTPS listener with a Tailscale-issued cert so phones can
+// open several parallel connections straight to this process. Best-effort: if
+// the tailnet has no HTTPS certs, we quietly keep using Serve. `tailscale cert`
+// reuses a still-valid cert, so re-running it is cheap and doubles as renewal.
+async function autoEnableDirectHttps() {
+  try {
+    if (!dropServer?.startHttps) return;
+    const state = await tailscale.status();
+    if (!state.running || !state.loggedIn || !state.dnsName) return;
+    const certDir = path.join(app.getPath("userData"), "certs");
+    await fs.promises.mkdir(certDir, { recursive: true });
+    const certPath = path.join(certDir, `${state.dnsName}.crt`);
+    const keyPath = path.join(certDir, `${state.dnsName}.key`);
+    const result = await tailscale.provisionCert(state.dnsName, certPath, keyPath);
+    if (!result.ok) {
+      logDiagnostic("direct https cert unavailable", result.message);
+      return;
+    }
+    const [cert, key] = await Promise.all([
+      fs.promises.readFile(certPath),
+      fs.promises.readFile(keyPath),
+    ]);
+    await dropServer.startHttps({ cert, key });
+  } catch (err) {
+    logDiagnostic("direct https enable error", err);
+  }
+}
+
+function scheduleHttpsRenewal() {
+  if (httpsRenewTimer) return;
+  httpsRenewTimer = setInterval(() => autoEnableDirectHttps(), 12 * 60 * 60 * 1000);
+  httpsRenewTimer.unref?.();
+}
+
 async function createWindow() {
   const preload = path.join(__dirname, "preload.js");
   mainWindow = new BrowserWindow({
@@ -330,6 +366,8 @@ if (gotLock) {
       Menu.setApplicationMenu(null);
       await startServer();
       autoPublishServe(); // best-effort, non-blocking: makes the QR a real phone link
+      autoEnableDirectHttps(); // best-effort: direct HTTPS unlocks full-speed parallel transfers
+      scheduleHttpsRenewal();
       applyLoginSettings();
       createTray();
       wireIpc();

src/main/tailscale.js

@@ -112,13 +112,16 @@ function findServeHandler(config, pathName = "/drop") {
   return null;
 }
 
-async function inspect(port) {
+async function inspect(port, { httpsPort } = {}) {
   const ts = await status();
   const serve = await serveStatus();
   const handler = serve.ok ? findServeHandler(serve.config, "/drop") : null;
   const serveUrl = ts.dnsName ? `https://${ts.dnsName}/drop/` : null;
   const directUrl = ts.tailnetIp ? `http://${ts.tailnetIp}:${port}/drop/` : null;
   const localUrl = `http://127.0.0.1:${port}/drop/`;
+  // Direct HTTPS to this process (own Tailscale cert). Fastest and still a secure
+  // context, so it's the preferred link whenever it's up.
+  const httpsDirectUrl = ts.dnsName && httpsPort ? `https://${ts.dnsName}:${httpsPort}/drop/` : null;
 
   return {
     ...ts,
@@ -128,12 +131,28 @@ async function inspect(port) {
     serveProxy: handler ? handler.proxy : null,
     serveUrl,
     directUrl,
+    // Advertised for the client to probe and route bulk transfers through when
+    // reachable, but NOT the QR link: a phone must be able to open the QR, and
+    // the direct port may be blocked by the Windows firewall. Serve always works.
+    httpsDirectUrl,
     localUrl,
     preferredUrl: handler && serveUrl ? serveUrl : directUrl || localUrl,
     serveCommand: `tailscale serve --bg --yes --set-path /drop http://127.0.0.1:${port}`,
   };
 }
 
+// Ask Tailscale to issue (and thereafter renew) a TLS cert for this node's
+// MagicDNS name, written to the given files. Needs HTTPS certs enabled on the
+// tailnet; best-effort — the caller falls back to Serve/local if it fails.
+async function provisionCert(dnsName, certPath, keyPath) {
+  if (!dnsName) return { ok: false, message: "No MagicDNS name" };
+  const result = await run(["cert", "--cert-file", certPath, "--key-file", keyPath, dnsName], 45000);
+  if (!result.ok) {
+    return { ok: false, message: result.message || "tailscale cert failed" };
+  }
+  return { ok: true, message: result.stdout.trim() || "cert ready" };
+}
+
 async function configureServe(port) {
   const target = `http://127.0.0.1:${port}`;
   const result = await run(["serve", "--bg", "--yes", "--set-path", "/drop", target], 15000);
@@ -147,6 +166,7 @@ module.exports = {
   configureServe,
   exePath,
   inspect,
+  provisionCert,
   run,
   serveStatus,
   status,

src/main/updater.js

@@ -45,6 +45,10 @@ function wireAutoUpdaterEvents() {
   });
 
   autoUpdater.on("error", (err) => {
+    if (isUpdateManifestNotReady(err)) {
+      send({ state: "up-to-date", message: "No update is ready yet." });
+      return;
+    }
     send({ state: "error", message: (err && err.message) || String(err) });
   });
 }
@@ -59,6 +63,16 @@ function normalizeNotes(notes) {
   return "";
 }
 
+function isUpdateManifestNotReady(err) {
+  const message = (err && err.message) || String(err);
+  const code = err && err.code;
+
+  return (
+    code === "ERR_UPDATER_CHANNEL_FILE_NOT_FOUND" ||
+    /Cannot find (latest|testing)\.yml in the latest release artifacts/i.test(message)
+  );
+}
+
 async function checkForUpdates({ silent = false } = {}) {
   if (!app.isPackaged) {
     send({ state: "dev" });
@@ -69,6 +83,10 @@ async function checkForUpdates({ silent = false } = {}) {
   try {
     await autoUpdater.checkForUpdates();
   } catch (err) {
+    if (isUpdateManifestNotReady(err)) {
+      send({ state: "up-to-date", message: "No update is ready yet." });
+      return lastStatus;
+    }
     if (!silent) send({ state: "error", message: (err && err.message) || String(err) });
   } finally {
     checkInFlight = false;

src/renderer/public/waterdrop-sw.js

@@ -53,7 +53,7 @@ async function drainUploadQueue() {
       lockedUntil: now + WORKER_LOCK_MS,
       lastError: "",
     };
-    await putUploadRecord(claimed);
+    if (!await putUploadRecord(claimed)) continue;
     broadcast({ type: "WATERDROP_UPLOAD_SYNCING", id: claimed.id });
 
     try {
@@ -79,6 +79,7 @@ async function uploadRecord(record) {
       "X-WaterDrop-File-Name": encodeURIComponent(record.name || "unnamed-file"),
       "X-WaterDrop-Mime-Type": record.mimeType || "application/octet-stream",
       "X-WaterDrop-Upload-Id": record.id,
+      ...(record.folderId ? { "X-WaterDrop-Folder-Id": record.folderId } : {}),
     },
   });
   if (!response.ok) throw new Error(`HTTP ${response.status}`);
@@ -92,19 +93,59 @@ async function broadcast(message) {
 async function listQueuedUploads() {
   const db = await openDb();
   const records = await requestAsPromise(db.transaction(STORE_NAME, "readonly").objectStore(STORE_NAME).getAll());
-  return records.sort((a, b) => Number(a.createdAt || 0) - Number(b.createdAt || 0));
+  const now = Date.now();
+  const expiredCancelledIds = [];
+  const visible = [];
+  for (const record of records) {
+    if (isCancelledUploadRecord(record, now)) continue;
+    if (isExpiredCancelledUploadRecord(record, now)) {
+      expiredCancelledIds.push(record.id);
+      continue;
+    }
+    visible.push(record);
+  }
+  if (expiredCancelledIds.length) deleteUploadRecords(expiredCancelledIds).catch(() => {});
+  return visible.sort((a, b) => Number(a.createdAt || 0) - Number(b.createdAt || 0));
 }
 
 async function putUploadRecord(record) {
   const db = await openDb();
-  await requestAsPromise(db.transaction(STORE_NAME, "readwrite").objectStore(STORE_NAME).put(record));
+  return new Promise((resolve, reject) => {
+    const transaction = db.transaction(STORE_NAME, "readwrite");
+    const store = transaction.objectStore(STORE_NAME);
+    let stored = false;
+    transaction.oncomplete = () => resolve(stored);
+    transaction.onerror = () => reject(transaction.error || new Error("IndexedDB transaction failed"));
+    transaction.onabort = () => reject(transaction.error || new Error("IndexedDB transaction aborted"));
+    const request = store.get(record.id);
+    request.onsuccess = () => {
+      if (record.status !== "cancelled" && isCancelledUploadRecord(request.result)) return;
+      store.put(record);
+      stored = true;
+    };
+    request.onerror = () => reject(request.error || new Error("IndexedDB request failed"));
+  });
 }
 
 async function deleteUploadRecord(id) {
+  const record = await getUploadRecord(id);
+  if (isCancelledUploadRecord(record)) return;
   const db = await openDb();
   await requestAsPromise(db.transaction(STORE_NAME, "readwrite").objectStore(STORE_NAME).delete(id));
 }
 
+async function deleteUploadRecords(ids) {
+  const db = await openDb();
+  await new Promise((resolve, reject) => {
+    const transaction = db.transaction(STORE_NAME, "readwrite");
+    const store = transaction.objectStore(STORE_NAME);
+    transaction.oncomplete = resolve;
+    transaction.onerror = () => reject(transaction.error || new Error("IndexedDB transaction failed"));
+    transaction.onabort = () => reject(transaction.error || new Error("IndexedDB transaction aborted"));
+    ids.forEach((id) => store.delete(id));
+  });
+}
+
 async function getUploadRecord(id) {
   const db = await openDb();
   return requestAsPromise(db.transaction(STORE_NAME, "readonly").objectStore(STORE_NAME).get(id));
@@ -113,7 +154,7 @@ async function getUploadRecord(id) {
 async function markUploadQueued(id, message, knownRecord = null) {
   const record = knownRecord || await getUploadRecord(id);
   if (!record) return;
-  await putUploadRecord({
+  const queued = await putUploadRecord({
     ...record,
     status: "queued",
     progress: 0,
@@ -122,9 +163,22 @@ async function markUploadQueued(id, message, knownRecord = null) {
     lockedUntil: 0,
     lastError: message || "Upload paused",
   });
+  if (!queued) return;
   await broadcast({ type: "WATERDROP_UPLOAD_QUEUED", id });
 }
 
+function isCancelledUploadRecord(record, now = Date.now()) {
+  if (record?.status !== "cancelled") return false;
+  const cancelledUntil = Number(record.cancelledUntil || 0);
+  return !cancelledUntil || cancelledUntil > now;
+}
+
+function isExpiredCancelledUploadRecord(record, now = Date.now()) {
+  if (record?.status !== "cancelled") return false;
+  const cancelledUntil = Number(record.cancelledUntil || 0);
+  return Boolean(cancelledUntil && cancelledUntil <= now);
+}
+
 function openDb() {
   return new Promise((resolve, reject) => {
     const request = indexedDB.open(DB_NAME, DB_VERSION);