@wix/mcp 1.0.88 → 1.0.89

package/build/bin-standalone.js

@@ -71737,32 +71737,49 @@ var ACCOUNT_SITE_EXECUTE_SCOPE = dedent_default`
     request<T = unknown>(options: WixRequestOptions): Promise<WixResponse<T>>;
     // Build a multipart/form-data body from files (defaults to the \`files\`
     // global). Each file becomes a part named fieldName (default "files") with
-    // its path as the filename. Pass body + contentType to wix.request.
+    // its path as the filename; \`body\` is bytes so binary parts stay intact.
+    // Pass a base64 entry for binary (an image/font): { path, base64 }, or a
+    // \`files\`-param entry tagged \`base64\`.
     multipart(
-      files?: Array<{ path: string; content: string; contentType?: string }>,
+      files?: Array<{ path: string; content?: string; base64?: string; bytes?: Uint8Array; contentType?: string }>,
       options?: { fieldName?: string }
-    ): { body: string; contentType: string };
+    ): { body: Uint8Array; contentType: string };
+    // Unzip a downloaded site archive (base64 string or bytes) into entries with
+    // RAW bytes (binary-safe); entry.text() decodes a text file. Entries can be
+    // passed straight back to wix.multipart() for a re-upload.
+    unzip(input: string | Uint8Array): Promise<Array<{ path: string; bytes: Uint8Array; text(): string }>>;
   };
   declare const siteId: string | undefined;
-  // Files from the ExecuteWixAPI \`files\` param (raw content, no escaping).
-  declare const files: Array<{ path: string; content: string }>;
+  // Files from the ExecuteWixAPI \`files\` param. Text entries have \`content\`;
+  // an entry tagged \`=== FILE: <path> base64 ===\` has encoding:'base64' and
+  // base64 \`content\` (a binary file — image, font).
+  declare const files: Array<{ path: string; content: string; encoding?: "base64" }>;
   \`\`\`
 
-  FILE UPLOADS: pass file bodies via the \`files\` param (not inside \`code\` — no escaping), then build the multipart body with \`wix.multipart()\`:
+  FILE UPLOADS: put every file in the \`files\` param (never inline in \`code\`). Text goes raw; a small binary (icon, logo, font) rides as a \`base64\`-tagged entry — large images/video are referenced by URL (\`<img src="https://...">\`), not bundled. \`wix.multipart()\` turns the whole set into one upload body (bytes, so binary is safe):
   \`\`\`javascript
-  // files param: "=== FILE: index.html ===\\n<!doctype html>...\\n=== FILE: app.js ===\\nconsole.log(1)"
+  // files param:
+  //   === FILE: index.html ===
+  //   <!doctype html><img src="logo.png">...
+  //   === FILE: logo.png base64 ===
+  //   iVBORw0KGgoAAA...
   async () => {
-    const mp = wix.multipart(); // parts named "files", filename = each path
-    const res = await wix.request({
-      scope: "account",
-      method: "POST",
-      url: "https://www.wixapis.com/.../upload",
-      headers: { "Content-Type": mp.contentType },
-      body: mp.body
-    });
+    const mp = wix.multipart(); // all entries from the files param; base64 ones decoded to raw bytes
+    const res = await wix.request({ scope: "account", method: "POST",
+      url: "https://www.wixapis.com/.../drop",
+      headers: { "Content-Type": mp.contentType }, body: mp.body });
     return res.data;
   }
   \`\`\`
+  DOWNLOAD + EDIT + RE-UPLOAD: fetch the zip as base64, \`wix.unzip()\` it, edit text via \`entry.text()\`, keep binary as bytes, and hand the entries back to \`wix.multipart()\`:
+  \`\`\`javascript
+  const r = await wix.request({ scope: "account", method: "GET", responseType: "base64", url: zipUrl });
+  const entries = await wix.unzip(r.data); // [{ path, bytes, text() }]
+  const edited = entries.map(e => e.path === "index.html"
+    ? { path: e.path, content: e.text().replace("Old title", "New title") }
+    : e); // images etc. pass through untouched as bytes
+  const mp = wix.multipart(edited);
+  \`\`\`
 `;
 var EXECUTE_WIX_API_WQL = dedent_default`
   For query and search endpoints: each endpoint declares which fields it can filter and sort by, and with which operators. That list is closed for fields and their operators and covers that endpoint only, and a field's presence in the response is no evidence it can be filtered on. It lives in the method's declared capabilities, and some resources also publish it as a "Supported Filters and Sorting" page. Logical operators are WQL syntax rather than field capabilities and never appear in it. Anything else errors or silently returns the wrong rows; fetch a bounded page and filter it in your own code instead.

package/build/cjs/index.cjs

@@ -37353,32 +37353,49 @@ var ACCOUNT_SITE_EXECUTE_SCOPE = dedent_default`
     request<T = unknown>(options: WixRequestOptions): Promise<WixResponse<T>>;
     // Build a multipart/form-data body from files (defaults to the \`files\`
     // global). Each file becomes a part named fieldName (default "files") with
-    // its path as the filename. Pass body + contentType to wix.request.
+    // its path as the filename; \`body\` is bytes so binary parts stay intact.
+    // Pass a base64 entry for binary (an image/font): { path, base64 }, or a
+    // \`files\`-param entry tagged \`base64\`.
     multipart(
-      files?: Array<{ path: string; content: string; contentType?: string }>,
+      files?: Array<{ path: string; content?: string; base64?: string; bytes?: Uint8Array; contentType?: string }>,
       options?: { fieldName?: string }
-    ): { body: string; contentType: string };
+    ): { body: Uint8Array; contentType: string };
+    // Unzip a downloaded site archive (base64 string or bytes) into entries with
+    // RAW bytes (binary-safe); entry.text() decodes a text file. Entries can be
+    // passed straight back to wix.multipart() for a re-upload.
+    unzip(input: string | Uint8Array): Promise<Array<{ path: string; bytes: Uint8Array; text(): string }>>;
   };
   declare const siteId: string | undefined;
-  // Files from the ExecuteWixAPI \`files\` param (raw content, no escaping).
-  declare const files: Array<{ path: string; content: string }>;
+  // Files from the ExecuteWixAPI \`files\` param. Text entries have \`content\`;
+  // an entry tagged \`=== FILE: <path> base64 ===\` has encoding:'base64' and
+  // base64 \`content\` (a binary file — image, font).
+  declare const files: Array<{ path: string; content: string; encoding?: "base64" }>;
   \`\`\`
 
-  FILE UPLOADS: pass file bodies via the \`files\` param (not inside \`code\` — no escaping), then build the multipart body with \`wix.multipart()\`:
+  FILE UPLOADS: put every file in the \`files\` param (never inline in \`code\`). Text goes raw; a small binary (icon, logo, font) rides as a \`base64\`-tagged entry — large images/video are referenced by URL (\`<img src="https://...">\`), not bundled. \`wix.multipart()\` turns the whole set into one upload body (bytes, so binary is safe):
   \`\`\`javascript
-  // files param: "=== FILE: index.html ===\\n<!doctype html>...\\n=== FILE: app.js ===\\nconsole.log(1)"
+  // files param:
+  //   === FILE: index.html ===
+  //   <!doctype html><img src="logo.png">...
+  //   === FILE: logo.png base64 ===
+  //   iVBORw0KGgoAAA...
   async () => {
-    const mp = wix.multipart(); // parts named "files", filename = each path
-    const res = await wix.request({
-      scope: "account",
-      method: "POST",
-      url: "https://www.wixapis.com/.../upload",
-      headers: { "Content-Type": mp.contentType },
-      body: mp.body
-    });
+    const mp = wix.multipart(); // all entries from the files param; base64 ones decoded to raw bytes
+    const res = await wix.request({ scope: "account", method: "POST",
+      url: "https://www.wixapis.com/.../drop",
+      headers: { "Content-Type": mp.contentType }, body: mp.body });
     return res.data;
   }
   \`\`\`
+  DOWNLOAD + EDIT + RE-UPLOAD: fetch the zip as base64, \`wix.unzip()\` it, edit text via \`entry.text()\`, keep binary as bytes, and hand the entries back to \`wix.multipart()\`:
+  \`\`\`javascript
+  const r = await wix.request({ scope: "account", method: "GET", responseType: "base64", url: zipUrl });
+  const entries = await wix.unzip(r.data); // [{ path, bytes, text() }]
+  const edited = entries.map(e => e.path === "index.html"
+    ? { path: e.path, content: e.text().replace("Old title", "New title") }
+    : e); // images etc. pass through untouched as bytes
+  const mp = wix.multipart(edited);
+  \`\`\`
 `;
 var EXECUTE_WIX_API_WQL = dedent_default`
   For query and search endpoints: each endpoint declares which fields it can filter and sort by, and with which operators. That list is closed for fields and their operators and covers that endpoint only, and a field's presence in the response is no evidence it can be filtered on. It lives in the method's declared capabilities, and some resources also publish it as a "Supported Filters and Sorting" page. Logical operators are WQL syntax rather than field capabilities and never appear in it. Anything else errors or silently returns the wrong rows; fetch a bounded page and filter it in your own code instead.
@@ -53183,10 +53200,11 @@ function addExecuteTool(server, options) {
       sourceDocUrls: external_exports.array(external_exports.string()).describe(d2.sourceDocUrls),
       files: external_exports.string().optional().describe(
         [
-          "Optional bundle of raw file contents for uploads, so file bytes never go through the `code` JavaScript (no escaping, no string-literal/`${}`/backtick pitfalls).",
-          "Format: one or more sections, each a line `=== FILE: <path> ===` on its own, followed by that file's raw text content; `<path>` is the path relative to the site root (e.g. `index.html`, `assets/app.js`). Example: `=== FILE: index.html ===\\n<!doctype html>...\\n=== FILE: assets/app.js ===\\nconsole.log(1)`.",
-          'In `code`, the parsed files are the `files` global (array of `{ path, content }`), and `wix.multipart(files)` returns `{ body, contentType }` for a `multipart/form-data` upload \u2014 e.g. `const mp = wix.multipart(); await wix.request({ scope: "account", method: "POST", url, headers: { "Content-Type": mp.contentType }, body: mp.body });`.',
-          "Text files only; for binary assets pass bytes as a base64 request body instead. A file whose content itself contains a line exactly like the delimiter is not supported."
+          "Optional bundle of raw file contents for uploads, so file bytes never go through the `code` JavaScript (no escaping, no string-literal/`${}`/backtick pitfalls). Never inline file contents in `code`.",
+          "Format: sections delimited by a line `=== FILE: <path> ===` (text, raw) or `=== FILE: <path> base64 ===` (binary, base64); `<path>` is relative to the site root. Example:",
+          '`=== FILE: index.html ===\\n<!doctype html><img src="logo.png">\\n=== FILE: assets/app.js ===\\nconsole.log(1)\\n=== FILE: logo.png base64 ===\\niVBORw0KGgo...`',
+          'In `code` they are the `files` global (`{ path, content, encoding?: "base64" }[]`); `wix.multipart()` turns them into one binary-safe `multipart/form-data` body: `const mp = wix.multipart(); await wix.request({ scope: "account", method: "POST", url, headers: { "Content-Type": mp.contentType }, body: mp.body });`.',
+          'Use base64 entries for small assets (icons, logos, fonts) and for files you downloaded and are re-uploading; large images/video go in by URL (`<img src="https://...">`), not in the bundle. A file containing a line exactly like the delimiter is not supported.'
         ].join(" ")
       ),
       // Visitor mode takes an agent-supplied token and pins the site; account/site

package/build/cjs/toolkit.cjs

@@ -17840,32 +17840,49 @@ var ACCOUNT_SITE_EXECUTE_SCOPE = dedent_default`
     request<T = unknown>(options: WixRequestOptions): Promise<WixResponse<T>>;
     // Build a multipart/form-data body from files (defaults to the \`files\`
     // global). Each file becomes a part named fieldName (default "files") with
-    // its path as the filename. Pass body + contentType to wix.request.
+    // its path as the filename; \`body\` is bytes so binary parts stay intact.
+    // Pass a base64 entry for binary (an image/font): { path, base64 }, or a
+    // \`files\`-param entry tagged \`base64\`.
     multipart(
-      files?: Array<{ path: string; content: string; contentType?: string }>,
+      files?: Array<{ path: string; content?: string; base64?: string; bytes?: Uint8Array; contentType?: string }>,
       options?: { fieldName?: string }
-    ): { body: string; contentType: string };
+    ): { body: Uint8Array; contentType: string };
+    // Unzip a downloaded site archive (base64 string or bytes) into entries with
+    // RAW bytes (binary-safe); entry.text() decodes a text file. Entries can be
+    // passed straight back to wix.multipart() for a re-upload.
+    unzip(input: string | Uint8Array): Promise<Array<{ path: string; bytes: Uint8Array; text(): string }>>;
   };
   declare const siteId: string | undefined;
-  // Files from the ExecuteWixAPI \`files\` param (raw content, no escaping).
-  declare const files: Array<{ path: string; content: string }>;
+  // Files from the ExecuteWixAPI \`files\` param. Text entries have \`content\`;
+  // an entry tagged \`=== FILE: <path> base64 ===\` has encoding:'base64' and
+  // base64 \`content\` (a binary file — image, font).
+  declare const files: Array<{ path: string; content: string; encoding?: "base64" }>;
   \`\`\`
 
-  FILE UPLOADS: pass file bodies via the \`files\` param (not inside \`code\` — no escaping), then build the multipart body with \`wix.multipart()\`:
+  FILE UPLOADS: put every file in the \`files\` param (never inline in \`code\`). Text goes raw; a small binary (icon, logo, font) rides as a \`base64\`-tagged entry — large images/video are referenced by URL (\`<img src="https://...">\`), not bundled. \`wix.multipart()\` turns the whole set into one upload body (bytes, so binary is safe):
   \`\`\`javascript
-  // files param: "=== FILE: index.html ===\\n<!doctype html>...\\n=== FILE: app.js ===\\nconsole.log(1)"
+  // files param:
+  //   === FILE: index.html ===
+  //   <!doctype html><img src="logo.png">...
+  //   === FILE: logo.png base64 ===
+  //   iVBORw0KGgoAAA...
   async () => {
-    const mp = wix.multipart(); // parts named "files", filename = each path
-    const res = await wix.request({
-      scope: "account",
-      method: "POST",
-      url: "https://www.wixapis.com/.../upload",
-      headers: { "Content-Type": mp.contentType },
-      body: mp.body
-    });
+    const mp = wix.multipart(); // all entries from the files param; base64 ones decoded to raw bytes
+    const res = await wix.request({ scope: "account", method: "POST",
+      url: "https://www.wixapis.com/.../drop",
+      headers: { "Content-Type": mp.contentType }, body: mp.body });
     return res.data;
   }
   \`\`\`
+  DOWNLOAD + EDIT + RE-UPLOAD: fetch the zip as base64, \`wix.unzip()\` it, edit text via \`entry.text()\`, keep binary as bytes, and hand the entries back to \`wix.multipart()\`:
+  \`\`\`javascript
+  const r = await wix.request({ scope: "account", method: "GET", responseType: "base64", url: zipUrl });
+  const entries = await wix.unzip(r.data); // [{ path, bytes, text() }]
+  const edited = entries.map(e => e.path === "index.html"
+    ? { path: e.path, content: e.text().replace("Old title", "New title") }
+    : e); // images etc. pass through untouched as bytes
+  const mp = wix.multipart(edited);
+  \`\`\`
 `;
 var EXECUTE_WIX_API_WQL = dedent_default`
   For query and search endpoints: each endpoint declares which fields it can filter and sort by, and with which operators. That list is closed for fields and their operators and covers that endpoint only, and a field's presence in the response is no evidence it can be filtered on. It lives in the method's declared capabilities, and some resources also publish it as a "Supported Filters and Sorting" page. Logical operators are WQL syntax rather than field capabilities and never appear in it. Anything else errors or silently returns the wrong rows; fetch a bounded page and filter it in your own code instead.
@@ -22326,10 +22343,11 @@ function addExecuteTool(server, options) {
       sourceDocUrls: external_exports.array(external_exports.string()).describe(d.sourceDocUrls),
       files: external_exports.string().optional().describe(
         [
-          "Optional bundle of raw file contents for uploads, so file bytes never go through the `code` JavaScript (no escaping, no string-literal/`${}`/backtick pitfalls).",
-          "Format: one or more sections, each a line `=== FILE: <path> ===` on its own, followed by that file's raw text content; `<path>` is the path relative to the site root (e.g. `index.html`, `assets/app.js`). Example: `=== FILE: index.html ===\\n<!doctype html>...\\n=== FILE: assets/app.js ===\\nconsole.log(1)`.",
-          'In `code`, the parsed files are the `files` global (array of `{ path, content }`), and `wix.multipart(files)` returns `{ body, contentType }` for a `multipart/form-data` upload \u2014 e.g. `const mp = wix.multipart(); await wix.request({ scope: "account", method: "POST", url, headers: { "Content-Type": mp.contentType }, body: mp.body });`.',
-          "Text files only; for binary assets pass bytes as a base64 request body instead. A file whose content itself contains a line exactly like the delimiter is not supported."
+          "Optional bundle of raw file contents for uploads, so file bytes never go through the `code` JavaScript (no escaping, no string-literal/`${}`/backtick pitfalls). Never inline file contents in `code`.",
+          "Format: sections delimited by a line `=== FILE: <path> ===` (text, raw) or `=== FILE: <path> base64 ===` (binary, base64); `<path>` is relative to the site root. Example:",
+          '`=== FILE: index.html ===\\n<!doctype html><img src="logo.png">\\n=== FILE: assets/app.js ===\\nconsole.log(1)\\n=== FILE: logo.png base64 ===\\niVBORw0KGgo...`',
+          'In `code` they are the `files` global (`{ path, content, encoding?: "base64" }[]`); `wix.multipart()` turns them into one binary-safe `multipart/form-data` body: `const mp = wix.multipart(); await wix.request({ scope: "account", method: "POST", url, headers: { "Content-Type": mp.contentType }, body: mp.body });`.',
+          'Use base64 entries for small assets (icons, logos, fonts) and for files you downloaded and are re-uploading; large images/video go in by URL (`<img src="https://...">`), not in the bundle. A file containing a line exactly like the delimiter is not supported.'
         ].join(" ")
       ),
       // Visitor mode takes an agent-supplied token and pins the site; account/site

package/build/dts/code-mode/index.js

@@ -240,10 +240,11 @@ function addExecuteTool(server, options) {
             .string()
             .optional()
             .describe([
-            'Optional bundle of raw file contents for uploads, so file bytes never go through the `code` JavaScript (no escaping, no string-literal/`${}`/backtick pitfalls).',
-            "Format: one or more sections, each a line `=== FILE: <path> ===` on its own, followed by that file's raw text content; `<path>` is the path relative to the site root (e.g. `index.html`, `assets/app.js`). Example: `=== FILE: index.html ===\\n<!doctype html>...\\n=== FILE: assets/app.js ===\\nconsole.log(1)`.",
-            'In `code`, the parsed files are the `files` global (array of `{ path, content }`), and `wix.multipart(files)` returns `{ body, contentType }` for a `multipart/form-data` upload — e.g. `const mp = wix.multipart(); await wix.request({ scope: "account", method: "POST", url, headers: { "Content-Type": mp.contentType }, body: mp.body });`.',
-            'Text files only; for binary assets pass bytes as a base64 request body instead. A file whose content itself contains a line exactly like the delimiter is not supported.'
+            'Optional bundle of raw file contents for uploads, so file bytes never go through the `code` JavaScript (no escaping, no string-literal/`${}`/backtick pitfalls). Never inline file contents in `code`.',
+            'Format: sections delimited by a line `=== FILE: <path> ===` (text, raw) or `=== FILE: <path> base64 ===` (binary, base64); `<path>` is relative to the site root. Example:',
+            '`=== FILE: index.html ===\\n<!doctype html><img src="logo.png">\\n=== FILE: assets/app.js ===\\nconsole.log(1)\\n=== FILE: logo.png base64 ===\\niVBORw0KGgo...`',
+            'In `code` they are the `files` global (`{ path, content, encoding?: "base64" }[]`); `wix.multipart()` turns them into one binary-safe `multipart/form-data` body: `const mp = wix.multipart(); await wix.request({ scope: "account", method: "POST", url, headers: { "Content-Type": mp.contentType }, body: mp.body });`.',
+            'Use base64 entries for small assets (icons, logos, fonts) and for files you downloaded and are re-uploading; large images/video go in by URL (`<img src="https://...">`), not in the bundle. A file containing a line exactly like the delimiter is not supported.'
         ].join(' ')),
         // Visitor mode takes an agent-supplied token and pins the site; account/site
         // mode lets the agent pick the site.

package/build/dts/config/default-config.js

@@ -167,32 +167,49 @@ const ACCOUNT_SITE_EXECUTE_SCOPE = dedent `
     request<T = unknown>(options: WixRequestOptions): Promise<WixResponse<T>>;
     // Build a multipart/form-data body from files (defaults to the \`files\`
     // global). Each file becomes a part named fieldName (default "files") with
-    // its path as the filename. Pass body + contentType to wix.request.
+    // its path as the filename; \`body\` is bytes so binary parts stay intact.
+    // Pass a base64 entry for binary (an image/font): { path, base64 }, or a
+    // \`files\`-param entry tagged \`base64\`.
     multipart(
-      files?: Array<{ path: string; content: string; contentType?: string }>,
+      files?: Array<{ path: string; content?: string; base64?: string; bytes?: Uint8Array; contentType?: string }>,
       options?: { fieldName?: string }
-    ): { body: string; contentType: string };
+    ): { body: Uint8Array; contentType: string };
+    // Unzip a downloaded site archive (base64 string or bytes) into entries with
+    // RAW bytes (binary-safe); entry.text() decodes a text file. Entries can be
+    // passed straight back to wix.multipart() for a re-upload.
+    unzip(input: string | Uint8Array): Promise<Array<{ path: string; bytes: Uint8Array; text(): string }>>;
   };
   declare const siteId: string | undefined;
-  // Files from the ExecuteWixAPI \`files\` param (raw content, no escaping).
-  declare const files: Array<{ path: string; content: string }>;
+  // Files from the ExecuteWixAPI \`files\` param. Text entries have \`content\`;
+  // an entry tagged \`=== FILE: <path> base64 ===\` has encoding:'base64' and
+  // base64 \`content\` (a binary file — image, font).
+  declare const files: Array<{ path: string; content: string; encoding?: "base64" }>;
   \`\`\`
 
-  FILE UPLOADS: pass file bodies via the \`files\` param (not inside \`code\` — no escaping), then build the multipart body with \`wix.multipart()\`:
+  FILE UPLOADS: put every file in the \`files\` param (never inline in \`code\`). Text goes raw; a small binary (icon, logo, font) rides as a \`base64\`-tagged entry — large images/video are referenced by URL (\`<img src="https://...">\`), not bundled. \`wix.multipart()\` turns the whole set into one upload body (bytes, so binary is safe):
   \`\`\`javascript
-  // files param: "=== FILE: index.html ===\\n<!doctype html>...\\n=== FILE: app.js ===\\nconsole.log(1)"
+  // files param:
+  //   === FILE: index.html ===
+  //   <!doctype html><img src="logo.png">...
+  //   === FILE: logo.png base64 ===
+  //   iVBORw0KGgoAAA...
   async () => {
-    const mp = wix.multipart(); // parts named "files", filename = each path
-    const res = await wix.request({
-      scope: "account",
-      method: "POST",
-      url: "https://www.wixapis.com/.../upload",
-      headers: { "Content-Type": mp.contentType },
-      body: mp.body
-    });
+    const mp = wix.multipart(); // all entries from the files param; base64 ones decoded to raw bytes
+    const res = await wix.request({ scope: "account", method: "POST",
+      url: "https://www.wixapis.com/.../drop",
+      headers: { "Content-Type": mp.contentType }, body: mp.body });
     return res.data;
   }
   \`\`\`
+  DOWNLOAD + EDIT + RE-UPLOAD: fetch the zip as base64, \`wix.unzip()\` it, edit text via \`entry.text()\`, keep binary as bytes, and hand the entries back to \`wix.multipart()\`:
+  \`\`\`javascript
+  const r = await wix.request({ scope: "account", method: "GET", responseType: "base64", url: zipUrl });
+  const entries = await wix.unzip(r.data); // [{ path, bytes, text() }]
+  const edited = entries.map(e => e.path === "index.html"
+    ? { path: e.path, content: e.text().replace("Old title", "New title") }
+    : e); // images etc. pass through untouched as bytes
+  const mp = wix.multipart(edited);
+  \`\`\`
 `;
 const EXECUTE_WIX_API_WQL = dedent `
   For query and search endpoints: each endpoint declares which fields it can filter and sort by, and with which operators. That list is closed for fields and their operators and covers that endpoint only, and a field's presence in the response is no evidence it can be filtered on. It lives in the method's declared capabilities, and some resources also publish it as a "Supported Filters and Sorting" page. Logical operators are WQL syntax rather than field capabilities and never appear in it. Anything else errors or silently returns the wrong rows; fetch a bounded page and filter it in your own code instead.

package/build/esm/index.js

@@ -31066,32 +31066,49 @@ var ACCOUNT_SITE_EXECUTE_SCOPE = dedent_default`
     request<T = unknown>(options: WixRequestOptions): Promise<WixResponse<T>>;
     // Build a multipart/form-data body from files (defaults to the \`files\`
     // global). Each file becomes a part named fieldName (default "files") with
-    // its path as the filename. Pass body + contentType to wix.request.
+    // its path as the filename; \`body\` is bytes so binary parts stay intact.
+    // Pass a base64 entry for binary (an image/font): { path, base64 }, or a
+    // \`files\`-param entry tagged \`base64\`.
     multipart(
-      files?: Array<{ path: string; content: string; contentType?: string }>,
+      files?: Array<{ path: string; content?: string; base64?: string; bytes?: Uint8Array; contentType?: string }>,
       options?: { fieldName?: string }
-    ): { body: string; contentType: string };
+    ): { body: Uint8Array; contentType: string };
+    // Unzip a downloaded site archive (base64 string or bytes) into entries with
+    // RAW bytes (binary-safe); entry.text() decodes a text file. Entries can be
+    // passed straight back to wix.multipart() for a re-upload.
+    unzip(input: string | Uint8Array): Promise<Array<{ path: string; bytes: Uint8Array; text(): string }>>;
   };
   declare const siteId: string | undefined;
-  // Files from the ExecuteWixAPI \`files\` param (raw content, no escaping).
-  declare const files: Array<{ path: string; content: string }>;
+  // Files from the ExecuteWixAPI \`files\` param. Text entries have \`content\`;
+  // an entry tagged \`=== FILE: <path> base64 ===\` has encoding:'base64' and
+  // base64 \`content\` (a binary file — image, font).
+  declare const files: Array<{ path: string; content: string; encoding?: "base64" }>;
   \`\`\`
 
-  FILE UPLOADS: pass file bodies via the \`files\` param (not inside \`code\` — no escaping), then build the multipart body with \`wix.multipart()\`:
+  FILE UPLOADS: put every file in the \`files\` param (never inline in \`code\`). Text goes raw; a small binary (icon, logo, font) rides as a \`base64\`-tagged entry — large images/video are referenced by URL (\`<img src="https://...">\`), not bundled. \`wix.multipart()\` turns the whole set into one upload body (bytes, so binary is safe):
   \`\`\`javascript
-  // files param: "=== FILE: index.html ===\\n<!doctype html>...\\n=== FILE: app.js ===\\nconsole.log(1)"
+  // files param:
+  //   === FILE: index.html ===
+  //   <!doctype html><img src="logo.png">...
+  //   === FILE: logo.png base64 ===
+  //   iVBORw0KGgoAAA...
   async () => {
-    const mp = wix.multipart(); // parts named "files", filename = each path
-    const res = await wix.request({
-      scope: "account",
-      method: "POST",
-      url: "https://www.wixapis.com/.../upload",
-      headers: { "Content-Type": mp.contentType },
-      body: mp.body
-    });
+    const mp = wix.multipart(); // all entries from the files param; base64 ones decoded to raw bytes
+    const res = await wix.request({ scope: "account", method: "POST",
+      url: "https://www.wixapis.com/.../drop",
+      headers: { "Content-Type": mp.contentType }, body: mp.body });
     return res.data;
   }
   \`\`\`
+  DOWNLOAD + EDIT + RE-UPLOAD: fetch the zip as base64, \`wix.unzip()\` it, edit text via \`entry.text()\`, keep binary as bytes, and hand the entries back to \`wix.multipart()\`:
+  \`\`\`javascript
+  const r = await wix.request({ scope: "account", method: "GET", responseType: "base64", url: zipUrl });
+  const entries = await wix.unzip(r.data); // [{ path, bytes, text() }]
+  const edited = entries.map(e => e.path === "index.html"
+    ? { path: e.path, content: e.text().replace("Old title", "New title") }
+    : e); // images etc. pass through untouched as bytes
+  const mp = wix.multipart(edited);
+  \`\`\`
 `;
 var EXECUTE_WIX_API_WQL = dedent_default`
   For query and search endpoints: each endpoint declares which fields it can filter and sort by, and with which operators. That list is closed for fields and their operators and covers that endpoint only, and a field's presence in the response is no evidence it can be filtered on. It lives in the method's declared capabilities, and some resources also publish it as a "Supported Filters and Sorting" page. Logical operators are WQL syntax rather than field capabilities and never appear in it. Anything else errors or silently returns the wrong rows; fetch a bounded page and filter it in your own code instead.
@@ -46947,10 +46964,11 @@ function addExecuteTool(server, options) {
       sourceDocUrls: external_exports.array(external_exports.string()).describe(d2.sourceDocUrls),
       files: external_exports.string().optional().describe(
         [
-          "Optional bundle of raw file contents for uploads, so file bytes never go through the `code` JavaScript (no escaping, no string-literal/`${}`/backtick pitfalls).",
-          "Format: one or more sections, each a line `=== FILE: <path> ===` on its own, followed by that file's raw text content; `<path>` is the path relative to the site root (e.g. `index.html`, `assets/app.js`). Example: `=== FILE: index.html ===\\n<!doctype html>...\\n=== FILE: assets/app.js ===\\nconsole.log(1)`.",
-          'In `code`, the parsed files are the `files` global (array of `{ path, content }`), and `wix.multipart(files)` returns `{ body, contentType }` for a `multipart/form-data` upload \u2014 e.g. `const mp = wix.multipart(); await wix.request({ scope: "account", method: "POST", url, headers: { "Content-Type": mp.contentType }, body: mp.body });`.',
-          "Text files only; for binary assets pass bytes as a base64 request body instead. A file whose content itself contains a line exactly like the delimiter is not supported."
+          "Optional bundle of raw file contents for uploads, so file bytes never go through the `code` JavaScript (no escaping, no string-literal/`${}`/backtick pitfalls). Never inline file contents in `code`.",
+          "Format: sections delimited by a line `=== FILE: <path> ===` (text, raw) or `=== FILE: <path> base64 ===` (binary, base64); `<path>` is relative to the site root. Example:",
+          '`=== FILE: index.html ===\\n<!doctype html><img src="logo.png">\\n=== FILE: assets/app.js ===\\nconsole.log(1)\\n=== FILE: logo.png base64 ===\\niVBORw0KGgo...`',
+          'In `code` they are the `files` global (`{ path, content, encoding?: "base64" }[]`); `wix.multipart()` turns them into one binary-safe `multipart/form-data` body: `const mp = wix.multipart(); await wix.request({ scope: "account", method: "POST", url, headers: { "Content-Type": mp.contentType }, body: mp.body });`.',
+          'Use base64 entries for small assets (icons, logos, fonts) and for files you downloaded and are re-uploading; large images/video go in by URL (`<img src="https://...">`), not in the bundle. A file containing a line exactly like the delimiter is not supported.'
         ].join(" ")
       ),
       // Visitor mode takes an agent-supplied token and pins the site; account/site

package/build/esm/toolkit.js

@@ -12262,32 +12262,49 @@ var ACCOUNT_SITE_EXECUTE_SCOPE = dedent_default`
     request<T = unknown>(options: WixRequestOptions): Promise<WixResponse<T>>;
     // Build a multipart/form-data body from files (defaults to the \`files\`
     // global). Each file becomes a part named fieldName (default "files") with
-    // its path as the filename. Pass body + contentType to wix.request.
+    // its path as the filename; \`body\` is bytes so binary parts stay intact.
+    // Pass a base64 entry for binary (an image/font): { path, base64 }, or a
+    // \`files\`-param entry tagged \`base64\`.
     multipart(
-      files?: Array<{ path: string; content: string; contentType?: string }>,
+      files?: Array<{ path: string; content?: string; base64?: string; bytes?: Uint8Array; contentType?: string }>,
       options?: { fieldName?: string }
-    ): { body: string; contentType: string };
+    ): { body: Uint8Array; contentType: string };
+    // Unzip a downloaded site archive (base64 string or bytes) into entries with
+    // RAW bytes (binary-safe); entry.text() decodes a text file. Entries can be
+    // passed straight back to wix.multipart() for a re-upload.
+    unzip(input: string | Uint8Array): Promise<Array<{ path: string; bytes: Uint8Array; text(): string }>>;
   };
   declare const siteId: string | undefined;
-  // Files from the ExecuteWixAPI \`files\` param (raw content, no escaping).
-  declare const files: Array<{ path: string; content: string }>;
+  // Files from the ExecuteWixAPI \`files\` param. Text entries have \`content\`;
+  // an entry tagged \`=== FILE: <path> base64 ===\` has encoding:'base64' and
+  // base64 \`content\` (a binary file — image, font).
+  declare const files: Array<{ path: string; content: string; encoding?: "base64" }>;
   \`\`\`
 
-  FILE UPLOADS: pass file bodies via the \`files\` param (not inside \`code\` — no escaping), then build the multipart body with \`wix.multipart()\`:
+  FILE UPLOADS: put every file in the \`files\` param (never inline in \`code\`). Text goes raw; a small binary (icon, logo, font) rides as a \`base64\`-tagged entry — large images/video are referenced by URL (\`<img src="https://...">\`), not bundled. \`wix.multipart()\` turns the whole set into one upload body (bytes, so binary is safe):
   \`\`\`javascript
-  // files param: "=== FILE: index.html ===\\n<!doctype html>...\\n=== FILE: app.js ===\\nconsole.log(1)"
+  // files param:
+  //   === FILE: index.html ===
+  //   <!doctype html><img src="logo.png">...
+  //   === FILE: logo.png base64 ===
+  //   iVBORw0KGgoAAA...
   async () => {
-    const mp = wix.multipart(); // parts named "files", filename = each path
-    const res = await wix.request({
-      scope: "account",
-      method: "POST",
-      url: "https://www.wixapis.com/.../upload",
-      headers: { "Content-Type": mp.contentType },
-      body: mp.body
-    });
+    const mp = wix.multipart(); // all entries from the files param; base64 ones decoded to raw bytes
+    const res = await wix.request({ scope: "account", method: "POST",
+      url: "https://www.wixapis.com/.../drop",
+      headers: { "Content-Type": mp.contentType }, body: mp.body });
     return res.data;
   }
   \`\`\`
+  DOWNLOAD + EDIT + RE-UPLOAD: fetch the zip as base64, \`wix.unzip()\` it, edit text via \`entry.text()\`, keep binary as bytes, and hand the entries back to \`wix.multipart()\`:
+  \`\`\`javascript
+  const r = await wix.request({ scope: "account", method: "GET", responseType: "base64", url: zipUrl });
+  const entries = await wix.unzip(r.data); // [{ path, bytes, text() }]
+  const edited = entries.map(e => e.path === "index.html"
+    ? { path: e.path, content: e.text().replace("Old title", "New title") }
+    : e); // images etc. pass through untouched as bytes
+  const mp = wix.multipart(edited);
+  \`\`\`
 `;
 var EXECUTE_WIX_API_WQL = dedent_default`
   For query and search endpoints: each endpoint declares which fields it can filter and sort by, and with which operators. That list is closed for fields and their operators and covers that endpoint only, and a field's presence in the response is no evidence it can be filtered on. It lives in the method's declared capabilities, and some resources also publish it as a "Supported Filters and Sorting" page. Logical operators are WQL syntax rather than field capabilities and never appear in it. Anything else errors or silently returns the wrong rows; fetch a bounded page and filter it in your own code instead.
@@ -16745,10 +16762,11 @@ function addExecuteTool(server, options) {
       sourceDocUrls: external_exports.array(external_exports.string()).describe(d.sourceDocUrls),
       files: external_exports.string().optional().describe(
         [
-          "Optional bundle of raw file contents for uploads, so file bytes never go through the `code` JavaScript (no escaping, no string-literal/`${}`/backtick pitfalls).",
-          "Format: one or more sections, each a line `=== FILE: <path> ===` on its own, followed by that file's raw text content; `<path>` is the path relative to the site root (e.g. `index.html`, `assets/app.js`). Example: `=== FILE: index.html ===\\n<!doctype html>...\\n=== FILE: assets/app.js ===\\nconsole.log(1)`.",
-          'In `code`, the parsed files are the `files` global (array of `{ path, content }`), and `wix.multipart(files)` returns `{ body, contentType }` for a `multipart/form-data` upload \u2014 e.g. `const mp = wix.multipart(); await wix.request({ scope: "account", method: "POST", url, headers: { "Content-Type": mp.contentType }, body: mp.body });`.',
-          "Text files only; for binary assets pass bytes as a base64 request body instead. A file whose content itself contains a line exactly like the delimiter is not supported."
+          "Optional bundle of raw file contents for uploads, so file bytes never go through the `code` JavaScript (no escaping, no string-literal/`${}`/backtick pitfalls). Never inline file contents in `code`.",
+          "Format: sections delimited by a line `=== FILE: <path> ===` (text, raw) or `=== FILE: <path> base64 ===` (binary, base64); `<path>` is relative to the site root. Example:",
+          '`=== FILE: index.html ===\\n<!doctype html><img src="logo.png">\\n=== FILE: assets/app.js ===\\nconsole.log(1)\\n=== FILE: logo.png base64 ===\\niVBORw0KGgo...`',
+          'In `code` they are the `files` global (`{ path, content, encoding?: "base64" }[]`); `wix.multipart()` turns them into one binary-safe `multipart/form-data` body: `const mp = wix.multipart(); await wix.request({ scope: "account", method: "POST", url, headers: { "Content-Type": mp.contentType }, body: mp.body });`.',
+          'Use base64 entries for small assets (icons, logos, fonts) and for files you downloaded and are re-uploading; large images/video go in by URL (`<img src="https://...">`), not in the bundle. A file containing a line exactly like the delimiter is not supported.'
         ].join(" ")
       ),
       // Visitor mode takes an agent-supplied token and pins the site; account/site

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wix/mcp",
-  "version": "1.0.88",
+  "version": "1.0.89",
   "description": "A Model Context Protocol server for Wix AI tools",
   "bin": "./build/bin-standalone.js",
   "dependencies": {
@@ -133,5 +133,5 @@
       ]
     }
   },
-  "falconPackageHash": "ca9fecd4d1efd1afea0d159f209aea15cf9475c2edec6f5a172bd92f"
+  "falconPackageHash": "56dddfd3c4abc5ee20298c4a7f54f409dc405abaf86f58fcc82d48ab"
 }