openfig-cli 0.3.17 → 0.3.18

package/bin/commands/clone-slide.mjs

@@ -40,22 +40,65 @@ export async function run(args, flags) {
   const tmplInst = deck.getSlideInstance(nid(tmplSlide));
   if (!tmplInst) { console.error(`No instance on template slide`); process.exit(1); }
 
-  // Find SLIDE_ROW parent
-  const slideRowId = tmplSlide.parentIndex?.guid
+  // Detect MODULE wrapper: SLIDE_ROW → MODULE → SLIDE
+  const tmplParentId = tmplSlide.parentIndex?.guid
     ? `${tmplSlide.parentIndex.guid.sessionID}:${tmplSlide.parentIndex.guid.localID}`
     : null;
+  const tmplParent = tmplParentId ? deck.getNode(tmplParentId) : null;
+  const hasModule = tmplParent?.type === 'MODULE';
+  const slideRowId = hasModule
+    ? (tmplParent.parentIndex?.guid
+        ? `${tmplParent.parentIndex.guid.sessionID}:${tmplParent.parentIndex.guid.localID}`
+        : null)
+    : tmplParentId;
 
   // Generate new IDs
   let nextId = deck.maxLocalID() + 1;
+  const moduleId = hasModule ? nextId++ : null;
   const slideId = nextId++;
   const instId = nextId++;
 
+  // Create new MODULE wrapper if template uses one
+  let newModule = null;
+  if (hasModule && slideRowId) {
+    const activeCount = deck.getActiveSlides().length;
+    newModule = {
+      guid: { sessionID: 1, localID: moduleId },
+      phase: 'CREATED',
+      type: 'MODULE',
+      name: newName,
+      isPublishable: true,
+      version: tmplParent.version,
+      userFacingVersion: tmplParent.userFacingVersion,
+      visible: true,
+      opacity: 1,
+      size: deepClone(tmplParent.size ?? { x: 1920, y: 1080 }),
+      transform: deepClone(tmplParent.transform ?? { m00: 1, m01: 0, m02: 0, m10: 0, m11: 1, m12: 0 }),
+      strokeWeight: 1,
+      strokeAlign: 'INSIDE',
+      strokeJoin: 'MITER',
+      fillPaints: deepClone(tmplParent.fillPaints ?? [{ type: 'SOLID', color: { r: 1, g: 1, b: 1, a: 1 }, opacity: 1, visible: true, blendMode: 'NORMAL' }]),
+      fillGeometry: deepClone(tmplParent.fillGeometry ?? [{ windingRule: 'NONZERO', commandsBlob: 13, styleID: 0 }]),
+      frameMaskDisabled: false,
+      parentIndex: {
+        guid: parseId(slideRowId),
+        position: positionChar(activeCount),
+      },
+    };
+  }
+
   // Clone slide node
   const newSlide = deepClone(tmplSlide);
   newSlide.guid = { sessionID: 1, localID: slideId };
   newSlide.name = newName;
   newSlide.phase = 'CREATED';
-  if (slideRowId) {
+  if (hasModule && newModule) {
+    // Parent to the new MODULE
+    newSlide.parentIndex = {
+      guid: { sessionID: 1, localID: moduleId },
+      position: '!',
+    };
+  } else if (slideRowId) {
     const activeCount = deck.getActiveSlides().length;
     newSlide.parentIndex = {
       guid: parseId(slideRowId),
@@ -119,16 +162,24 @@ export async function run(args, flags) {
 
   // Set slide position
   const activeSlides = deck.getActiveSlides();
+  const xOffset = activeSlides.length * 2160;
+  if (newModule?.transform) {
+    newModule.transform.m02 = xOffset;
+  }
   if (newSlide.transform) {
-    newSlide.transform.m02 = activeSlides.length * 2160;
+    newSlide.transform.m02 = hasModule ? 0 : xOffset;
   }
 
   // Push to nodeChanges
+  if (newModule) {
+    deck.message.nodeChanges.push(newModule);
+  }
   deck.message.nodeChanges.push(newSlide);
   deck.message.nodeChanges.push(newInst);
   deck.rebuildMaps();
 
-  console.log(`Cloned slide "${tmplSlide.name}" → "${newName}" (1:${slideId} + 1:${instId})`);
+  const moduleNote = newModule ? ` + MODULE 1:${moduleId}` : '';
+  console.log(`Cloned slide "${tmplSlide.name}" → "${newName}" (1:${slideId} + 1:${instId}${moduleNote})`);
   console.log(`  ${sets.length} text override(s), ${setImages.length} image override(s)`);
 
   const bytes = await deck.saveDeck(outPath);

package/lib/images/search.mjs

@@ -0,0 +1,88 @@
+/**
+ * Image search and download — currently backed by DuckDuckGo.
+ * Generic interface so the backend can be swapped or extended later.
+ */
+import { createWriteStream, mkdirSync } from 'fs';
+import { pipeline } from 'stream/promises';
+import { join } from 'path';
+
+const sleep = ms => new Promise(r => setTimeout(r, ms));
+
+async function fetchWithRetry(url, opts, retries = 4) {
+  const delays = [2000, 5000, 10000, 20000];
+  for (let i = 0; i <= retries; i++) {
+    const res = await fetch(url, opts);
+    if (res.status !== 429 && res.status !== 403) return res;
+    if (i === retries) throw new Error(`Image search rate limit — try again in a minute (HTTP ${res.status})`);
+    await sleep(delays[i]);
+  }
+}
+
+async function getDDGToken(query) {
+  const res = await fetchWithRetry(
+    `https://duckduckgo.com/?q=${encodeURIComponent(query)}&iax=images&ia=images`,
+    { headers: { 'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36' } }
+  );
+  const html = await res.text();
+  const match = html.match(/vqd=(['"])([\d-]+)\1/);
+  if (!match) throw new Error('Could not get search token — DuckDuckGo may have changed its API');
+  return match[2];
+}
+
+export async function searchImages(query, count = 10) {
+  const vqd = await getDDGToken(query);
+  await sleep(1500); // avoid rate limiting
+  const url = `https://duckduckgo.com/i.js?l=us-en&o=json&q=${encodeURIComponent(query)}&vqd=${vqd}&f=,,,&p=1`;
+  const res = await fetchWithRetry(url, {
+    headers: {
+      'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36',
+      'Referer': 'https://duckduckgo.com/',
+      'Accept': 'application/json',
+    }
+  });
+  const data = await res.json();
+  return (data.results ?? []).slice(0, Math.min(count, 20)).map(r => ({
+    title: r.title,
+    url: r.image,
+    width: r.width,
+    height: r.height,
+    source: r.source,
+  }));
+}
+
+export async function downloadImage(url, filename, outputDir) {
+  const dir = outputDir ?? join(process.cwd(), 'images');
+  mkdirSync(dir, { recursive: true });
+
+  const rawName = url.split('/').pop().split('?')[0].replace(/[^a-zA-Z0-9._-]/g, '_');
+  const name = filename ?? (rawName.length > 0 ? rawName : 'image.jpg');
+  const outPath = join(dir, name);
+
+  const res = await fetch(url, { headers: { 'User-Agent': 'Mozilla/5.0' } });
+  if (!res.ok) throw new Error(`HTTP ${res.status} for ${url}`);
+
+  const ct = res.headers.get('content-type') ?? '';
+  if (ct && !ct.startsWith('image/') && !ct.startsWith('application/octet-stream'))
+    throw new Error(`URL returned ${ct}, not an image — try a different URL`);
+
+  const reader = res.body.getReader();
+  const { value: firstChunk } = await reader.read();
+  if (!firstChunk || firstChunk.length === 0) throw new Error('Empty response from URL');
+  const prefix = Buffer.from(firstChunk).toString('utf8', 0, 64);
+  if (/^\s*<(!DOCTYPE|html)/i.test(prefix))
+    throw new Error('URL returned an HTML page, not an image — try a different URL');
+
+  await pipeline(
+    (async function* () {
+      yield firstChunk;
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        yield value;
+      }
+    })(),
+    createWriteStream(outPath)
+  );
+
+  return outPath;
+}

package/manifest.json

@@ -1,7 +1,7 @@
 {
   "manifest_version": "0.2",
   "name": "openfig",
-  "version": "0.3.17",
+  "version": "0.3.18",
   "description": "Open-source tools for Figma file parsing and rendering",
   "author": {
     "name": "OpenFig Contributors"

package/mcp-server.mjs

@@ -21,6 +21,7 @@ import {
 import { nid, ov, removeNode } from './lib/core/node-helpers.mjs';
 import { imageOv, hashToHex } from './lib/core/image-helpers.mjs';
 import { deepClone } from './lib/core/deep-clone.mjs';
+import { searchImages, downloadImage } from './lib/images/search.mjs';
 
 const server = new McpServer({
   name: 'openfig',
@@ -222,45 +223,46 @@ server.tool(
 );
 
 // ── clone-slide ─────────────────────────────────────────────────────────
+import { run as cloneSlideRun } from './bin/commands/clone-slide.mjs';
+
 server.tool(
   'openfig_clone_slide',
   'Duplicate a slide from the deck',
   {
     path: z.string().describe('Path to .deck file'),
     output: z.string().describe('Output .deck path'),
-    slideId: z.string().describe('Source slide node ID to clone'),
+    slideId: z.string().describe('Source slide node ID or name to clone'),
+    name: z.string().optional().describe('Name for the new slide'),
+    set: z.array(z.string()).optional().describe('Text overrides as "nodeId=value" pairs'),
+    setImage: z.array(z.string()).optional().describe('Image overrides as "nodeId=path" pairs'),
   },
-  async ({ path, output, slideId }) => {
-    const deck = await FigDeck.fromDeckFile(path);
-    const slide = deck.getNode(slideId);
-    if (!slide) return { content: [{ type: 'text', text: `Slide ${slideId} not found` }] };
-
-    let nextId = deck.maxLocalID() + 1;
-    const newSlide = deepClone(slide);
-    const newSlideId = nextId++;
-    newSlide.guid = { sessionID: 1, localID: newSlideId };
-    newSlide.phase = 'CREATED';
-    delete newSlide.prototypeInteractions;
-    delete newSlide.slideThumbnailHash;
-    delete newSlide.editInfo;
-
-    const inst = deck.getSlideInstance(slideId);
-    if (inst) {
-      const newInst = deepClone(inst);
-      newInst.guid = { sessionID: 1, localID: nextId++ };
-      newInst.phase = 'CREATED';
-      newInst.parentIndex = { guid: { sessionID: 1, localID: newSlideId }, position: '!' };
-      delete newInst.derivedSymbolData;
-      delete newInst.derivedSymbolDataLayoutVersion;
-      delete newInst.editInfo;
-      deck.message.nodeChanges.push(newInst);
+  async ({ path, output, slideId, name, set, setImage }) => {
+    const logs = [];
+    const origLog = console.log;
+    const origError = console.error;
+    const origExit = process.exit;
+    console.log = (...a) => logs.push(a.join(' '));
+    console.error = (...a) => logs.push(a.join(' '));
+    process.exit = (code) => { throw new Error(`exit:${code}`); };
+    try {
+      await cloneSlideRun(
+        [path],
+        {
+          o: output,
+          template: slideId,
+          name: name || 'New Slide',
+          set: set || [],
+          'set-image': setImage || [],
+        }
+      );
+    } catch (e) {
+      if (!e.message?.startsWith('exit:')) logs.push(`Error: ${e.message}`);
+    } finally {
+      console.log = origLog;
+      console.error = origError;
+      process.exit = origExit;
     }
-
-    deck.message.nodeChanges.push(newSlide);
-    deck.rebuildMaps();
-
-    const bytes = await deck.saveDeck(output);
-    return { content: [{ type: 'text', text: `Cloned slide ${slideId} → 1:${newSlideId}. Saved ${output} (${bytes} bytes)` }] };
+    return { content: [{ type: 'text', text: logs.join('\n') }] };
   }
 );
 
@@ -536,6 +538,38 @@ server.tool(
   }
 );
 
+// ── search_images ────────────────────────────────────────────────────────
+server.tool(
+  'search_images',
+  'Search for images by keyword. Returns a numbered list of results with URLs, dimensions, and source. Use this to find filler or placeholder images for slides.',
+  {
+    query: z.string().describe('Search query, e.g. "modern office sustainability"'),
+    count: z.number().optional().describe('Number of results to return (default: 10, max: 20)'),
+  },
+  async ({ query, count = 10 }) => {
+    const results = await searchImages(query, count);
+    const lines = results.map((r, i) =>
+      `${i + 1}. ${r.title}\n   URL: ${r.url}\n   Size: ${r.width}×${r.height} | Source: ${r.source}`
+    );
+    return { content: [{ type: 'text', text: lines.join('\n\n') || 'No results found' }] };
+  }
+);
+
+// ── download_image ───────────────────────────────────────────────────────
+server.tool(
+  'download_image',
+  'Download an image from a URL to the project images/ folder. Returns the local file path. Always show the user the downloaded path before inserting into a slide.',
+  {
+    url:        z.string().describe('Image URL to download'),
+    filename:   z.string().optional().describe('Output filename (default: derived from URL)'),
+    output_dir: z.string().optional().describe('Directory to save into (default: ./images/ relative to cwd)'),
+  },
+  async ({ url, filename, output_dir }) => {
+    const outPath = await downloadImage(url, filename, output_dir);
+    return { content: [{ type: 'text', text: `Downloaded to: ${outPath}` }] };
+  }
+);
+
 // ── Start server ────────────────────────────────────────────────────────
 const transport = new StdioServerTransport();
 await server.connect(transport);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openfig-cli",
-  "version": "0.3.17",
+  "version": "0.3.18",
   "description": "OpenFig — Open-source tools for Figma file parsing and rendering",
   "type": "module",
   "bin": {
@@ -36,11 +36,11 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/rcoenen/OpenFig.git"
+    "url": "git+https://github.com/OpenFig-org/openfig-cli.git"
   },
-  "homepage": "https://github.com/rcoenen/OpenFig",
+  "homepage": "https://github.com/OpenFig-org/openfig-cli",
   "bugs": {
-    "url": "https://github.com/rcoenen/OpenFig/issues"
+    "url": "https://github.com/OpenFig-org/openfig-cli/issues"
   },
   "author": "rcoenen",
   "dependencies": {