@jay-framework/wix-media 0.19.1

package/agent-kit/designer/wix-media.md

@@ -0,0 +1,105 @@
+# Using Wix Media
+
+How to use images, video, documents, and audio from Wix Media Manager in jay-html templates.
+
+## Finding Media
+
+See the generated `references/wix-media/MEDIA-INDEX.md` for all available media with ready-to-use URLs.
+Look up media by slug, then use the URL from the table.
+
+## Image URLs
+
+### Basic usage
+
+```html
+<img src="https://static.wixstatic.com/media/{mediaId}" alt="description" />
+```
+
+### Transformed (recommended for performance)
+
+URL format: `https://static.wixstatic.com/media/{mediaId}/v1/{mode}/{params}/file.{ext}`
+
+#### Modes
+
+- **fit** — scale to fit within dimensions, preserve aspect ratio (may add padding)
+  `<img src="https://static.wixstatic.com/media/{mediaId}/v1/fit/w_800,h_600/file.jpg" alt="" />`
+- **fill** — scale to fill dimensions exactly, crop from center
+  `<img src="https://static.wixstatic.com/media/{mediaId}/v1/fill/w_800,h_600/file.jpg" alt="" />`
+- **crop** — extract a rectangle at specific coordinates
+  `<img src="https://static.wixstatic.com/media/{mediaId}/v1/crop/x_100,y_50,w_800,h_600/file.jpg" alt="" />`
+
+#### Parameters
+
+- `w_{width}` — target width (1–5000 px)
+- `h_{height}` — target height (1–5000 px)
+- `x_{x},y_{y}` — crop start position (crop mode only)
+- `q_{quality}` — JPEG quality (1–100)
+
+#### Output format (set via file extension)
+
+- `file.jpg` — JPEG (photos)
+- `file.webp` — WebP (modern, smaller)
+- `file.png` — PNG (transparency)
+- `file.gif` — GIF (animation)
+
+#### Common sizes
+
+- Thumbnail: `/v1/fill/w_100,h_100/file.jpg`
+- Card: `/v1/fill/w_400,h_300/file.jpg`
+- Hero: `/v1/fill/w_1920,h_600/file.jpg`
+- Full width: `/v1/fit/w_1200,h_800/file.webp`
+
+## Responsive Images
+
+Use `srcset` and `sizes` to let the browser pick the best image size for the viewport. Generate multiple sizes from the same Wix media URL:
+
+```html
+<img
+  src="{url}/v1/fill/w_400,h_400/file.webp"
+  srcset="{url}/v1/fill/w_300,h_300/file.webp 300w,
+          {url}/v1/fill/w_400,h_400/file.webp 400w,
+          {url}/v1/fill/w_600,h_600/file.webp 600w,
+          {url}/v1/fill/w_800,h_800/file.webp 800w"
+  sizes="(max-width: 600px) 100vw, (max-width: 900px) 50vw, 25vw"
+  alt="description"
+/>
+```
+
+- `src` — fallback for browsers that don't support srcset
+- `srcset` — candidate images with their width in pixels (`w` descriptor)
+- `sizes` — tells the browser how wide the image will be at each breakpoint
+
+Match `sizes` to your CSS layout (grid columns, container widths). The browser combines `sizes` with the device pixel ratio to pick the smallest sufficient image from `srcset`.
+
+For hero/banner images that span the full viewport:
+
+```html
+<img
+  src="{url}/v1/fill/w_1200,h_600/file.webp"
+  srcset="{url}/v1/fill/w_600,h_300/file.webp 600w,
+          {url}/v1/fill/w_1200,h_600/file.webp 1200w,
+          {url}/v1/fill/w_1920,h_960/file.webp 1920w"
+  sizes="100vw"
+  alt="description"
+/>
+```
+
+## Video
+
+Use the media URL directly in `<video>` tags.
+Poster image: append `/v1/fit/w_{w},h_{h}/file.jpg` to video mediaId.
+
+## Documents
+
+URL format: `https://static.wixstatic.com/ugd/{mediaId}`
+
+## Audio
+
+URL format: `https://static.wixstatic.com/mp3/{mediaId}`
+
+## Limits
+
+- Max dimension: 5000px per side
+- WebP max: 16,383px per side
+- Images are not upscaled beyond original size
+- Transformations only work with public Wix-hosted media

package/dist/index.d.ts

@@ -0,0 +1,35 @@
+import { JayHtmlValidatorFn } from '@jay-framework/compiler-shared';
+import { PluginSetupContext, PluginSetupResult, PluginReferencesContext, PluginReferencesResult } from '@jay-framework/stack-server-runtime';
+import * as _jay_framework_fullstack_component from '@jay-framework/fullstack-component';
+
+declare const validate: JayHtmlValidatorFn;
+
+interface MediaFileInfo {
+    id: string;
+    displayName: string;
+    slug: string;
+    url: string;
+    mediaType: string;
+    width?: number;
+    height?: number;
+    labels: string[];
+    folderId: string;
+    folderName: string;
+}
+
+declare function generateMediaIndex(files: MediaFileInfo[]): string;
+
+declare function setupWixMedia(ctx: PluginSetupContext): Promise<PluginSetupResult>;
+declare function generateWixMediaReferences(ctx: PluginReferencesContext): Promise<PluginReferencesResult>;
+
+declare const rebuildIndex: _jay_framework_fullstack_component.JayCliCommand<{}> & _jay_framework_fullstack_component.JayCliCommandDefinition<{}, [_jay_framework_fullstack_component.ConsoleContext]>;
+
+declare const uploadPublic: _jay_framework_fullstack_component.JayCliCommand<{
+    folder?: string;
+    dryRun?: boolean;
+}> & _jay_framework_fullstack_component.JayCliCommandDefinition<{
+    folder?: string;
+    dryRun?: boolean;
+}, [_jay_framework_fullstack_component.ConsoleContext]>;
+
+export { generateMediaIndex, generateWixMediaReferences, rebuildIndex, setupWixMedia, uploadPublic, validate };

package/dist/index.js

@@ -0,0 +1,440 @@
+import { walkElements, resolveBinding } from "@jay-framework/compiler-shared";
+import { parseTemplateParts } from "@jay-framework/compiler-jay-html";
+import * as fs from "fs";
+import * as path from "path";
+import { registerService, getService } from "@jay-framework/stack-server-runtime";
+import { WIX_CLIENT_SERVICE } from "@jay-framework/wix-server-client";
+import { files, folders } from "@wix/media";
+import { createJayService, makeCliCommand, CONSOLE_CONTEXT } from "@jay-framework/fullstack-component";
+import * as fs$1 from "node:fs";
+import * as path$1 from "node:path";
+const WIXSTATIC_MEDIA_RE = /static\.wixstatic\.com\/media\//;
+const V1_TRANSFORM_RE = /\/v1\//;
+const IMAGE_EXTENSIONS_RE = /\.(jpe?g|png|gif|webp|svg|bmp|ico)$/i;
+const MEDIA_SRC_ATTRS = ["src", "poster"];
+const MEDIA_ELEMENTS = /* @__PURE__ */ new Set(["img", "video", "source"]);
+function checkStaticWixUrl(value) {
+  return WIXSTATIC_MEDIA_RE.test(value) && !V1_TRANSFORM_RE.test(value);
+}
+function isLocalImagePath(value) {
+  if (!IMAGE_EXTENSIONS_RE.test(value)) return false;
+  if (value.startsWith("http://") || value.startsWith("https://")) return false;
+  return true;
+}
+function resolveBindingWithHeadless(bindingPath, scope, ctx) {
+  const resolved = resolveBinding(bindingPath, scope);
+  if (resolved.tag) return resolved;
+  const segments = bindingPath.split(".");
+  if (segments.length < 2) return resolved;
+  const headlessKey = segments[0];
+  const headless = ctx.headlessImports.find((h) => h.key === headlessKey && h.contract);
+  if (!headless?.contract) return resolved;
+  const remainingPath = segments.slice(1).join(".");
+  const headlessScope = { tags: headless.contract.tags };
+  return resolveBinding(remainingPath, headlessScope);
+}
+const validate = (ctx) => {
+  const findings = [];
+  walkElements(ctx.body, ctx, (el, scope) => {
+    const tagName = el.rawTagName?.toLowerCase();
+    if (!tagName || !MEDIA_ELEMENTS.has(tagName)) return;
+    for (const attr of MEDIA_SRC_ATTRS) {
+      const value = el.getAttribute(attr);
+      if (!value) continue;
+      const parts = parseTemplateParts(value);
+      const isFullyStatic = parts.every((p) => p.kind === "static");
+      if (isFullyStatic) {
+        const staticValue = parts.map((p) => p.value).join("");
+        if (checkStaticWixUrl(staticValue)) {
+          findings.push({
+            severity: "error",
+            message: "Wix media URL missing image optimization parameters. See agent-kit/wix-media.md for transformation reference.",
+            element: `<${tagName}>`,
+            attribute: attr
+          });
+        } else if (isLocalImagePath(staticValue)) {
+          findings.push({
+            severity: "error",
+            message: "Local image reference — upload to Wix Media Manager and use a Wix media URL with optimization parameters. See agent-kit/wix-media.md.",
+            element: `<${tagName}>`,
+            attribute: attr
+          });
+        }
+        continue;
+      }
+      for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        if (part.kind !== "binding") continue;
+        const resolved = resolveBindingWithHeadless(part.value, scope, ctx);
+        if (resolved.tag?.meta?.mediaType !== "wix-image") continue;
+        const followingStatic = parts.slice(i + 1).filter((p) => p.kind === "static").map((p) => p.value).join("");
+        if (!V1_TRANSFORM_RE.test(followingStatic)) {
+          findings.push({
+            severity: "error",
+            message: `Image binding '{${part.value}}' produces a Wix media URL but no optimization parameters are applied. See agent-kit/wix-media.md for transformation reference.`,
+            element: `<${tagName}>`,
+            attribute: attr
+          });
+        }
+      }
+    }
+  });
+  return findings;
+};
+function formatDimensions(file) {
+  if (file.width && file.height) {
+    return `${file.width}x${file.height}`;
+  }
+  return "-";
+}
+function formatLabels(labels) {
+  return labels.length > 0 ? labels.join(", ") : "-";
+}
+function escapeMarkdownCell(value) {
+  return value.replace(/\|/g, "\\|");
+}
+function generateMediaIndex(files2) {
+  const lines = [];
+  lines.push("# Available Media");
+  lines.push("");
+  lines.push("| Folder | Slug | Display Name | Type | Dimensions | Labels | URL |");
+  lines.push("| ------ | ---- | ------------ | ---- | ---------- | ------ | --- |");
+  for (const file of files2) {
+    lines.push(
+      `| ${escapeMarkdownCell(file.folderName)} | ${file.slug} | ${escapeMarkdownCell(file.displayName)} | ${file.mediaType} | ${formatDimensions(file)} | ${formatLabels(file.labels)} | ${file.url} |`
+    );
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+const WIX_MEDIA_SERVICE_MARKER = createJayService("Wix Media Service");
+let filesClientInstance;
+let foldersClientInstance;
+function getFilesClient(wixClient) {
+  if (!filesClientInstance) {
+    filesClientInstance = wixClient.use(files);
+  }
+  return filesClientInstance;
+}
+function getFoldersClient(wixClient) {
+  if (!foldersClientInstance) {
+    foldersClientInstance = wixClient.use(folders);
+  }
+  return foldersClientInstance;
+}
+function toSlug(displayName) {
+  return displayName.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+function deduplicateSlugs(items) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const count = seen.get(item.slug) ?? 0;
+    if (count > 0) {
+      item.slug = `${item.slug}-${count + 1}`;
+    }
+    seen.set(item.slug, count + 1);
+  }
+}
+function extractDimensions(file) {
+  const url = file.url ?? "";
+  const widthMatch = url.match(/originWidth=(\d+)/);
+  const heightMatch = url.match(/originHeight=(\d+)/);
+  if (widthMatch && heightMatch) {
+    return { width: parseInt(widthMatch[1], 10), height: parseInt(heightMatch[1], 10) };
+  }
+  return {};
+}
+async function fetchAllFolders(foldersClient) {
+  const folderMap = /* @__PURE__ */ new Map();
+  folderMap.set("media-root", "Media Root");
+  let cursor;
+  do {
+    const result = await foldersClient.searchFolders({
+      rootFolder: "MEDIA_ROOT",
+      paging: cursor ? { cursor, limit: 100 } : { limit: 100 }
+    });
+    for (const folder of result.folders ?? []) {
+      if (folder._id && folder.displayName) {
+        folderMap.set(folder._id, folder.displayName);
+      }
+    }
+    cursor = result.nextCursor?.cursors?.next;
+  } while (cursor);
+  return folderMap;
+}
+async function fetchAllPublicFiles(filesClient) {
+  const allFiles = [];
+  let cursor;
+  do {
+    const result = await filesClient.searchFiles({
+      rootFolder: "MEDIA_ROOT",
+      private: false,
+      paging: cursor ? { cursor, limit: 100 } : { limit: 100 },
+      sort: { fieldName: "displayName", order: "ASC" }
+    });
+    for (const file of result.files ?? []) {
+      if (file.state !== "OK" || !file._id) continue;
+      allFiles.push({
+        id: file._id,
+        displayName: file.displayName ?? file._id,
+        url: file.url ?? "",
+        mediaType: (file.mediaType ?? "UNKNOWN").toLowerCase(),
+        labels: file.labels ?? [],
+        folderId: file.parentFolderId ?? "media-root",
+        media: file.media
+      });
+    }
+    cursor = result.nextCursor?.cursors?.next;
+  } while (cursor);
+  return allFiles;
+}
+function provideWixMediaService(wixClient) {
+  const filesClient = getFilesClient(wixClient);
+  const foldersClient = getFoldersClient(wixClient);
+  const service = {
+    async generateUploadUrl(mimeType, fileName) {
+      const result = await filesClient.generateFileUploadUrl(mimeType, {
+        fileName
+      });
+      return { uploadUrl: result.uploadUrl ?? "" };
+    },
+    async listPublicFiles() {
+      const [folderMap, rawFiles] = await Promise.all([
+        fetchAllFolders(foldersClient),
+        fetchAllPublicFiles(filesClient)
+      ]);
+      const items = rawFiles.map((file) => {
+        const dims = extractDimensions(file);
+        return {
+          id: file.id,
+          displayName: file.displayName,
+          slug: toSlug(file.displayName),
+          url: file.url,
+          mediaType: file.mediaType,
+          width: dims.width,
+          height: dims.height,
+          labels: file.labels,
+          folderId: file.folderId,
+          folderName: folderMap.get(file.folderId) ?? "Unknown"
+        };
+      });
+      deduplicateSlugs(items);
+      items.sort((a, b) => {
+        const folderCmp = a.folderName.localeCompare(b.folderName);
+        if (folderCmp !== 0) return folderCmp;
+        return a.slug.localeCompare(b.slug);
+      });
+      return items;
+    }
+  };
+  registerService(WIX_MEDIA_SERVICE_MARKER, service);
+  return service;
+}
+function createMediaService() {
+  const wixClient = getService(WIX_CLIENT_SERVICE);
+  return provideWixMediaService(wixClient);
+}
+async function setupWixMedia(ctx) {
+  if (ctx.initError) {
+    return {
+      status: "needs-config",
+      message: "wix-media requires wix-server-client to be configured first. Run: jay-stack setup wix-server-client"
+    };
+  }
+  try {
+    createMediaService();
+  } catch {
+    return {
+      status: "needs-config",
+      message: "wix-media requires wix-server-client to be configured first. Run: jay-stack setup wix-server-client"
+    };
+  }
+  return {
+    status: "configured",
+    message: "Wix Media Manager access verified."
+  };
+}
+async function generateWixMediaReferences(ctx) {
+  if (ctx.initError) {
+    throw new Error(`init failed: ${ctx.initError.message}`);
+  }
+  let mediaService;
+  try {
+    mediaService = createMediaService();
+  } catch {
+    throw new Error("WixMediaService not available. Run jay-stack setup first.");
+  }
+  fs.mkdirSync(ctx.referencesDir, { recursive: true });
+  const mediaFiles = await mediaService.listPublicFiles();
+  const mediaIndexContent = generateMediaIndex(mediaFiles);
+  const mediaIndexPath = path.join(ctx.referencesDir, "MEDIA-INDEX.md");
+  fs.writeFileSync(mediaIndexPath, mediaIndexContent, "utf-8");
+  return {
+    referencesCreated: [`agent-kit/references/${ctx.pluginName}/MEDIA-INDEX.md`],
+    message: `${mediaFiles.length} media files indexed.`
+  };
+}
+const rebuildIndex = makeCliCommand("rebuild-index").withServices(CONSOLE_CONTEXT).withHandler(async (input, console) => {
+  const wixClient = getService(WIX_CLIENT_SERVICE);
+  const mediaService = provideWixMediaService(wixClient);
+  console.log("Fetching media from Wix Media Manager...");
+  const files2 = await mediaService.listPublicFiles();
+  console.log(`Found ${files2.length} public media files.`);
+  const referencesDir = path$1.join(
+    console.projectRoot,
+    "agent-kit",
+    "references",
+    "wix-media"
+  );
+  fs$1.mkdirSync(referencesDir, { recursive: true });
+  const indexContent = generateMediaIndex(files2);
+  const indexPath = path$1.join(referencesDir, "MEDIA-INDEX.md");
+  fs$1.writeFileSync(indexPath, indexContent, "utf-8");
+  console.log(`Media index written to ${indexPath}`);
+  return { success: true };
+});
+const UPLOAD_INDEX_FILE = ".wix-media-uploads.json";
+const MEDIA_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".jpg",
+  ".jpeg",
+  ".png",
+  ".gif",
+  ".webp",
+  ".svg",
+  ".bmp",
+  ".ico",
+  ".mp4",
+  ".webm",
+  ".mov",
+  ".avi",
+  ".mp3",
+  ".wav",
+  ".ogg",
+  ".aac",
+  ".pdf",
+  ".doc",
+  ".docx"
+]);
+function getMimeType(ext) {
+  const map = {
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".png": "image/png",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".svg": "image/svg+xml",
+    ".bmp": "image/bmp",
+    ".ico": "image/x-icon",
+    ".mp4": "video/mp4",
+    ".webm": "video/webm",
+    ".mov": "video/quicktime",
+    ".avi": "video/x-msvideo",
+    ".mp3": "audio/mpeg",
+    ".wav": "audio/wav",
+    ".ogg": "audio/ogg",
+    ".aac": "audio/aac",
+    ".pdf": "application/pdf",
+    ".doc": "application/msword",
+    ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+  };
+  return map[ext.toLowerCase()] ?? "application/octet-stream";
+}
+function loadUploadIndex(configDir) {
+  const indexPath = path$1.join(configDir, UPLOAD_INDEX_FILE);
+  if (fs$1.existsSync(indexPath)) {
+    return JSON.parse(fs$1.readFileSync(indexPath, "utf-8"));
+  }
+  return {};
+}
+function saveUploadIndex(configDir, index) {
+  fs$1.mkdirSync(configDir, { recursive: true });
+  const indexPath = path$1.join(configDir, UPLOAD_INDEX_FILE);
+  fs$1.writeFileSync(indexPath, JSON.stringify(index, null, 2), "utf-8");
+}
+function scanMediaFiles(dir, baseDir) {
+  const results = [];
+  if (!fs$1.existsSync(dir)) return results;
+  const entries = fs$1.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path$1.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...scanMediaFiles(fullPath, baseDir));
+    } else {
+      const ext = path$1.extname(entry.name).toLowerCase();
+      if (MEDIA_EXTENSIONS.has(ext)) {
+        results.push(path$1.relative(baseDir, fullPath));
+      }
+    }
+  }
+  return results;
+}
+const uploadPublic = makeCliCommand("upload-public").withServices(CONSOLE_CONTEXT).withHandler(async (input, console) => {
+  const wixClient = getService(WIX_CLIENT_SERVICE);
+  const mediaService = provideWixMediaService(wixClient);
+  const publicDir = console.publicFolder;
+  const scanDir = input.folder ? path$1.join(publicDir, input.folder) : publicDir;
+  const configDir = path$1.join(console.projectRoot, "config");
+  console.log(`Scanning ${scanDir} for media files...`);
+  const mediaFiles = scanMediaFiles(scanDir, publicDir);
+  if (mediaFiles.length === 0) {
+    console.log("No media files found.");
+    return { success: true };
+  }
+  console.log(`Found ${mediaFiles.length} media files.`);
+  const uploadIndex = loadUploadIndex(configDir);
+  const toUpload = mediaFiles.filter((f) => {
+    const key = `public/${f}`;
+    return !uploadIndex[key] || uploadIndex[key].status !== "uploaded";
+  });
+  if (toUpload.length === 0) {
+    console.log("All files already uploaded.");
+    return { success: true };
+  }
+  console.log(
+    `${toUpload.length} files to upload (${mediaFiles.length - toUpload.length} already uploaded).`
+  );
+  if (input.dryRun) {
+    for (const file of toUpload) {
+      console.log(`[dry-run] Would upload: ${file}`);
+    }
+    return { success: true };
+  }
+  let uploaded = 0;
+  let failed = 0;
+  for (const file of toUpload) {
+    const key = `public/${file}`;
+    const filePath = path$1.join(publicDir, file);
+    const ext = path$1.extname(file);
+    const mimeType = getMimeType(ext);
+    const fileName = path$1.basename(file);
+    try {
+      const { uploadUrl } = await mediaService.generateUploadUrl(mimeType, fileName);
+      const fileBuffer = fs$1.readFileSync(filePath);
+      const response = await fetch(uploadUrl, {
+        method: "PUT",
+        headers: { "Content-Type": mimeType },
+        body: fileBuffer
+      });
+      if (!response.ok) {
+        throw new Error(`Upload failed with status ${response.status}`);
+      }
+      uploadIndex[key] = { status: "uploaded" };
+      uploaded++;
+      console.log(`Uploaded: ${file}`);
+    } catch (err) {
+      failed++;
+      console.error(`Failed to upload ${file}: ${err.message}`);
+    }
+  }
+  saveUploadIndex(configDir, uploadIndex);
+  console.log(`Upload complete: ${uploaded} uploaded, ${failed} failed.`);
+  return { success: failed === 0 };
+});
+export {
+  generateMediaIndex,
+  generateWixMediaReferences,
+  rebuildIndex,
+  setupWixMedia,
+  uploadPublic,
+  validate
+};

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@jay-framework/wix-media",
+  "version": "0.19.1",
+  "type": "module",
+  "description": "Wix Media Manager plugin for Jay Framework — media validation, index generation, and agent-kit references",
+  "license": "Apache-2.0",
+  "main": "dist/index.js",
+  "files": [
+    "dist",
+    "plugin.yaml",
+    "agent-kit"
+  ],
+  "exports": {
+    ".": "./dist/index.js",
+    "./plugin.yaml": "./plugin.yaml"
+  },
+  "scripts": {
+    "build": "npm run clean && npm run build:server && npm run build:types && npm run validate",
+    "validate": "jay-stack-cli validate-plugin",
+    "build:server": "vite build --ssr",
+    "build:types": "tsup lib/index.ts --dts-only --format esm",
+    "build:check-types": "tsc",
+    "clean": "rimraf dist",
+    "confirm": "npm run clean && npm run build && npm run test",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@jay-framework/compiler-jay-html": "^0.19.1",
+    "@jay-framework/compiler-shared": "^0.19.1",
+    "@jay-framework/component": "^0.19.1",
+    "@jay-framework/fullstack-component": "^0.19.1",
+    "@jay-framework/stack-server-runtime": "^0.19.1",
+    "@jay-framework/wix-server-client": "^0.19.1",
+    "@jay-framework/wix-utils": "^0.19.1",
+    "@wix/media": "^1.0.247",
+    "@wix/sdk": "^1.21.5"
+  },
+  "devDependencies": {
+    "@jay-framework/compiler-jay-stack": "^0.19.1",
+    "@jay-framework/vite-plugin": "^0.19.1",
+    "@types/node": "^20.11.0",
+    "node-html-parser": "^6.1.0",
+    "rimraf": "^5.0.5",
+    "tsup": "^8.5.1",
+    "typescript": "^5.3.3",
+    "vite": "^5.0.11",
+    "vitest": "^1.2.0"
+  }
+}

package/plugin.yaml

@@ -0,0 +1,17 @@
+name: wix-media
+
+validators:
+  - name: media-optimization
+    handler: validate
+    description: Validates Wix media URLs have optimization parameters
+
+commands:
+  - name: upload-public
+    command: upload-public.jay-command
+  - name: rebuild-index
+    command: rebuild-index.jay-command
+
+setup:
+  handler: setupWixMedia
+  references: generateWixMediaReferences
+  description: Validates Wix Media Manager access, generates agent-kit media index