wiki-plugin-shoppe 0.0.31 → 0.0.33

package/client/shoppe.js

@@ -44,6 +44,10 @@
             .sw-status.success { background: #d1fae5; color: #065f46; display: block; }
             .sw-status.error   { background: #fee2e2; color: #991b1b; display: block; }
             .sw-status code { background: rgba(0,0,0,0.08); border-radius: 4px; padding: 1px 5px; font-size: 12px; }
+            .sw-progress-bar-track { background: rgba(0,0,0,0.12); border-radius: 4px; height: 8px; margin: 8px 0; overflow: hidden; }
+            .sw-progress-bar-fill  { height: 100%; background: #1a56db; border-radius: 4px; width: 0%; transition: width 0.25s ease; }
+            .sw-progress-meta { display: flex; justify-content: space-between; font-size: 12px; opacity: 0.75; }
+            .sw-progress-item { margin-top: 6px; font-size: 13px; font-style: italic; }
             .sw-remove { display: block; width: 100%; margin-top: 24px; padding: 8px; background: none; border: 1px solid #e5e5ea; border-radius: 8px; font-size: 12px; color: #aaa; cursor: pointer; text-align: center; }
             .sw-remove:hover { border-color: #cc0000; color: #cc0000; }
           </style>
@@ -313,25 +317,72 @@
   // ── Upload ──────────────────────────────────────────────────────────────────
 
   async function uploadArchive(file, container) {
+    const statusEl = container.querySelector('#sw-upload-status');
+
+    // Step 1: POST the file, get a jobId back immediately.
     showStatus(container, '#sw-upload-status', `⏳ Uploading <strong>${file.name}</strong>…`, 'info');
     const form = new FormData();
     form.append('archive', file);
+    let jobId;
     try {
       const resp = await fetch('/plugin/shoppe/upload', { method: 'POST', body: form });
       const result = await resp.json();
-      if (!result.success) throw new Error(result.error || 'Upload failed');
+      if (!result.success || !result.jobId) throw new Error(result.error || 'Upload failed');
+      jobId = result.jobId;
+    } catch (err) {
+      showStatus(container, '#sw-upload-status', `❌ ${err.message}`, 'error');
+      return;
+    }
+
+    // Step 2: Show progress UI and open SSE stream.
+    statusEl.className = 'sw-status info';
+    statusEl.style.display = 'block';
+    statusEl.innerHTML = `
+      <div id="sw-progress-title" style="font-weight:600;margin-bottom:6px;">⏳ Processing archive…</div>
+      <div class="sw-progress-bar-track"><div id="sw-progress-fill" class="sw-progress-bar-fill"></div></div>
+      <div class="sw-progress-meta">
+        <span id="sw-progress-count">0 / …</span>
+        <span id="sw-progress-pct">0%</span>
+      </div>
+      <div id="sw-progress-item" class="sw-progress-item"></div>
+    `;
+
+    const fillEl  = statusEl.querySelector('#sw-progress-fill');
+    const countEl = statusEl.querySelector('#sw-progress-count');
+    const pctEl   = statusEl.querySelector('#sw-progress-pct');
+    const itemEl  = statusEl.querySelector('#sw-progress-item');
+    const titleEl = statusEl.querySelector('#sw-progress-title');
+
+    const es = new EventSource(`/plugin/shoppe/upload/progress/${jobId}`);
+
+    es.addEventListener('start', e => {
+      const { total, name } = JSON.parse(e.data);
+      titleEl.innerHTML = `⏳ Uploading <strong>${name}</strong> — ${total} item${total !== 1 ? 's' : ''}`;
+      countEl.textContent = `0 / ${total}`;
+    });
+
+    es.addEventListener('progress', e => {
+      const { current, total, label } = JSON.parse(e.data);
+      const pct = total > 0 ? Math.round(current / total * 100) : 0;
+      fillEl.style.width  = pct + '%';
+      countEl.textContent = `${current} / ${total}`;
+      pctEl.textContent   = pct + '%';
+      itemEl.textContent  = label;
+    });
 
+    es.addEventListener('complete', e => {
+      es.close();
+      const result = JSON.parse(e.data);
       const r = result.results;
       const counts = [
-        r.books.length        && `📚 ${r.books.length} book${r.books.length !== 1 ? 's' : ''}`,
-        r.music.length        && `🎵 ${r.music.length} music item${r.music.length !== 1 ? 's' : ''}`,
-        r.posts.length        && `📝 ${r.posts.length} post${r.posts.length !== 1 ? 's' : ''}`,
-        r.albums.length       && `🖼️ ${r.albums.length} album${r.albums.length !== 1 ? 's' : ''}`,
-        r.products.length     && `📦 ${r.products.length} product${r.products.length !== 1 ? 's' : ''}`,
+        r.books.length             && `📚 ${r.books.length} book${r.books.length !== 1 ? 's' : ''}`,
+        r.music.length             && `🎵 ${r.music.length} music item${r.music.length !== 1 ? 's' : ''}`,
+        r.posts.length             && `📝 ${r.posts.length} post${r.posts.length !== 1 ? 's' : ''}`,
+        r.albums.length            && `🖼️ ${r.albums.length} album${r.albums.length !== 1 ? 's' : ''}`,
+        r.products.length          && `📦 ${r.products.length} product${r.products.length !== 1 ? 's' : ''}`,
         r.appointments && r.appointments.length && `📅 ${r.appointments.length} appointment${r.appointments.length !== 1 ? 's' : ''}`,
         r.subscriptions && r.subscriptions.length && `🎁 ${r.subscriptions.length} subscription tier${r.subscriptions.length !== 1 ? 's' : ''}`
       ].filter(Boolean).join(' · ') || 'no items found';
-
       const warnings = (r.warnings && r.warnings.length > 0)
         ? `<br><br>⚠️ <strong>Warnings (${r.warnings.length}):</strong><br>${r.warnings.map(w => `• ${w}`).join('<br>')}`
         : '';
@@ -340,9 +391,14 @@
          <a href="/plugin/shoppe/${result.tenant.uuid}" target="_blank" class="sw-link" style="display:inline-block;margin-top:8px;">View your shoppe →</a>`,
         'success');
       loadDirectory(container);
-    } catch (err) {
-      showStatus(container, '#sw-upload-status', `❌ ${err.message}`, 'error');
-    }
+    });
+
+    es.addEventListener('error', e => {
+      es.close();
+      let msg = 'Upload failed';
+      try { msg = JSON.parse(e.data).message; } catch (err) { /* use default */ }
+      showStatus(container, '#sw-upload-status', `❌ ${msg}`, 'error');
+    });
   }
 
   // ── Save URL (owner) ────────────────────────────────────────────────────────

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wiki-plugin-shoppe",
-  "version": "0.0.31",
+  "version": "0.0.33",
   "description": "Multi-tenant digital goods shoppe for federated wiki, powered by Sanora",
   "keywords": [
     "wiki",

package/server/server.js

@@ -448,8 +448,13 @@ async function registerTenant(name) {
 
 function getTenantByIdentifier(identifier) {
   const tenants = loadTenants();
-  if (tenants[identifier]) return tenants[identifier];
-  return Object.values(tenants).find(t => t.emojicode === identifier) || null;
+  const entry = tenants[identifier];
+  if (entry) {
+    // String value = alias left behind after a UUID change (Redis reset); follow it.
+    if (typeof entry === 'string') return tenants[entry] || null;
+    return entry;
+  }
+  return Object.values(tenants).find(t => typeof t === 'object' && t.emojicode === identifier) || null;
 }
 
 // ============================================================
@@ -506,15 +511,29 @@ async function sanoraEnsureUser(tenant) {
     console.log(`[shoppe] Sanora UUID changed ${tenant.uuid} → ${sanoraUser.uuid} (Redis was reset). Updating tenants.json.`);
     const tenants = loadTenants();
     const oldUuid = tenant.uuid;
-    delete tenants[oldUuid];
     tenant.uuid = sanoraUser.uuid;
     tenants[sanoraUser.uuid] = tenant;
+    // Keep old UUID as a forwarding alias so existing manifest.json / shared URLs still resolve.
+    tenants[oldUuid] = sanoraUser.uuid;
     saveTenants(tenants);
   }
 
   return tenant; // tenant.uuid is now correct
 }
 
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
+
+// fetch() wrapper that retries on 429 with exponential backoff (1s, 2s, 4s).
+async function fetchWithRetry(url, options, maxRetries = 3) {
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    const resp = await fetch(url, options);
+    if (resp.status !== 429 || attempt === maxRetries) return resp;
+    const delay = 1000 * Math.pow(2, attempt);
+    console.warn(`[shoppe] 429 rate limited on ${new URL(url).pathname}, retrying in ${delay}ms…`);
+    await sleep(delay);
+  }
+}
+
 async function sanoraCreateProduct(tenant, title, category, description, price, shipping, tags) {
   const { uuid, keys } = tenant;
   const timestamp = Date.now().toString();
@@ -524,7 +543,7 @@ async function sanoraCreateProduct(tenant, title, category, description, price,
   sessionless.getKeys = () => keys;
   const signature = await sessionless.sign(message);
 
-  const resp = await fetch(
+  const resp = await fetchWithRetry(
     `${getSanoraUrl()}/user/${uuid}/product/${encodeURIComponent(title)}`,
     {
       method: 'PUT',
@@ -543,11 +562,32 @@ async function sanoraCreateProduct(tenant, title, category, description, price,
     }
   );
 
+  if (!resp.ok) {
+    const text = await resp.text().catch(() => '');
+    throw new Error(`Create product failed (${resp.status}): ${text.slice(0, 200)}`);
+  }
   const product = await resp.json();
   if (product.error) throw new Error(`Create product failed: ${product.error}`);
   return product;
 }
 
+// Wrapper used by processArchive. On "not found" (Sanora Redis cleared mid-upload),
+// re-registers the tenant and retries once. tenant.uuid may be updated in place.
+async function sanoraCreateProductResilient(tenant, title, category, description, price, shipping, tags) {
+  try {
+    return await sanoraCreateProduct(tenant, title, category, description, price, shipping, tags);
+  } catch (err) {
+    if (err.message.includes('not found') || err.message.includes('404')) {
+      console.warn(`[shoppe] Sanora user lost mid-upload, re-registering and retrying: ${title}`);
+      const updated = await sanoraEnsureUser(tenant);
+      // Mutate tenant in place so all subsequent calls use the new UUID
+      tenant.uuid = updated.uuid;
+      return await sanoraCreateProduct(tenant, title, category, description, price, shipping, tags);
+    }
+    throw err;
+  }
+}
+
 async function sanoraUploadArtifact(tenant, title, fileBuffer, filename, artifactType) {
   const { uuid, keys } = tenant;
   const timestamp = Date.now().toString();
@@ -558,7 +598,7 @@ async function sanoraUploadArtifact(tenant, title, fileBuffer, filename, artifac
   const form = new FormData();
   form.append('artifact', fileBuffer, { filename, contentType: getMimeType(filename) });
 
-  const resp = await fetch(
+  const resp = await fetchWithRetry(
     `${getSanoraUrl()}/user/${uuid}/product/${encodeURIComponent(title)}/artifact`,
     {
       method: 'PUT',
@@ -573,6 +613,10 @@ async function sanoraUploadArtifact(tenant, title, fileBuffer, filename, artifac
     }
   );
 
+  if (!resp.ok) {
+    const text = await resp.text().catch(() => '');
+    throw new Error(`Artifact upload failed (${resp.status}): ${text.slice(0, 200)}`);
+  }
   const result = await resp.json();
   if (result.error) throw new Error(`Artifact upload failed: ${result.error}`);
   return result;
@@ -588,7 +632,7 @@ async function sanoraUploadImage(tenant, title, imageBuffer, filename) {
   const form = new FormData();
   form.append('image', imageBuffer, { filename, contentType: getMimeType(filename) });
 
-  const resp = await fetch(
+  const resp = await fetchWithRetry(
     `${getSanoraUrl()}/user/${uuid}/product/${encodeURIComponent(title)}/image`,
     {
       method: 'PUT',
@@ -602,6 +646,10 @@ async function sanoraUploadImage(tenant, title, imageBuffer, filename) {
     }
   );
 
+  if (!resp.ok) {
+    const text = await resp.text().catch(() => '');
+    throw new Error(`Image upload failed (${resp.status}): ${text.slice(0, 200)}`);
+  }
   const result = await resp.json();
   if (result.error) throw new Error(`Image upload failed: ${result.error}`);
   return result;
@@ -710,7 +758,46 @@ async function lucilleUploadVideo(tenant, title, fileBuffer, filename, lucilleUr
 // ARCHIVE PROCESSING
 // ============================================================
 
-async function processArchive(zipPath) {
+// ── Upload job store ─────────────────────────────────────────────────────────
+// Each job buffers SSE events so the client can replay them if it connects late.
+const uploadJobs = new Map(); // jobId → { sse: res|null, queue: [], done: false }
+
+function countItems(root) {
+  let count = 0;
+
+  const booksDir = path.join(root, 'books');
+  if (fs.existsSync(booksDir))
+    count += fs.readdirSync(booksDir).filter(f => fs.statSync(path.join(booksDir, f)).isDirectory()).length;
+
+  const musicDir = path.join(root, 'music');
+  if (fs.existsSync(musicDir)) {
+    for (const entry of fs.readdirSync(musicDir)) {
+      const stat = fs.statSync(path.join(musicDir, entry));
+      if (stat.isDirectory()) count++;
+      else if (MUSIC_EXTS.has(path.extname(entry).toLowerCase())) count++;
+    }
+  }
+
+  const postsDir = path.join(root, 'posts');
+  if (fs.existsSync(postsDir)) {
+    for (const entry of fs.readdirSync(postsDir)) {
+      const entryPath = path.join(postsDir, entry);
+      if (!fs.statSync(entryPath).isDirectory()) continue;
+      const subDirs = fs.readdirSync(entryPath).filter(f => fs.statSync(path.join(entryPath, f)).isDirectory());
+      count += subDirs.length > 0 ? 1 + subDirs.length : 1;
+    }
+  }
+
+  for (const dirName of ['albums', 'products', 'subscriptions', 'videos', 'appointments']) {
+    const dir = path.join(root, dirName);
+    if (fs.existsSync(dir))
+      count += fs.readdirSync(dir).filter(f => fs.statSync(path.join(dir, f)).isDirectory()).length;
+  }
+
+  return count;
+}
+
+async function processArchive(zipPath, onProgress = () => {}) {
   const tmpDir = path.join(TMP_DIR, `extract-${Date.now()}`);
   fs.mkdirSync(tmpDir, { recursive: true });
   // Use system unzip to stream-extract without loading entire archive into RAM.
@@ -783,6 +870,10 @@ async function processArchive(zipPath) {
     // If Redis was wiped, this re-creates the user and updates tenant.uuid.
     tenant = await sanoraEnsureUser(tenant);
 
+    const total = countItems(root);
+    let current = 0;
+    onProgress({ type: 'start', total, name: manifest.name });
+
     const results = { books: [], music: [], posts: [], albums: [], products: [], videos: [], appointments: [], subscriptions: [], warnings: [] };
 
     function readInfo(entryPath) {
@@ -811,7 +902,8 @@ async function processArchive(zipPath) {
           const description = info.description || '';
           const price = info.price || 0;
 
-          await sanoraCreateProduct(tenant, title, 'book', description, price, 0, buildTags('book', info.keywords));
+          onProgress({ type: 'progress', current: ++current, total, label: `📚 ${title}` });
+          await sanoraCreateProductResilient(tenant, title, 'book', description, price, 0, buildTags('book', info.keywords));
 
           // Cover image — use info.cover to pin a specific file, else first image found
           const covers = fs.readdirSync(entryPath).filter(f => IMAGE_EXTS.has(path.extname(f).toLowerCase()));
@@ -853,7 +945,8 @@ async function processArchive(zipPath) {
           try {
             const description = info.description || `Album: ${albumTitle}`;
             const price = info.price || 0;
-            await sanoraCreateProduct(tenant, albumTitle, 'music', description, price, 0, buildTags('music,album', info.keywords));
+            onProgress({ type: 'progress', current: ++current, total, label: `🎵 ${albumTitle}` });
+            await sanoraCreateProductResilient(tenant, albumTitle, 'music', description, price, 0, buildTags('music,album', info.keywords));
             const coverFile = info.cover ? (covers.find(f => f === info.cover) || covers[0]) : covers[0];
             if (coverFile) {
               const coverBuf = fs.readFileSync(path.join(entryPath, coverFile));
@@ -882,7 +975,8 @@ async function processArchive(zipPath) {
             const buf = fs.readFileSync(entryPath);
             const description = trackInfo.description || `Track: ${title}`;
             const price = trackInfo.price || 0;
-            await sanoraCreateProduct(tenant, title, 'music', description, price, 0, buildTags('music,track', trackInfo.keywords));
+            onProgress({ type: 'progress', current: ++current, total, label: `🎵 ${title}` });
+            await sanoraCreateProductResilient(tenant, title, 'music', description, price, 0, buildTags('music,track', trackInfo.keywords));
             await sanoraUploadArtifact(tenant, title, buf, entry, 'audio');
             results.music.push({ title, type: 'track' });
             console.log(`[shoppe]   🎵 track: ${title}`);
@@ -922,7 +1016,8 @@ async function processArchive(zipPath) {
           // Register the series itself as a parent product
           try {
             const description = info.description || `A ${subDirs.length}-part series`;
-            await sanoraCreateProduct(tenant, seriesTitle, 'post-series', description, 0, 0, buildTags(`post,series,order:${order}`, info.keywords));
+            onProgress({ type: 'progress', current: ++current, total, label: `📝 ${seriesTitle} (series)` });
+            await sanoraCreateProductResilient(tenant, seriesTitle, 'post-series', description, 0, 0, buildTags(`post,series,order:${order}`, info.keywords));
 
             const covers = fs.readdirSync(entryPath).filter(f => IMAGE_EXTS.has(path.extname(f).toLowerCase()));
             if (covers.length > 0) {
@@ -962,7 +1057,8 @@ async function processArchive(zipPath) {
               const productTitle = `${seriesTitle}: ${resolvedTitle}`;
               const description = partInfo.description || partFm.body.split('\n\n')[0].replace(/^#+\s*/, '').trim() || resolvedTitle;
 
-              await sanoraCreateProduct(tenant, productTitle, 'post', description, 0, 0,
+              onProgress({ type: 'progress', current: ++current, total, label: `📝 ${productTitle}` });
+              await sanoraCreateProductResilient(tenant, productTitle, 'post', description, 0, 0,
                 buildTags(`post,blog,series:${seriesTitle},part:${partIndex + 1},order:${order}`, partInfo.keywords));
 
               await sanoraUploadArtifact(tenant, productTitle, mdBuf, partMdFiles[0], 'text');
@@ -1004,7 +1100,8 @@ async function processArchive(zipPath) {
             const firstLine = fm.body.split('\n').find(l => l.trim()).replace(/^#+\s*/, '');
             const description = info.description || fm.body.split('\n\n')[0].replace(/^#+\s*/, '').trim() || firstLine || title;
 
-            await sanoraCreateProduct(tenant, title, 'post', description, 0, 0, buildTags(`post,blog,order:${order}`, info.keywords));
+            onProgress({ type: 'progress', current: ++current, total, label: `📝 ${title}` });
+            await sanoraCreateProductResilient(tenant, title, 'post', description, 0, 0, buildTags(`post,blog,order:${order}`, info.keywords));
             await sanoraUploadArtifact(tenant, title, mdBuf, mdFiles[0], 'text');
 
             const covers = fs.readdirSync(entryPath).filter(f => IMAGE_EXTS.has(path.extname(f).toLowerCase()));
@@ -1041,7 +1138,8 @@ async function processArchive(zipPath) {
         if (!fs.statSync(entryPath).isDirectory()) continue;
         const images = fs.readdirSync(entryPath).filter(f => IMAGE_EXTS.has(path.extname(f).toLowerCase()));
         try {
-          await sanoraCreateProduct(tenant, entry, 'album', `Photo album: ${entry}`, 0, 0, 'album,photos');
+          onProgress({ type: 'progress', current: ++current, total, label: `🖼️ ${entry}` });
+          await sanoraCreateProductResilient(tenant, entry, 'album', `Photo album: ${entry}`, 0, 0, 'album,photos');
           if (images.length > 0) {
             const coverBuf = fs.readFileSync(path.join(entryPath, images[0]));
             await sanoraUploadImage(tenant, entry, coverBuf, images[0]);
@@ -1078,7 +1176,8 @@ async function processArchive(zipPath) {
           const price = info.price || 0;
           const shipping = info.shipping || 0;
 
-          await sanoraCreateProduct(tenant, title, 'product', description, price, shipping, buildTags(`product,physical,order:${order}`, info.keywords));
+          onProgress({ type: 'progress', current: ++current, total, label: `📦 ${title}` });
+          await sanoraCreateProductResilient(tenant, title, 'product', description, price, shipping, buildTags(`product,physical,order:${order}`, info.keywords));
 
           // Hero image: prefer hero.jpg / hero.png, fall back to first image
           const images = fs.readdirSync(entryPath).filter(f => IMAGE_EXTS.has(path.extname(f).toLowerCase()));
@@ -1119,7 +1218,8 @@ async function processArchive(zipPath) {
             renewalDays: info.renewalDays || 30
           };
 
-          await sanoraCreateProduct(tenant, title, 'subscription', description, price, 0, buildTags('subscription', info.keywords));
+          onProgress({ type: 'progress', current: ++current, total, label: `🎁 ${title}` });
+          await sanoraCreateProductResilient(tenant, title, 'subscription', description, price, 0, buildTags('subscription', info.keywords));
 
           // Upload tier metadata (benefits list, renewal period) as a JSON artifact
           const tierBuf = Buffer.from(JSON.stringify(tierMeta));
@@ -1194,7 +1294,8 @@ async function processArchive(zipPath) {
             (lucilleVideoId ? `,lucille-id:${lucilleVideoId},lucille-url:${lucilleBase}` : '');
 
           // Sanora catalog entry (for discovery / storefront)
-          await sanoraCreateProduct(tenant, title, 'video', description, price, 0, videoTags);
+          onProgress({ type: 'progress', current: ++current, total, label: `🎬 ${title}` });
+          await sanoraCreateProductResilient(tenant, title, 'video', description, price, 0, videoTags);
 
           // Cover / poster image (optional)
           const images = fs.readdirSync(entryPath).filter(f => IMAGE_EXTS.has(path.extname(f).toLowerCase()));
@@ -1240,7 +1341,8 @@ async function processArchive(zipPath) {
             advanceDays:  info.advanceDays  || 30
           };
 
-          await sanoraCreateProduct(tenant, title, 'appointment', description, price, 0, buildTags('appointment', info.keywords));
+          onProgress({ type: 'progress', current: ++current, total, label: `📅 ${title}` });
+          await sanoraCreateProductResilient(tenant, title, 'appointment', description, price, 0, buildTags('appointment', info.keywords));
 
           // Upload schedule as a JSON artifact so the booking page can retrieve it
           const scheduleBuf = Buffer.from(JSON.stringify(schedule));
@@ -1998,22 +2100,53 @@ async function startServer(params) {
   });
 
   // Upload goods archive (auth via manifest uuid+emojicode)
-  app.post('/plugin/shoppe/upload', upload.single('archive'), async (req, res) => {
-    try {
-      if (!req.file) {
-        return res.status(400).json({ success: false, error: 'No archive uploaded' });
-      }
-      console.log('[shoppe] Processing archive:', req.file.originalname);
-      const result = await processArchive(req.file.path);
-      res.json({ success: true, ...result });
-    } catch (err) {
-      console.error('[shoppe] upload error:', err);
-      res.status(500).json({ success: false, error: err.message });
-    } finally {
-      if (req.file && fs.existsSync(req.file.path)) {
-        try { fs.unlinkSync(req.file.path); } catch (e) {}
-      }
+  app.post('/plugin/shoppe/upload', upload.single('archive'), (req, res) => {
+    if (!req.file) {
+      return res.status(400).json({ success: false, error: 'No archive uploaded' });
     }
+
+    const jobId = crypto.randomBytes(8).toString('hex');
+    const job = { sse: null, queue: [], done: false };
+    uploadJobs.set(jobId, job);
+    setTimeout(() => uploadJobs.delete(jobId), 15 * 60 * 1000); // clean up after 15 min
+
+    res.json({ success: true, jobId });
+
+    function emit(type, data) {
+      job.queue.push({ type, data });
+      if (job.sse) job.sse.write(`event: ${type}\ndata: ${JSON.stringify(data)}\n\n`);
+    }
+
+    const zipPath = req.file.path;
+    console.log('[shoppe] Processing archive:', req.file.originalname);
+    processArchive(zipPath, emit)
+      .then(result  => emit('complete', { success: true, ...result }))
+      .catch(err    => { console.error('[shoppe] upload error:', err); emit('error', { message: err.message }); })
+      .finally(() => {
+        job.done = true;
+        if (job.sse) { job.sse.end(); job.sse = null; }
+        if (fs.existsSync(zipPath)) try { fs.unlinkSync(zipPath); } catch (e) {}
+      });
+  });
+
+  app.get('/plugin/shoppe/upload/progress/:jobId', (req, res) => {
+    const job = uploadJobs.get(req.params.jobId);
+    if (!job) return res.status(404).json({ error: 'Unknown job' });
+
+    res.setHeader('Content-Type', 'text/event-stream');
+    res.setHeader('Cache-Control', 'no-cache');
+    res.setHeader('Connection', 'keep-alive');
+    res.flushHeaders();
+
+    // Replay buffered events for late-connecting clients.
+    for (const evt of job.queue) {
+      res.write(`event: ${evt.type}\ndata: ${JSON.stringify(evt.data)}\n\n`);
+    }
+
+    if (job.done) { res.end(); return; }
+
+    job.sse = res;
+    req.on('close', () => { if (job.sse === res) job.sse = null; });
   });
 
   // Get config (owner only)