@pixeldojo/mcp 0.1.1 → 0.3.0

package/dist/index.js

@@ -3,6 +3,8 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import { PixelDojoClient } from '@pixeldojo/sdk';
 import { z } from 'zod';
+import { stat, readFile } from 'fs/promises';
+import { basename, extname } from 'path';
 
 // src/server.ts
 function makeAttributedClient(options) {
@@ -106,6 +108,71 @@ function extractAssetUrls(job) {
   if (output?.video) return [output.video];
   return [];
 }
+var MAX_IMAGE_BYTES = 50 * 1024 * 1024;
+var MAX_VIDEO_BYTES = 200 * 1024 * 1024;
+var EXT_TO_MIME = {
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".png": "image/png",
+  ".webp": "image/webp",
+  ".gif": "image/gif",
+  ".mp4": "video/mp4",
+  ".webm": "video/webm",
+  ".mov": "video/quicktime"
+};
+var SkillUploadError = class extends Error {
+  constructor(userMessage) {
+    super(userMessage);
+    this.userMessage = userMessage;
+    this.name = "SkillUploadError";
+  }
+  userMessage;
+};
+async function uploadLocalFile(path, client) {
+  const ext = extname(path).toLowerCase();
+  const mime = EXT_TO_MIME[ext];
+  if (!mime) {
+    throw new SkillUploadError(
+      `Unsupported file extension "${ext || "(none)"}" for "${path}". Allowed: ${Object.keys(EXT_TO_MIME).join(", ")}.`
+    );
+  }
+  let size;
+  try {
+    const info = await stat(path);
+    if (!info.isFile()) {
+      throw new SkillUploadError(`"${path}" is not a file.`);
+    }
+    size = info.size;
+  } catch (err) {
+    if (err instanceof SkillUploadError) throw err;
+    const code = err?.code;
+    if (code === "ENOENT") {
+      throw new SkillUploadError(
+        `File not found at "${path}". Pass an absolute path.`
+      );
+    }
+    throw new SkillUploadError(
+      `Cannot read "${path}": ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  const isImage = mime.startsWith("image/");
+  const limit = isImage ? MAX_IMAGE_BYTES : MAX_VIDEO_BYTES;
+  if (size > limit) {
+    const gotMB = (size / 1024 / 1024).toFixed(1);
+    const limitMB = (limit / 1024 / 1024).toFixed(0);
+    throw new SkillUploadError(
+      `"${basename(path)}" is ${gotMB}MB; limit for ${isImage ? "images" : "videos"} is ${limitMB}MB. Downscale or re-encode and try again.`
+    );
+  }
+  const buffer = await readFile(path);
+  const blob = new Blob([new Uint8Array(buffer)], { type: mime });
+  const filename = basename(path);
+  const response = await client.uploadImage(blob, filename);
+  return response.url;
+}
+async function uploadLocalFiles(paths, client) {
+  return Promise.all(paths.map((p) => uploadLocalFile(p, client)));
+}
 
 // src/skills/generate.ts
 var InputSchema = z.object({
@@ -113,9 +180,15 @@ var InputSchema = z.object({
   model: z.string().optional().describe(
     'Override the model. Any apiId from /api/v1/models (e.g. "flux", "google-nano-banana", "veo-3.1", "kling-video"). Omit to use the default.'
   ),
+  preset: z.string().optional().describe(
+    'Preset slug to seed the params (e.g. "cinematic-portrait", "product-floating-clean", "magazine-cover-text"). Browse the catalog at https://pixeldojo.ai/presets. Explicit fields override preset values.'
+  ),
   aspect_ratio: z.string().optional().describe('Aspect ratio supported by the chosen model (e.g. "1:1", "16:9", "9:16").'),
   duration: z.number().int().positive().optional().describe("Video duration in seconds, when applicable."),
-  image_url: z.string().url().optional().describe("Reference image URL for image-to-image / image-to-video tools.")
+  image_url: z.string().url().optional().describe("Reference image URL for image-to-image / image-to-video tools."),
+  image_path: z.string().min(1).optional().describe(
+    "Absolute local file path to a reference image/video. The skill uploads it to PixelDojo first (24h temp storage) and then dispatches. Prefer this over image_url when the user has the file on disk."
+  )
 });
 var DEFAULT_MODEL = "google-nano-banana";
 var InputJsonSchema = {
@@ -126,18 +199,73 @@ var InputJsonSchema = {
       type: "string",
       description: 'Override the model. Any apiId from /api/v1/models (e.g. "flux", "google-nano-banana", "veo-3.1", "kling-video"). Omit to use the default.'
     },
+    preset: {
+      type: "string",
+      description: 'Preset slug to seed the params (e.g. "cinematic-portrait", "product-floating-clean"). Explicit fields override preset values.'
+    },
     aspect_ratio: { type: "string" },
     duration: { type: "integer" },
-    image_url: { type: "string", format: "uri" }
+    image_url: { type: "string", format: "uri" },
+    image_path: {
+      type: "string",
+      description: "Absolute local file path. The skill uploads it to PixelDojo (24h temp storage) and uses the resulting URL as the reference image. Prefer this over image_url when the user has a local file."
+    }
   },
   required: ["prompt"]
 };
-async function run(input, ctx) {
-  const apiId = input.model ?? DEFAULT_MODEL;
+function buildPayload(apiId, input) {
   const body = { prompt: input.prompt };
   if (input.aspect_ratio) body.aspect_ratio = input.aspect_ratio;
-  if (input.duration !== void 0) body.duration = input.duration;
-  if (input.image_url) body.image_url = input.image_url;
+  if (input.preset) body.preset = input.preset;
+  switch (apiId) {
+    case "grok-video-extend":
+    case "wan-video-edit":
+    case "seedance-video-edit":
+      if (input.image_url) {
+        body.video_url = input.image_url;
+        body.image_url = input.image_url;
+      }
+      if (input.duration !== void 0) {
+        body.video_duration = input.duration;
+        body.duration = input.duration;
+      }
+      break;
+    default:
+      if (input.image_url) body.image_url = input.image_url;
+      if (input.duration !== void 0) body.duration = input.duration;
+      break;
+  }
+  return body;
+}
+async function run(input, ctx) {
+  const apiId = input.model ?? DEFAULT_MODEL;
+  let resolved = input;
+  if (!input.image_url && input.image_path) {
+    try {
+      const uploadedUrl = await uploadLocalFile(input.image_path, ctx.client);
+      resolved = { ...input, image_url: uploadedUrl };
+    } catch (err) {
+      if (err instanceof SkillUploadError) {
+        return { kind: "text", text: `pixeldojo:generate (upload): ${err.userMessage}` };
+      }
+      throw err;
+    }
+  }
+  if (apiId === "grok-video-extend") {
+    if (!resolved.image_url) {
+      return {
+        kind: "text",
+        text: 'pixeldojo:generate with model="grok-video-extend" requires image_url (the source video URL to extend, or image_path for a local file).'
+      };
+    }
+    if (resolved.duration === void 0) {
+      return {
+        kind: "text",
+        text: 'pixeldojo:generate with model="grok-video-extend" requires duration (extension length in seconds).'
+      };
+    }
+  }
+  const body = buildPayload(apiId, resolved);
   const submitted = await ctx.client.run(apiId, body);
   const result = await pollJobUntilDoneOrHandoff(
     submitted.jobId,
@@ -155,39 +283,191 @@ async function run(input, ctx) {
 }
 var generateSkill = {
   name: "pixeldojo:generate",
-  description: "Generate any image or video from a prompt. Auto-routes to a sensible default model; pass `model` to pick a specific apiId from the catalog.",
+  description: "Generate any image or video from a prompt. Auto-routes to a sensible default model; pass `model` to pick a specific apiId from the catalog. For reference-image / image-to-video flows: pass `image_url` if you already have a URL, or `image_path` (absolute local path) and the skill uploads it to 24h temp storage automatically.",
   inputZod: InputSchema,
   inputJsonSchema: InputJsonSchema,
   allowedModels: null,
   defaultModel: DEFAULT_MODEL,
   run
 };
-var ALLOWED = ["ideogram-character", "flux-edit", "gpt-image-2-edit"];
-var DEFAULT_MODEL2 = "ideogram-character";
+var DEFAULT_MODEL2 = "wan-2.7-image-edit";
+var ALLOWED_MODELS = [
+  "wan-2.7-image-edit",
+  "wan-2.6-image-edit",
+  "flux-edit",
+  "xai-image-edit",
+  "p-image-edit",
+  "gpt-image-2-edit",
+  "hidream-edit",
+  "google-nano-banana"
+];
 var InputSchema2 = z.object({
+  prompt: z.string().min(1).max(5e3).describe("Edit instruction."),
+  image_url: z.string().url().optional().describe("Single reference image to edit. Pass image_urls for multi-image edits."),
+  image_urls: z.array(z.string().url()).min(1).max(9).optional().describe("Multiple reference images (1-9). Used for composition/multi-ref edits."),
+  image_path: z.string().min(1).optional().describe(
+    "Absolute local file path. Skill uploads it (24h temp storage) and edits it. Prefer over image_url when the user has the file on disk."
+  ),
+  image_paths: z.array(z.string().min(1)).min(1).max(9).optional().describe(
+    "Multiple absolute local file paths (1-9) for multi-image edits. Each uploaded to 24h temp storage before dispatch."
+  ),
+  model: z.enum(ALLOWED_MODELS).optional().describe(
+    "Override the default edit model. Defaults to wan-2.7-image-edit (most popular)."
+  ),
+  aspect_ratio: z.string().optional().describe('Aspect ratio when supported (e.g. "1:1", "16:9", "match_input_image").')
+});
+var InputJsonSchema2 = {
+  type: "object",
+  properties: {
+    prompt: { type: "string", description: "Edit instruction." },
+    image_url: {
+      type: "string",
+      format: "uri",
+      description: "Single reference image. Pass image_urls for multi-image edits."
+    },
+    image_urls: {
+      type: "array",
+      items: { type: "string", format: "uri" },
+      minItems: 1,
+      maxItems: 9,
+      description: "Multiple reference images (1-9)."
+    },
+    image_path: {
+      type: "string",
+      description: "Absolute local file path. Skill uploads it (24h temp storage) and edits the resulting URL. Prefer over image_url when the user has a local file."
+    },
+    image_paths: {
+      type: "array",
+      items: { type: "string" },
+      minItems: 1,
+      maxItems: 9,
+      description: "Multiple absolute local file paths (1-9). Each uploaded before dispatch."
+    },
+    model: {
+      type: "string",
+      enum: [...ALLOWED_MODELS],
+      description: "Override edit model. Default: wan-2.7-image-edit."
+    },
+    aspect_ratio: { type: "string" }
+  },
+  required: ["prompt"]
+};
+function buildPayload2(apiId, input) {
+  const urls = input.image_urls && input.image_urls.length > 0 ? input.image_urls : input.image_url ? [input.image_url] : [];
+  switch (apiId) {
+    case "wan-2.7-image-edit":
+    case "wan-2.6-image-edit":
+      return {
+        prompt: input.prompt,
+        image_urls: urls
+        // wan-edit uses `size` not aspect_ratio. Default 2K, let model defaults handle it otherwise.
+      };
+    case "p-image-edit":
+      return {
+        prompt: input.prompt,
+        images: urls.slice(0, 5),
+        ...input.aspect_ratio ? { aspect_ratio: input.aspect_ratio } : {}
+      };
+    case "flux-edit":
+    case "xai-image-edit":
+    case "gpt-image-2-edit":
+    case "hidream-edit":
+      return {
+        prompt: input.prompt,
+        image_url: urls[0],
+        ...urls.length > 1 ? { image_urls: urls } : {},
+        ...input.aspect_ratio ? { aspect_ratio: input.aspect_ratio } : {}
+      };
+    case "google-nano-banana":
+      return {
+        prompt: input.prompt,
+        image_input: urls,
+        ...input.aspect_ratio ? { aspect_ratio: input.aspect_ratio } : {}
+      };
+    default:
+      return {
+        prompt: input.prompt,
+        image_url: urls[0]
+      };
+  }
+}
+async function run2(input, ctx) {
+  let resolved = input;
+  try {
+    if (input.image_paths && input.image_paths.length > 0) {
+      const urls = await uploadLocalFiles(input.image_paths, ctx.client);
+      resolved = {
+        ...input,
+        image_urls: [...input.image_urls ?? [], ...urls]
+      };
+    } else if (input.image_path && !input.image_url) {
+      const url = await uploadLocalFile(input.image_path, ctx.client);
+      resolved = { ...input, image_url: url };
+    }
+  } catch (err) {
+    if (err instanceof SkillUploadError) {
+      return { kind: "text", text: `pixeldojo:edit (upload): ${err.userMessage}` };
+    }
+    throw err;
+  }
+  if (!resolved.image_url && (!resolved.image_urls || resolved.image_urls.length === 0)) {
+    return {
+      kind: "text",
+      text: "pixeldojo:edit requires at least one reference image. Pass image_url / image_urls (hosted URL) or image_path / image_paths (local file)."
+    };
+  }
+  const apiId = resolved.model ?? DEFAULT_MODEL2;
+  const body = buildPayload2(apiId, resolved);
+  const submitted = await ctx.client.run(apiId, body);
+  const result = await pollJobUntilDoneOrHandoff(
+    submitted.jobId,
+    (id) => ctx.client.getJob(id),
+    ctx.buildStatusUrl,
+    {
+      now: ctx.pollOverrides?.now,
+      sleep: ctx.pollOverrides?.sleep
+    }
+  );
+  return pollResultToSkillResult(
+    result,
+    (urls) => urls.length === 0 ? `Edit job ${submitted.jobId} completed but returned no assets.` : urls.length === 1 ? `Edit complete. Asset: ${urls[0]}` : `Edit produced ${urls.length} assets. URLs: ${urls.join(", ")}`
+  );
+}
+var editSkill = {
+  name: "pixeldojo:edit",
+  description: "Edit an existing image with a text instruction. Defaults to wan-2.7-image-edit; pass `model` to pick another edit-capable apiId. Supports up to 9 reference images for multi-image composition. For reference images: pass image_url(s) for hosted URLs or image_path(s) for absolute local file paths (skill uploads to 24h temp storage automatically).",
+  inputZod: InputSchema2,
+  inputJsonSchema: InputJsonSchema2,
+  allowedModels: [...ALLOWED_MODELS],
+  defaultModel: DEFAULT_MODEL2,
+  run: run2
+};
+var ALLOWED = ["ideogram-character", "flux-edit", "gpt-image-2-edit"];
+var DEFAULT_MODEL3 = "ideogram-character";
+var InputSchema3 = z.object({
   prompt: z.string().min(1).max(8e3),
-  model: z.string().optional().describe(`One of: ${ALLOWED.join(", ")}. Defaults to ${DEFAULT_MODEL2}.`),
+  model: z.string().optional().describe(`One of: ${ALLOWED.join(", ")}. Defaults to ${DEFAULT_MODEL3}.`),
   reference_image_url: z.string().url().optional().describe(
     "Reference image of the character. Required by flux-edit and gpt-image-2-edit; optional for ideogram-character."
   ),
   aspect_ratio: z.string().optional()
 });
-var InputJsonSchema2 = {
+var InputJsonSchema3 = {
   type: "object",
   properties: {
     prompt: { type: "string" },
     model: {
       type: "string",
       enum: ALLOWED,
-      description: `One of: ${ALLOWED.join(", ")}. Defaults to ${DEFAULT_MODEL2}.`
+      description: `One of: ${ALLOWED.join(", ")}. Defaults to ${DEFAULT_MODEL3}.`
     },
     reference_image_url: { type: "string", format: "uri" },
     aspect_ratio: { type: "string" }
   },
   required: ["prompt"]
 };
-async function run2(input, ctx) {
-  const requested = input.model ?? DEFAULT_MODEL2;
+async function run3(input, ctx) {
+  const requested = input.model ?? DEFAULT_MODEL3;
   if (!ALLOWED.includes(requested)) {
     return {
       kind: "text",
@@ -195,6 +475,12 @@ async function run2(input, ctx) {
     };
   }
   const apiId = requested;
+  if ((apiId === "flux-edit" || apiId === "gpt-image-2-edit") && !input.reference_image_url) {
+    return {
+      kind: "text",
+      text: `pixeldojo:character with model="${apiId}" requires reference_image_url (the source image of the character to edit). For generation from a prompt alone, use model="ideogram-character".`
+    };
+  }
   const body = { prompt: input.prompt };
   if (input.aspect_ratio) body.aspect_ratio = input.aspect_ratio;
   if (input.reference_image_url) {
@@ -219,21 +505,21 @@ async function run2(input, ctx) {
 var characterSkill = {
   name: "pixeldojo:character",
   description: "Generate or edit consistent characters across shots. Pass a reference_image_url for edit-style models.",
-  inputZod: InputSchema2,
-  inputJsonSchema: InputJsonSchema2,
+  inputZod: InputSchema3,
+  inputJsonSchema: InputJsonSchema3,
   allowedModels: [...ALLOWED],
-  defaultModel: DEFAULT_MODEL2,
-  run: run2
+  defaultModel: DEFAULT_MODEL3,
+  run: run3
 };
 var ALLOWED2 = ["veo-3.1", "kling-video", "seedance-2"];
-var DEFAULT_MODEL3 = "veo-3.1";
-var InputSchema3 = z.object({
+var DEFAULT_MODEL4 = "veo-3.1";
+var InputSchema4 = z.object({
   brief: z.string().min(1).max(8e3).describe("Storyboard brief: scene, shots, mood, action."),
-  model: z.string().optional().describe(`One of: ${ALLOWED2.join(", ")}. Defaults to ${DEFAULT_MODEL3}.`),
+  model: z.string().optional().describe(`One of: ${ALLOWED2.join(", ")}. Defaults to ${DEFAULT_MODEL4}.`),
   aspect_ratio: z.string().optional(),
   duration: z.number().int().positive().optional()
 });
-var InputJsonSchema3 = {
+var InputJsonSchema4 = {
   type: "object",
   properties: {
     brief: {
@@ -243,15 +529,15 @@ var InputJsonSchema3 = {
     model: {
       type: "string",
       enum: ALLOWED2,
-      description: `One of: ${ALLOWED2.join(", ")}. Defaults to ${DEFAULT_MODEL3}.`
+      description: `One of: ${ALLOWED2.join(", ")}. Defaults to ${DEFAULT_MODEL4}.`
     },
     aspect_ratio: { type: "string" },
     duration: { type: "integer" }
   },
   required: ["brief"]
 };
-async function run3(input, ctx) {
-  const requested = input.model ?? DEFAULT_MODEL3;
+async function run4(input, ctx) {
+  const requested = input.model ?? DEFAULT_MODEL4;
   if (!ALLOWED2.includes(requested)) {
     return {
       kind: "text",
@@ -280,21 +566,21 @@ async function run3(input, ctx) {
 var storyboardSkill = {
   name: "pixeldojo:storyboard",
   description: "Generate a video storyboard preview from a single brief. v1: single-shot preview; multi-shot orchestration coming.",
-  inputZod: InputSchema3,
-  inputJsonSchema: InputJsonSchema3,
+  inputZod: InputSchema4,
+  inputJsonSchema: InputJsonSchema4,
   allowedModels: [...ALLOWED2],
-  defaultModel: DEFAULT_MODEL3,
-  run: run3
+  defaultModel: DEFAULT_MODEL4,
+  run: run4
 };
 var ALLOWED3 = ["magnific-upscaler", "creative-upscale", "face-enhance"];
-var DEFAULT_MODEL4 = "magnific-upscaler";
-var InputSchema4 = z.object({
+var DEFAULT_MODEL5 = "magnific-upscaler";
+var InputSchema5 = z.object({
   image_url: z.string().url().describe("URL of the source image to upscale."),
-  model: z.string().optional().describe(`One of: ${ALLOWED3.join(", ")}. Defaults to ${DEFAULT_MODEL4}.`),
+  model: z.string().optional().describe(`One of: ${ALLOWED3.join(", ")}. Defaults to ${DEFAULT_MODEL5}.`),
   scale_factor: z.number().int().min(1).max(4).optional().describe("Magnific only: 1, 2, or 4. Defaults to 2."),
   creativity: z.number().min(0).max(1).optional().describe("Magnific only: 0 (preserve) \u2192 1 (creative). Defaults to 0.")
 });
-var InputJsonSchema4 = {
+var InputJsonSchema5 = {
   type: "object",
   properties: {
     image_url: { type: "string", format: "uri" },
@@ -304,8 +590,8 @@ var InputJsonSchema4 = {
   },
   required: ["image_url"]
 };
-async function run4(input, ctx) {
-  const requested = input.model ?? DEFAULT_MODEL4;
+async function run5(input, ctx) {
+  const requested = input.model ?? DEFAULT_MODEL5;
   if (!ALLOWED3.includes(requested)) {
     return {
       kind: "text",
@@ -339,16 +625,16 @@ async function run4(input, ctx) {
 var upscaleSkill = {
   name: "pixeldojo:upscale",
   description: "Enhance an image. Magnific (default) supports configurable scale_factor and creativity; face-enhance for portraits.",
-  inputZod: InputSchema4,
-  inputJsonSchema: InputJsonSchema4,
+  inputZod: InputSchema5,
+  inputJsonSchema: InputJsonSchema5,
   allowedModels: [...ALLOWED3],
-  defaultModel: DEFAULT_MODEL4,
-  run: run4
+  defaultModel: DEFAULT_MODEL5,
+  run: run5
 };
-var InputSchema5 = z.object({
+var InputSchema6 = z.object({
   jobId: z.string().min(1).max(200).describe("Job id returned from a prior pixeldojo:* skill handoff.")
 });
-var InputJsonSchema5 = {
+var InputJsonSchema6 = {
   type: "object",
   properties: {
     jobId: {
@@ -360,7 +646,7 @@ var InputJsonSchema5 = {
 };
 var STUCK_HINT_MS = 5 * 60 * 1e3;
 var ABANDON_HINT_MS = 12 * 60 * 1e3;
-async function run5(input, ctx) {
+async function run6(input, ctx) {
   const job = await ctx.client.getJob(input.jobId);
   if (job.status === "completed") {
     const urls = extractAssetUrls2(job);
@@ -427,21 +713,240 @@ function extractAssetUrls2(job) {
 var statusSkill = {
   name: "pixeldojo:status",
   description: "Check the status of a long-running job after a 30s sync handoff. Returns assets when ready, failure reason if failed, or current state if still running.",
-  inputZod: InputSchema5,
-  inputJsonSchema: InputJsonSchema5,
+  inputZod: InputSchema6,
+  inputJsonSchema: InputJsonSchema6,
   // status is special — it doesn't dispatch to a model
   allowedModels: [],
   defaultModel: "",
-  run: run5
+  run: run6
+};
+var InputSchema7 = z.object({
+  url: z.string().min(1).max(2048).describe("Product page URL. Shopify, BigCommerce, WooCommerce, or any page with JSON-LD / OpenGraph product metadata.")
+});
+var InputJsonSchema7 = {
+  type: "object",
+  properties: {
+    url: {
+      type: "string",
+      description: "Product page URL. Shopify, BigCommerce, WooCommerce, or any page with JSON-LD / OpenGraph product metadata."
+    }
+  },
+  required: ["url"]
+};
+async function run7(input, ctx) {
+  const product = await ctx.client.extractProduct(input.url);
+  const summary = [
+    `Product: ${product.name}`,
+    product.description ? `Description: ${truncate(product.description, 280)}` : null,
+    `Images (${product.images.length}): ${product.images.slice(0, 3).join(", ")}${product.images.length > 3 ? `, +${product.images.length - 3} more` : ""}`,
+    `Source strategy: ${product.source}`
+  ].filter(Boolean).join("\n");
+  return {
+    kind: "text",
+    text: summary
+  };
+}
+function truncate(input, max) {
+  if (input.length <= max) return input;
+  return input.slice(0, max - 3) + "...";
+}
+var fromUrlSkill = {
+  name: "pixeldojo:from_url",
+  description: "Extract product info (name, description, images) from any product page URL. Use this as the first step before pixeldojo:campaign / :ad / :lookbook so the agent has structured product data instead of a free-text description.",
+  inputZod: InputSchema7,
+  inputJsonSchema: InputJsonSchema7,
+  // No model dispatch — this skill calls a server-side scrape, not a generation.
+  allowedModels: [],
+  defaultModel: "",
+  run: run7
+};
+var InputSchema8 = z.object({
+  productUrl: z.string().url().optional().describe("Product page URL. We extract name + description + images automatically."),
+  product: z.object({
+    name: z.string().min(1).max(200),
+    description: z.string().max(2e3).optional(),
+    images: z.array(z.string().url()).max(5).optional()
+  }).optional().describe("Manual product fields, used when productUrl is omitted."),
+  tone: z.string().max(120).optional().describe('Optional creative direction ("premium minimalist", "playful Y2K"). Threaded through every prompt.'),
+  variants: z.number().int().min(1).max(8).optional().describe("Lifestyle shots in addition to the hero (default 4, max 8)."),
+  includeVideo: z.boolean().optional().describe("Whether to also generate a vertical launch video (default true)."),
+  videoAspectRatio: z.enum(["9:16", "16:9", "1:1"]).optional().describe("Aspect ratio of the launch video (default 9:16 for Reels/TikTok)."),
+  videoMode: z.enum(["lifestyle", "cgi", "ugc", "skip"]).optional().describe("Video styling \u2014 lifestyle (default), cgi, ugc, or skip to omit video.")
+}).refine((v) => v.productUrl || v.product, {
+  message: "productUrl or product is required",
+  path: ["productUrl"]
+});
+var InputJsonSchema8 = {
+  type: "object",
+  properties: {
+    productUrl: {
+      type: "string",
+      format: "uri",
+      description: "Product page URL. We extract name + description + images automatically."
+    },
+    product: {
+      type: "object",
+      properties: {
+        name: { type: "string" },
+        description: { type: "string" },
+        images: { type: "array", items: { type: "string", format: "uri" } }
+      },
+      required: ["name"]
+    },
+    tone: {
+      type: "string",
+      description: "Creative direction threaded through every prompt."
+    },
+    variants: { type: "integer", minimum: 1, maximum: 8 },
+    includeVideo: { type: "boolean" },
+    videoAspectRatio: { type: "string", enum: ["9:16", "16:9", "1:1"] },
+    videoMode: { type: "string", enum: ["lifestyle", "cgi", "ugc", "skip"] }
+  },
+  oneOf: [{ required: ["productUrl"] }, { required: ["product"] }]
+};
+async function run8(input, ctx) {
+  const client = ctx.client;
+  const result = await client.runCampaign(input);
+  if (result.kind === "campaign") {
+    const assets = result.assets ?? [];
+    const lines = [
+      `Campaign ${result.campaignId} for "${result.product?.name ?? "product"}":`,
+      ...assets.map(
+        (a) => `  - ${a.role}${a.variantIndex !== void 0 ? ` #${a.variantIndex}` : ""} (${a.kind}, ${a.apiId}): ${a.url}`
+      ),
+      "",
+      `Total credits: ${result.totalCreditCost ?? 0}.`,
+      ...result.warnings && result.warnings.length > 0 ? [`Warnings: ${result.warnings.join("; ")}`] : []
+    ];
+    return {
+      kind: "assets",
+      text: lines.join("\n"),
+      assetUrls: assets.map((a) => a.url)
+    };
+  }
+  return {
+    kind: "handoff",
+    text: result.message ?? `Campaign ${result.campaignId} queued. Poll via pixeldojo:campaign_status.`,
+    jobId: result.campaignId,
+    statusUrl: result.statusUrl ?? ctx.buildStatusUrl(result.campaignId)
+  };
+}
+var campaignSkill = {
+  name: "pixeldojo:campaign",
+  description: "Generate a coherent product launch package (hero image + N lifestyle variants + optional vertical video) from one URL or product profile. Composes hero / lifestyle / video models server-side; returns assets in one call or a handoff with campaignId to poll via pixeldojo:campaign_status.",
+  inputZod: InputSchema8,
+  inputJsonSchema: InputJsonSchema8,
+  // Composition skill — internal sub-jobs route to per-tool models, no
+  // single allowed-models list applies here.
+  allowedModels: [],
+  defaultModel: "",
+  run: run8
+};
+var InputSchema9 = z.object({
+  campaignId: z.string().min(1).max(200).describe("Campaign id returned from a prior pixeldojo:campaign handoff.")
+});
+var InputJsonSchema9 = {
+  type: "object",
+  properties: {
+    campaignId: {
+      type: "string",
+      description: "Campaign id returned from a prior pixeldojo:campaign handoff."
+    }
+  },
+  required: ["campaignId"]
+};
+async function run9(input, ctx) {
+  const client = ctx.client;
+  const result = await client.getCampaign(input.campaignId);
+  if (result.kind === "campaign") {
+    const assets = result.assets ?? [];
+    const lines = [
+      `Campaign ${result.campaignId} complete (${assets.length} assets):`,
+      ...assets.map(
+        (a) => `  - ${a.role}${a.variantIndex !== void 0 ? ` #${a.variantIndex}` : ""} (${a.kind}, ${a.apiId}): ${a.url}`
+      ),
+      "",
+      `Total credits: ${result.totalCreditCost ?? 0}.`,
+      ...result.warnings && result.warnings.length > 0 ? [`Warnings: ${result.warnings.join("; ")}`] : []
+    ];
+    return {
+      kind: "assets",
+      text: lines.join("\n"),
+      assetUrls: assets.map((a) => a.url)
+    };
+  }
+  const stillRunning = (result.subJobs ?? []).filter(
+    (s) => s.status !== "completed" && s.status !== "failed"
+  );
+  return {
+    kind: "handoff",
+    text: `Campaign ${result.campaignId}: ` + (stillRunning.length > 0 ? `${stillRunning.length} of ${result.subJobs?.length ?? 0} sub-jobs still ${stillRunning[0].status}. Wait a few seconds, then poll again.` : `aggregate state pending. Poll again shortly.`),
+    jobId: result.campaignId,
+    statusUrl: result.statusUrl ?? ctx.buildStatusUrl(result.campaignId)
+  };
+}
+var campaignStatusSkill = {
+  name: "pixeldojo:campaign_status",
+  description: "Poll a campaign by campaignId returned from pixeldojo:campaign. Returns assets when every sub-job is done, or a handoff describing what is still in flight.",
+  inputZod: InputSchema9,
+  inputJsonSchema: InputJsonSchema9,
+  allowedModels: [],
+  defaultModel: "",
+  run: run9
+};
+var InputSchema10 = z.object({
+  path: z.string().min(1).max(4096).describe(
+    "Absolute local file path to upload. JPEG, PNG, WebP, GIF (\u226450MB) or MP4, WebM, MOV (\u2264200MB). Returns a public URL on the temp CDN; storage auto-expires after 24 hours."
+  )
+});
+var InputJsonSchema10 = {
+  type: "object",
+  properties: {
+    path: {
+      type: "string",
+      description: "Absolute local file path. Allowed: JPEG, PNG, WebP, GIF (\u226450MB) or MP4, WebM, MOV (\u2264200MB). Returns a public URL on the temp CDN; auto-expires after 24h."
+    }
+  },
+  required: ["path"]
+};
+async function run10(input, ctx) {
+  let url;
+  try {
+    url = await uploadLocalFile(input.path, ctx.client);
+  } catch (err) {
+    if (err instanceof SkillUploadError) {
+      return { kind: "text", text: `pixeldojo:upload: ${err.userMessage}` };
+    }
+    throw err;
+  }
+  return {
+    kind: "text",
+    text: `Uploaded ${basename(input.path)} \u2192 ${url}
+(temp storage; auto-deletes in ~24h \u2014 pass this URL as image_url to :generate or :edit)`
+  };
+}
+var uploadSkill = {
+  name: "pixeldojo:upload",
+  description: "Upload a local image or video file and get back a public URL you can pass to :generate or :edit as image_url. Use when the user has a reference image on disk (drag-dropped into Claude Code, screenshot, etc.) and you need a URL. Storage auto-expires after 24 hours.",
+  inputZod: InputSchema10,
+  inputJsonSchema: InputJsonSchema10,
+  allowedModels: [],
+  defaultModel: "",
+  run: run10
 };
 
 // src/skills/index.ts
 var ALL_SKILLS = [
   generateSkill,
+  editSkill,
   characterSkill,
   storyboardSkill,
   upscaleSkill,
-  statusSkill
+  statusSkill,
+  fromUrlSkill,
+  uploadSkill,
+  campaignSkill,
+  campaignStatusSkill
 ];
 function findSkill(name) {
   return ALL_SKILLS.find((s) => s.name === name);