@productmaker/mcp 12.2.6 → 12.2.8

package/dist/ui/meta-upload-app.html

@@ -569,6 +569,7 @@
           forceSizeReport: false,
           lastReportedHeight: 0,
           session: null,
+          sessionGeneration: 0,
           toolInput: {},
           items: [],
           consumedBridgeIds: new Set(),
@@ -812,6 +813,33 @@
           return state.abortController?.signal;
         }
 
+        // An immutable work context prevents old async continuations from
+        // acquiring a replacement session's credentials or mutating its UI.
+        function captureUploadWork() {
+          return state.session
+            ? {
+                session: state.session,
+                generation: state.sessionGeneration,
+                signal: activeAbortSignal(),
+              }
+            : null;
+        }
+
+        function uploadWorkIsCurrent(work) {
+          return Boolean(
+            work &&
+            !state.disposed &&
+            !state.workCancelled &&
+            !work.signal?.aborted &&
+            work.generation === state.sessionGeneration &&
+            work.session.sessionId === state.session?.sessionId,
+          );
+        }
+
+        function requireCurrentUploadWork(work) {
+          if (!uploadWorkIsCurrent(work)) throw new Error("upload_cancelled");
+        }
+
         function abortActiveWork() {
           state.abortController?.abort();
           for (const request of state.activeXhrs) request.abort();
@@ -1013,7 +1041,12 @@
         }
 
         function handleHostMessage(event) {
-          if (event.source !== window.parent || !isRecord(event.data)) return;
+          if (
+            event.source !== window.parent ||
+            !isRecord(event.data) ||
+            event.data.jsonrpc !== "2.0"
+          )
+            return;
           const message = event.data;
           if (message.method === "ui/resource-teardown") {
             cleanup();
@@ -1046,7 +1079,58 @@
             applyHostContainerDimensions();
             return;
           }
+          // Host requests have their own ID namespace: a ping may reuse an
+          // outstanding app request ID without being its response.
+          if (message.method === "ping") {
+            if (
+              (typeof message.id === "string" ||
+                Number.isInteger(message.id)) &&
+              !Object.prototype.hasOwnProperty.call(message, "result") &&
+              !Object.prototype.hasOwnProperty.call(message, "error") &&
+              (message.params === undefined || isRecord(message.params))
+            )
+              window.parent.postMessage(
+                { jsonrpc: "2.0", id: message.id, result: {} },
+                "*",
+              );
+            return;
+          }
+          if (typeof message.method === "string") {
+            if (
+              (typeof message.id === "string" ||
+                Number.isInteger(message.id)) &&
+              !Object.prototype.hasOwnProperty.call(message, "result") &&
+              !Object.prototype.hasOwnProperty.call(message, "error") &&
+              (message.params === undefined ||
+                isRecord(message.params) ||
+                Array.isArray(message.params))
+            ) {
+              window.parent.postMessage(
+                {
+                  jsonrpc: "2.0",
+                  id: message.id,
+                  error: { code: -32601, message: "Method not found" },
+                },
+                "*",
+              );
+            }
+            // Notifications have no id and are handled below.
+            if (Object.prototype.hasOwnProperty.call(message, "id")) return;
+          }
           if (Object.prototype.hasOwnProperty.call(message, "id")) {
+            const successResponse =
+              isRecord(message.result) &&
+              !Object.prototype.hasOwnProperty.call(message, "error");
+            const errorResponse =
+              isRecord(message.error) &&
+              Number.isInteger(message.error.code) &&
+              typeof message.error.message === "string" &&
+              !Object.prototype.hasOwnProperty.call(message, "result");
+            if (
+              Object.prototype.hasOwnProperty.call(message, "method") ||
+              (!successResponse && !errorResponse)
+            )
+              return;
             const pending = state.pendingRpc.get(message.id);
             if (!pending) return;
             window.clearTimeout(pending.timeout);
@@ -1080,6 +1164,7 @@
           const sessionChanged =
             !state.session || state.session.sessionId !== session.sessionId;
           if (sessionChanged) {
+            state.sessionGeneration += 1;
             abortActiveWork();
             for (const item of state.items) revokePreviewUrl(item);
             state.items = [];
@@ -1190,21 +1275,25 @@
             !Array.isArray(state.toolInput.files)
           )
             return;
+          const work = captureUploadWork();
           state.bridgeConsumptionQueued = true;
           void enqueueIngestion(async () => {
+            if (!uploadWorkIsCurrent(work)) return;
             state.bridgeConsumptionQueued = false;
-            await consumePendingBridgeFilesNow();
+            await consumePendingBridgeFilesNow(work);
           }).catch(() => {
-            state.bridgeConsumptionQueued = false;
+            if (uploadWorkIsCurrent(work))
+              state.bridgeConsumptionQueued = false;
           });
         }
 
-        async function consumePendingBridgeFilesNow() {
+        async function consumePendingBridgeFilesNow(work) {
           if (
             state.disposed ||
             !state.session ||
             !Array.isArray(state.toolInput.files) ||
-            state.consumingBridgeFiles
+            state.consumingBridgeFiles ||
+            !uploadWorkIsCurrent(work)
           )
             return;
           state.consumingBridgeFiles = true;
@@ -1229,35 +1318,41 @@
             for (const reference of pending.slice(0, availableSlots)) {
               const id = normalizedBridgeReferenceId(reference);
               try {
-                const file = await downloadBridgeReference(reference);
+                const file = await downloadBridgeReference(reference, work);
+                requireCurrentUploadWork(work);
                 state.consumedBridgeIds.add(id);
                 files.push(file);
               } catch {
+                if (!uploadWorkIsCurrent(work)) return;
                 state.consumedBridgeIds.add(id);
                 addBridgeFailure(reference);
               }
             }
-            if (files.length) await processFiles(files);
+            if (files.length) await processFiles(files, work);
           } finally {
-            state.consumingBridgeFiles = false;
-            const hasUnconsumed =
-              Array.isArray(state.toolInput.files) &&
-              state.toolInput.files.some((reference) => {
-                const id = normalizedBridgeReferenceId(reference);
-                return id && !state.consumedBridgeIds.has(id);
-              });
-            if (
-              hasUnconsumed &&
-              hasOpenAiFunction("getFileDownloadUrl") &&
-              state.items.length < safeSessionLimit()
-            ) {
-              queueMicrotask(() => void consumePendingBridgeFiles());
+            if (uploadWorkIsCurrent(work)) {
+              state.consumingBridgeFiles = false;
+              const hasUnconsumed =
+                Array.isArray(state.toolInput.files) &&
+                state.toolInput.files.some((reference) => {
+                  const id = normalizedBridgeReferenceId(reference);
+                  return id && !state.consumedBridgeIds.has(id);
+                });
+              if (
+                hasUnconsumed &&
+                hasOpenAiFunction("getFileDownloadUrl") &&
+                state.items.length < safeSessionLimit()
+              ) {
+                queueMicrotask(() => void consumePendingBridgeFiles());
+              }
             }
           }
         }
 
         function processLocalFiles(files) {
+          const work = captureUploadWork();
           return enqueueIngestion(async () => {
+            if (!uploadWorkIsCurrent(work)) return;
             if (
               state.disposed ||
               !state.session ||
@@ -1271,12 +1366,14 @@
                 `Puedes subir hasta ${safeSessionLimit()} archivos por sesión.`,
               );
             }
-            await processFiles(files);
+            await processFiles(files, work);
           });
         }
 
         function chooseLibraryFiles() {
+          const work = captureUploadWork();
           return enqueueIngestion(async () => {
+            if (!uploadWorkIsCurrent(work)) return;
             if (
               state.disposed ||
               !state.session ||
@@ -1293,6 +1390,7 @@
               return;
             try {
               const result = await bridge.selectFiles();
+              requireCurrentUploadWork(work);
               const selected = Array.isArray(result) ? result : [];
               const availableSlots = Math.max(
                 0,
@@ -1307,18 +1405,23 @@
                 if (!fileId || !fileName || !mimeType) continue;
                 try {
                   files.push(
-                    await downloadBridgeReference({
-                      fileId,
-                      fileName,
-                      mimeType,
-                    }),
+                    await downloadBridgeReference(
+                      {
+                        fileId,
+                        fileName,
+                        mimeType,
+                      },
+                      work,
+                    ),
                   );
                 } catch {
+                  if (!uploadWorkIsCurrent(work)) return;
                   addBridgeFailure({ fileId, fileName, mimeType });
                 }
               }
-              await processFiles(files);
+              await processFiles(files, work);
             } catch {
+              if (!uploadWorkIsCurrent(work)) return;
               setSessionStatus(
                 "No se pudo abrir el selector del host. Usa el selector del navegador.",
                 "warning",
@@ -1337,7 +1440,8 @@
           );
         }
 
-        async function downloadBridgeReference(reference) {
+        async function downloadBridgeReference(reference, work) {
+          requireCurrentUploadWork(work);
           const bridge = openAiBridge();
           if (!bridge || typeof bridge.getFileDownloadUrl !== "function") {
             throw new Error("bridge_download_unavailable");
@@ -1345,6 +1449,7 @@
           const fileId = normalizedBridgeReferenceId(reference);
           if (!fileId) throw new Error("invalid_bridge_file");
           const resolved = await bridge.getFileDownloadUrl({ fileId });
+          requireCurrentUploadWork(work);
           const temporaryUrl = normalizedBridgeDownloadUrl(resolved);
           const parsedUrl = new URL(temporaryUrl);
           if (!safeBridgeDownloadUrl(parsedUrl))
@@ -1353,10 +1458,11 @@
             method: "GET",
             credentials: "omit",
             redirect: "error",
-            signal: activeAbortSignal(),
+            signal: work.signal,
           });
           if (!response.ok) throw new Error("bridge_download_failed");
           const blob = await readBoundedBridgeBlob(response);
+          requireCurrentUploadWork(work);
           const preferredType = boundedString(
             reference.mime_type || reference.mimeType || reference.type,
             100,
@@ -1449,13 +1555,14 @@
           });
         }
 
-        async function processFiles(fileCandidates) {
+        async function processFiles(fileCandidates, work) {
           if (
             state.disposed ||
             !state.session ||
             sessionExpired() ||
             state.uploadBlocked ||
-            state.busyBatch
+            state.busyBatch ||
+            !uploadWorkIsCurrent(work)
           )
             return;
           const files = fileCandidates.filter(isBrowserFile);
@@ -1476,14 +1583,17 @@
           state.busyBatch = true;
           setPickerAvailability();
           for (const file of selected) {
+            if (!uploadWorkIsCurrent(work)) return;
             const mediaKind = mediaKindForType(file.type) || "image";
             const item = createItem(file, mediaKind);
+            item.work = work;
             state.items.push(item);
             renderItems();
             // Thumbnail is cosmetic and must never delay or block the upload.
             void upgradePreviewToDataUrl(item);
-            await prepareAndUpload(item);
+            await prepareAndUpload(item, work);
           }
+          if (!uploadWorkIsCurrent(work)) return;
           state.busyBatch = false;
           setPickerAvailability();
           if (state.items.some((item) => item.status === "uploaded")) {
@@ -1510,7 +1620,8 @@
           };
         }
 
-        async function prepareAndUpload(item) {
+        async function prepareAndUpload(item, work) {
+          if (!uploadWorkIsCurrent(work)) return;
           if (!item.file) return;
           item.status = "validating";
           item.progress = 0;
@@ -1518,20 +1629,31 @@
           item.failureStage = "";
           renderItems();
           try {
-            const inspection = await inspectFile(item.file);
+            const inspection = await inspectFile(item.file, work.session);
+            requireCurrentUploadWork(work);
             item.mediaKind = inspection.mediaKind;
             item.uploadFile =
               inspection.mediaKind === "image"
                 ? await compressImage(item.file, inspection)
                 : item.file;
+            requireCurrentUploadWork(work);
             emitAnalytics("mcp_media_upload_started", item.mediaKind);
-            await uploadWithRetries(item);
+            await uploadWithRetries(item, work);
+            requireCurrentUploadWork(work);
             item.status = "uploaded";
             item.progress = 100;
             item.error = "";
             item.slotReserved = false;
             emitAnalytics("mcp_media_upload_completed", item.mediaKind);
           } catch (error) {
+            if (!uploadWorkIsCurrent(work)) {
+              void releaseUploadSlot(item);
+              emitAnalytics("mcp_media_upload_error", item.mediaKind, {
+                failureStage: error?.safeStage || "upload",
+                errorType: "upload_cancelled",
+              });
+              return;
+            }
             const failure = safeFailure(error);
             item.status = "failed";
             item.error = failure.message;
@@ -1562,7 +1684,7 @@
           renderItems();
         }
 
-        async function inspectFile(file) {
+        async function inspectFile(file, session) {
           const mediaKind = mediaKindForType(file.type);
           if (!ACCEPTED_TYPES.has(file.type) || !mediaKind) {
             throw validationError(
@@ -1571,18 +1693,15 @@
             );
           }
           if (
-            state.session.mediaKind !== "mixed" &&
-            state.session.mediaKind !== mediaKind
+            session.mediaKind !== "mixed" &&
+            session.mediaKind !== mediaKind
           ) {
             throw validationError(
               "wrong_media_kind",
               "El archivo no coincide con el tipo solicitado.",
             );
           }
-          if (
-            state.session.assetRole === "thumbnail" &&
-            mediaKind !== "image"
-          ) {
+          if (session.assetRole === "thumbnail" && mediaKind !== "image") {
             throw validationError(
               "thumbnail_requires_image",
               "La miniatura debe ser una imagen.",
@@ -1818,35 +1937,33 @@
           });
         }
 
-        async function uploadWithRetries(item) {
+        async function uploadWithRetries(item, work) {
           let lastError = null;
           for (let attempt = 1; attempt <= MAX_UPLOAD_ATTEMPTS; attempt += 1) {
+            requireCurrentUploadWork(work);
             item.attempts = attempt;
             item.status = "uploading";
             item.progress = 0;
             renderItems();
             try {
-              const resolved = await resolveUpload(
-                item.uploadFile,
-                item.uploadId,
-              );
-              // From here the server holds a slot for this assetId until the
-              // object lands or the TTL expires.
-              item.slotReserved = true;
+              const resolved = await resolveUpload(item, work);
+              requireCurrentUploadWork(work);
               await putFileWithProgress(
                 resolved.uploadUrl,
                 item.uploadFile,
                 (progress) => {
+                  if (!uploadWorkIsCurrent(work)) return;
                   item.progress = progress;
                   renderItems();
                 },
               );
+              requireCurrentUploadWork(work);
               item.assetId = resolved.assetId;
               return;
             } catch (error) {
               if (error && error.message === "session_expired") throw error;
               if (error && error.permanent) throw error;
-              if (state.disposed || state.workCancelled) throw error;
+              if (!uploadWorkIsCurrent(work)) throw error;
               lastError = error;
             }
           }
@@ -1863,17 +1980,8 @@
           throw error;
         }
 
-        /**
-         * Classifies a failed resolve.
-         *
-         * 410 means the upload link is spent and the whole session is dead; any
-         * other 4xx means the API refused this particular file (unsupported type,
-         * session already at its file limit). Both are deterministic, and
-         * retrying them three times only produced three identical failures before
-         * telling the user to "retry" something that could never succeed. Only a
-         * server fault or a network blip earns another attempt, so anything below
-         * 500 stops at once and carries the server's own reason to the card.
-         */
+        // Deterministic API refusals stop immediately. Transport timeouts and
+        // throttling remain retryable within the same bounded upload identity.
         async function resolveFailure(response) {
           const status = response.status;
           const expired = status === 401 || status === 410;
@@ -1882,7 +1990,7 @@
           );
           error.safeCode = expired ? "session_expired" : "resolve_rejected";
           error.safeStage = "resolve";
-          error.permanent = status < 500;
+          error.permanent = status < 500 && ![408, 425, 429].includes(status);
           error.safeMessage = await resolveFailureMessage(response);
           return error;
         }
@@ -1928,12 +2036,15 @@
          * still frees the slot on its own, so no error here may reach the user.
          */
         async function releaseUploadSlot(item) {
-          if (!item || !item.slotReserved || !state.session) return;
+          if (!item || !item.slotReserved || !item.work) return;
           item.slotReserved = false;
           try {
-            const uploadPage = new URL(state.session.uploadPageUrl);
+            const uploadPage = new URL(item.work.session.uploadPageUrl);
             const releaseUrl = new URL(
-              state.session.resolveEndpoint.replace(/\/resolve$/, "/release"),
+              item.work.session.resolveEndpoint.replace(
+                /\/resolve$/,
+                "/release",
+              ),
               uploadPage.origin,
             );
             if (!safeReleaseEndpointUrl(releaseUrl)) return;
@@ -1953,10 +2064,11 @@
           }
         }
 
-        async function resolveUpload(file, uploadId) {
-          const uploadPage = new URL(state.session.uploadPageUrl);
+        async function resolveUpload(item, work) {
+          requireCurrentUploadWork(work);
+          const uploadPage = new URL(work.session.uploadPageUrl);
           const resolveUrl = new URL(
-            state.session.resolveEndpoint,
+            work.session.resolveEndpoint,
             uploadPage.origin,
           );
           if (
@@ -1977,26 +2089,41 @@
             headers: { "content-type": "application/json" },
             body: JSON.stringify({
               token,
-              uploadId,
-              contentType: file.type,
-              fileName: file.name,
-              fileSize: file.size,
+              uploadId: item.uploadId,
+              contentType: item.uploadFile.type,
+              fileName: item.uploadFile.name,
+              fileSize: item.uploadFile.size,
             }),
             credentials: "omit",
             redirect: "error",
-            signal: activeAbortSignal(),
+            signal: work.signal,
           });
           if (!response.ok) {
             throw await resolveFailure(response);
           }
+          // A successful resolver response already owns a server reservation,
+          // even if its body is invalid or this session was replaced meanwhile.
+          // Track it before parsing so terminal cleanup releases the original slot.
+          item.slotReserved = true;
+          requireCurrentUploadWork(work);
           const body = await response.json();
           if (!isRecord(body)) throw new Error("invalid_resolve_response");
-          const uploadUrl = boundedString(body.uploadUrl, 3000);
           const assetId = boundedString(body.assetId, 300);
-          const parsedUploadUrl = new URL(uploadUrl);
-          if (!safeWebProtocol(parsedUploadUrl) || !assetId) {
+          let parsedUploadUrl;
+          try {
+            if (
+              typeof body.uploadUrl !== "string" ||
+              !body.uploadUrl ||
+              body.uploadUrl.length > 3000
+            )
+              throw new Error("invalid_resolve_response");
+            parsedUploadUrl = new URL(body.uploadUrl);
+            if (!safeWebProtocol(parsedUploadUrl) || !assetId)
+              throw new Error("invalid_resolve_response");
+          } catch {
             const error = new Error("invalid_resolve_response");
             error.safeStage = "resolve";
+            error.permanent = true;
             throw error;
           }
           return { uploadUrl: parsedUploadUrl.toString(), assetId };
@@ -2140,6 +2267,9 @@
             request.addEventListener("timeout", () =>
               finish(() => reject(uploadTransportError("upload_timeout"))),
             );
+            request.addEventListener("abort", () =>
+              finish(() => reject(uploadTransportError("upload_cancelled"))),
+            );
             request.send(file);
           });
         }
@@ -2183,8 +2313,10 @@
             item.failureCode === "resolve_rejected"
           )
             return;
+          const work = item.work;
+          if (!uploadWorkIsCurrent(work)) return;
           item.attempts = 0;
-          await prepareAndUpload(item);
+          await prepareAndUpload(item, work);
           if (item.status === "uploaded") await refreshSessionStatus();
         }
 
@@ -2245,6 +2377,7 @@
           let source;
           try {
             source = await decodeImageSource(item.file);
+            if (item.work && !uploadWorkIsCurrent(item.work)) return;
             const { width, height } = sourceDimensions(source);
             if (!validDimension(width) || !validDimension(height)) return;
             const scale = Math.min(
@@ -2423,6 +2556,7 @@
         async function refreshSessionStatus({ onMount = false } = {}) {
           if (!state.session) return;
           const requestedSessionId = state.session.sessionId;
+          const requestedGeneration = state.sessionGeneration;
           if (!onMount)
             setSessionStatus("Comprobando el staging privado…", "neutral");
           try {
@@ -2432,7 +2566,8 @@
             if (
               state.disposed ||
               !state.session ||
-              state.session.sessionId !== requestedSessionId
+              state.session.sessionId !== requestedSessionId ||
+              state.sessionGeneration !== requestedGeneration
             )
               return;
             const status = parseStatusResult(result);
@@ -2476,7 +2611,13 @@
               partial ? "warning" : "success",
             );
           } catch (error) {
-            if (onMount) return;
+            if (
+              onMount ||
+              state.disposed ||
+              state.session?.sessionId !== requestedSessionId ||
+              state.sessionGeneration !== requestedGeneration
+            )
+              return;
             const expired =
               sessionExpired() ||
               (error && /expired|expirad/i.test(String(error.message)));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@productmaker/mcp",
-  "version": "12.2.6",
+  "version": "12.2.8",
   "type": "module",
   "private": false,
   "description": "ProductMaker MCP server — cost products, generate landing pages, UGC videos, and ad creatives, and publish to Shopify, Meta Ads, and TikTok Ads.",