@goodandready/dsh-image-gen 0.10.16 → 0.10.18

package/lib/providers.js

@@ -152,7 +152,12 @@ export function isFatalClientError(error) {
     msg.includes('bad request (http 400') ||
     msg.includes('invalid_prompt') ||
     msg.includes('prompt is required') ||
-    msg.includes('unsupported image format')
+    msg.includes('unsupported image format') ||
+    msg.includes('402 payment required') ||
+    msg.includes('insufficient_quota') ||
+    msg.includes('insufficient credits') ||
+    msg.includes('exceeded your current quota') ||
+    msg.includes('balance is insufficient')
   )
 }
 
@@ -371,16 +376,19 @@ export async function pollStatus(fetchImpl, statusUrl, key, signal, pollInterval
   for (;;) {
     if (signal?.aborted) throw new Error('FAL generation cancelled')
     if (Date.now() > deadline) throw new Error(`FAL generation timed out after ${timeoutMs} ms`)
-    const delay = calculateBackoff(attempt++, pollIntervalMs, 5000)
-    await new Promise((resolve) => {
-      const timer = setTimeout(resolve, delay)
-      if (signal) {
-        signal.addEventListener('abort', () => {
-          clearTimeout(timer)
-          resolve()
-        }, { once: true })
-      }
-    })
+    if (attempt > 0) {
+      const delay = calculateBackoff(attempt - 1, pollIntervalMs, 5000)
+      await new Promise((resolve) => {
+        const timer = setTimeout(resolve, delay)
+        if (signal) {
+          signal.addEventListener('abort', () => {
+            clearTimeout(timer)
+            resolve()
+          }, { once: true })
+        }
+      })
+    }
+    attempt++
     if (signal?.aborted) throw new Error('FAL generation cancelled')
     const res = await fetchImpl(statusUrl, { headers: { Authorization: falAuthHeader(key) }, signal })
     const data = await res.json().catch(() => ({}))
@@ -770,13 +778,16 @@ export function makeProviders(deps, job) {
     for (;;) {
       if (signal?.aborted) throw new Error('Local ComfyUI generation cancelled')
       if (Date.now() > deadline) throw new Error(`Local ComfyUI timed out after ${cfg.timeoutMs} ms`)
-      const cDelay = calculateBackoff(attempt++, cfg.pollIntervalMs || 1000, 5000)
-      await new Promise((resolve) => {
-        const timer = setTimeout(resolve, cDelay)
-        if (signal) {
-          signal.addEventListener('abort', () => { clearTimeout(timer); resolve() }, { once: true })
-        }
-      })
+      if (attempt > 0) {
+        const cDelay = calculateBackoff(attempt - 1, cfg.pollIntervalMs || 1000, 5000)
+        await new Promise((resolve) => {
+          const timer = setTimeout(resolve, cDelay)
+          if (signal) {
+            signal.addEventListener('abort', () => { clearTimeout(timer); resolve() }, { once: true })
+          }
+        })
+      }
+      attempt++
       const hist = await fetchImpl(`${base}/history/${pid}`, { signal })
       if (!hist.ok) continue
       const histData = await hist.json().catch(() => ({}))

package/lib/register-tools.js

@@ -0,0 +1,22 @@
+// register-tools.js — orchestrates all image-gen tool registrations (#216).
+// Each tool lives in lib/tools/* and is registered inside a labeled ctx.effect.
+
+import { registerGenerationTools } from './tools/generation.js'
+import { registerProcessingTools } from './tools/processing.js'
+import { registerEditingTools } from './tools/editing.js'
+import { registerInspectTools } from './tools/inspect.js'
+import { registerFrontendTools } from './tools/frontend.js'
+
+/**
+ * Registers every image-gen tool on the host tools service.
+ *
+ * @param {object} ctx cordis context
+ * @param {object} deps shared runtime from apply()
+ */
+export function registerAllTools(ctx, deps) {
+  registerGenerationTools(ctx, deps)
+  registerProcessingTools(ctx, deps)
+  registerEditingTools(ctx, deps)
+  registerInspectTools(ctx, deps)
+  registerFrontendTools(ctx, deps)
+}

package/lib/tools/editing.js

@@ -0,0 +1,325 @@
+// editing — image-gen tools (edit_image, vary_image). Extracted from apply() (#216).
+
+import { defineTool } from '@deepseek-ai/dsh-tools'
+import path from 'node:path'
+import { mkdir, writeFile } from 'node:fs/promises'
+import {
+  computeGenerationHash,
+  IMAGE_SIZES,
+  OUTPUT_FORMATS,
+  PROVIDER_KEYS,
+  buildSidecar,
+  makeProviders,
+  ASPECT_RATIOS,
+  pixelDiff,
+  normalizeCount,
+  tryGenerate,
+  fallbackOrder,
+  embedPngMetadata,
+  removeBackgroundFal,
+  upscaleImageFal,
+  traceToSvg,
+  estimateCost,
+  estimateSharpnessAndVariance,
+  applyStylePreset,
+  resolveStylePreset,
+  blendImagesFal,
+  toLosslessJson,
+  saveAttachmentSafe,
+} from '../providers.js'
+import { resolveConversationImage, analyzeImageWithVision, buildDualOutputMarkdown } from '../resolve-image.js'
+import { sanitizeNegativePrompt, supportsNegativePrompt } from '../negative-sanitizer.js'
+import { executeWithQualityGate } from '../quality-gate.js'
+import { calculateGenerationCost, recordSpend, assertBudgetAvailable } from '../cost-meter.js'
+import { trackAndAssertLoopGuard } from '../loop-guard.js'
+import { sanitizeErrorAndLogs } from '../security.js'
+import { getCachedGeneration, setCachedGeneration } from '../generation-cache.js'
+import {
+  extractDesignTokens,
+  generateCssGradient,
+  checkWcagContrast,
+  optimizeSvgContent,
+  generatePwaIconSuite,
+  extractSampleColorsFromBuffer,
+} from '../frontend-assets.js'
+
+
+export function registerEditingTools(ctx, deps) {
+  const {
+    config,
+    live,
+    saveAndAttachResult,
+    resolveSource,
+    slugify,
+    resolveApiKey,
+  } = deps
+  ctx.effect(() => {
+    ctx.tools.register(
+      defineTool({
+        name: 'edit_image',
+        description:
+          'Edit an existing image using inpainting, targeted modification, or object replacement. '
+          + 'Describe the desired changes in prompt. '
+          + 'If image is omitted or "latest", automatically resolves the most recent image from the conversation session (#144). '
+          + 'Leverages @goodandready/dsh-vision-bridge for pre-edit composition analysis (#145). '
+          + 'Optionally accepts mask (path or attachment id) and strength (0.1-1.0). Returns safe dual-output (#150).',
+        parameters: {
+          prompt: {
+            type: 'string',
+            required: true,
+            description: 'Detailed description of the modification or edit to perform on the image.',
+          },
+          image: {
+            type: 'string',
+            description: 'Path or attachment id of the source image. Defaults to "latest" to auto-resolve from session history.',
+          },
+          mask: {
+            type: 'string',
+            description: 'Optional path or attachment id of the inpaint mask image.',
+          },
+          strength: {
+            type: 'number',
+            description: 'Denoising / edit strength between 0.1 and 1.0 (default 0.75 for edits, 0.9 for mask inpainting).',
+          },
+          output_name: {
+            type: 'string',
+            description: 'Optional file name stem for the saved edited image.',
+          },
+          output_dir: {
+            type: 'string',
+            description: 'Optional custom directory to write edited image into.',
+          },
+        },
+        output: {
+          schema: {
+            type: 'object',
+            additionalProperties: true,
+            properties: {
+              summary: { type: 'string' },
+              path: { type: 'string' },
+              url: { type: 'string' },
+              width: { type: 'number' },
+              height: { type: 'number' },
+              seed: { type: 'number' },
+              provider: { type: 'string' },
+              cost: { type: 'number' },
+              format: { type: 'string' },
+              attachment: { type: 'object', additionalProperties: true },
+              visionAnalysis: { type: 'string' },
+            },
+          },
+        },
+        async execute(args, exec) {
+          try {
+            trackAndAssertLoopGuard(exec?.agent?.session?.id || 'default', { limit: cfg.loopGuardLimit })
+            const estimatedCostEdit = calculateGenerationCost({
+              provider: cfg.provider || 'fal',
+              model: cfg.model,
+              size: cfg.defaultSize || 'square_hd',
+              count: 1,
+            })
+            assertBudgetAvailable(estimatedCostEdit, cfg.dailyBudgetUsd)
+            const source = await resolveConversationImage(ctx, exec, args.image)
+          const mask = args.mask ? await resolveSource(ctx, exec, args.mask) : undefined
+          const vision = await analyzeImageWithVision(ctx, exec, source)
+
+          let effectivePrompt = args.prompt
+          if (vision.available && vision.summary) {
+            effectivePrompt = `${args.prompt} (Context: modifying ${vision.summary})`
+          }
+
+          const provider = cfg.provider || 'fal'
+          const deps = {
+            fetchImpl: ctx.http ? (url, opt) => ctx.http(url, opt) : fetch,
+            resolveKey: (ref) => resolveApiKey(ctx, ref),
+            cfg,
+          }
+
+          const seed = Math.floor(Math.random() * 100000)
+          const strength = args.strength ?? (mask ? 0.85 : 0.65)
+          const format = cfg.defaultFormat || 'png'
+          const size = cfg.defaultSize || 'square_hd'
+
+          const job = {
+            prompt: effectivePrompt,
+            size,
+            format,
+            seed,
+            source,
+            mask,
+            strength,
+            provider,
+          }
+
+          const providers = makeProviders(deps, job)
+          const fn = providers[provider] || providers.fal || providers.custom
+          const gen = await fn(seed, effectivePrompt)
+
+          const stem = args.output_name ? slugify(args.output_name) : `${source.name}-edit-${seed}`
+          const name = `${stem}.${format}`
+
+          const result = await saveAndAttachResult(ctx, exec, cfg, {
+            bytes: gen.bytes,
+            mediaType: gen.mediaType || 'image/png',
+            name,
+            stem,
+            prompt: args.prompt,
+            size,
+            format,
+            seed: gen.seed ?? seed,
+            provider,
+            model: cfg.model,
+            cost: gen.cost,
+            sourceUrl: gen.sourceUrl,
+            deliverAs: cfg.deliverAs || 'both',
+            args,
+            action: 'edited',
+          })
+
+          if (vision.summary) {
+            result.visionAnalysis = vision.summary
+          }
+          return toLosslessJson(result)
+          } catch (err) {
+            throw new Error(sanitizeErrorAndLogs(err.message || err))
+          }
+        },
+      }),
+    )
+  }, 'dsh-image-gen: tool edit_image')
+  ctx.effect(() => {
+    ctx.tools.register(
+      defineTool({
+        name: 'vary_image',
+        description:
+          'Generate subtle or creative variations of an existing image while preserving overall composition and structure. '
+          + 'Pass variation_strength between 0.1 (subtle difference) and 0.9 (strong reinterpretation, default 0.35). '
+          + 'If image is omitted or "latest", automatically resolves the most recent image from the conversation session (#144). '
+          + 'Returns safe dual-output for text-only LLMs (#150).',
+        parameters: {
+          image: {
+            type: 'string',
+            description: 'Path or attachment id of the source image. Defaults to "latest" to auto-resolve from session history.',
+          },
+          prompt: {
+            type: 'string',
+            description: 'Optional prompt to steer the variation towards a specific mood, lighting, or style.',
+          },
+          variation_strength: {
+            type: 'number',
+            description: 'Strength of variation between 0.1 and 0.9. Default: 0.35.',
+          },
+          count: {
+            type: 'integer',
+            description: 'Number of variations to produce (1-4, default 1).',
+          },
+          output_name: {
+            type: 'string',
+            description: 'Optional file name stem for the saved variations.',
+          },
+          output_dir: {
+            type: 'string',
+            description: 'Optional custom directory to write variations into.',
+          },
+        },
+        output: {
+          schema: {
+            type: 'object',
+            additionalProperties: true,
+            properties: {
+              summary: { type: 'string' },
+              path: { type: 'string' },
+              url: { type: 'string' },
+              width: { type: 'number' },
+              height: { type: 'number' },
+              seed: { type: 'number' },
+              provider: { type: 'string' },
+              cost: { type: 'number' },
+              format: { type: 'string' },
+              attachment: { type: 'object', additionalProperties: true },
+              variations: { type: 'array', items: { type: 'object', additionalProperties: true } },
+            },
+          },
+        },
+        async execute(args, exec) {
+          try {
+            trackAndAssertLoopGuard(exec?.agent?.session?.id || 'default', { limit: cfg.loopGuardLimit })
+            const count = normalizeCount(args.count || 1)
+            const estimatedCostVary = calculateGenerationCost({
+              provider: cfg.provider || 'fal',
+              model: cfg.model,
+              size: cfg.defaultSize || 'square_hd',
+              count,
+            })
+            assertBudgetAvailable(estimatedCostVary, cfg.dailyBudgetUsd)
+            const source = await resolveConversationImage(ctx, exec, args.image)
+          const vision = await analyzeImageWithVision(ctx, exec, source)
+
+          const provider = cfg.provider || 'fal'
+          const deps = {
+            fetchImpl: ctx.http ? (url, opt) => ctx.http(url, opt) : fetch,
+            resolveKey: (ref) => resolveApiKey(ctx, ref),
+            cfg,
+          }
+          const variationStrength = Math.max(0.05, Math.min(0.95, args.variation_strength ?? 0.35))
+          const baseSeed = Math.floor(Math.random() * 100000)
+          const format = cfg.defaultFormat || 'png'
+          const size = cfg.defaultSize || 'square_hd'
+
+          const promptText = args.prompt || (vision.available ? `variation of ${vision.summary}` : 'high fidelity variation preserving composition')
+
+          const results = []
+          for (let i = 0; i < count; i++) {
+            const currentSeed = baseSeed + i
+            const job = {
+              prompt: promptText,
+              size,
+              format,
+              seed: currentSeed,
+              source,
+              strength: variationStrength,
+              provider,
+            }
+
+            const providers = makeProviders(deps, job)
+            const fn = providers[provider] || providers.fal || providers.custom
+            const gen = await fn(currentSeed, promptText)
+
+            const stem = args.output_name
+              ? `${slugify(args.output_name)}-var-${i + 1}`
+              : `${source.name}-var-${currentSeed}`
+            const name = `${stem}.${format}`
+
+            const item = await saveAndAttachResult(ctx, exec, cfg, {
+              bytes: gen.bytes,
+              mediaType: gen.mediaType || 'image/png',
+              name,
+              stem,
+              prompt: promptText,
+              size,
+              format,
+              seed: gen.seed ?? currentSeed,
+              provider,
+              model: cfg.model,
+              cost: gen.cost,
+              sourceUrl: gen.sourceUrl,
+              deliverAs: cfg.deliverAs || 'both',
+              args,
+              action: `variation (${variationStrength})`,
+            })
+            results.push(item)
+          }
+
+          const first = results[0]
+          return toLosslessJson({
+            ...first,
+            variations: results.map((r) => ({ path: r.path, attachmentId: r.attachment?.attachmentId, seed: r.seed })),
+          })
+          } catch (err) {
+            throw new Error(sanitizeErrorAndLogs(err.message || err))
+          }
+        },
+      }),
+    )
+  }, 'dsh-image-gen: tool vary_image')
+}

package/lib/tools/frontend.js

@@ -0,0 +1,258 @@
+// frontend — image-gen tools (extract_design_tokens, image_to_css_gradient, check_image_contrast, optimize_vector_svg, generate_pwa_icon_suite). Extracted from apply() (#216).
+
+import { defineTool } from '@deepseek-ai/dsh-tools'
+import path from 'node:path'
+import { mkdir, writeFile } from 'node:fs/promises'
+import {
+  computeGenerationHash,
+  IMAGE_SIZES,
+  OUTPUT_FORMATS,
+  PROVIDER_KEYS,
+  buildSidecar,
+  makeProviders,
+  ASPECT_RATIOS,
+  pixelDiff,
+  normalizeCount,
+  tryGenerate,
+  fallbackOrder,
+  embedPngMetadata,
+  removeBackgroundFal,
+  upscaleImageFal,
+  traceToSvg,
+  estimateCost,
+  estimateSharpnessAndVariance,
+  applyStylePreset,
+  resolveStylePreset,
+  blendImagesFal,
+  toLosslessJson,
+  saveAttachmentSafe,
+} from '../providers.js'
+import { resolveConversationImage, analyzeImageWithVision, buildDualOutputMarkdown } from '../resolve-image.js'
+import { sanitizeNegativePrompt, supportsNegativePrompt } from '../negative-sanitizer.js'
+import { executeWithQualityGate } from '../quality-gate.js'
+import { calculateGenerationCost, recordSpend, assertBudgetAvailable } from '../cost-meter.js'
+import { trackAndAssertLoopGuard } from '../loop-guard.js'
+import { sanitizeErrorAndLogs } from '../security.js'
+import { getCachedGeneration, setCachedGeneration } from '../generation-cache.js'
+import {
+  extractDesignTokens,
+  generateCssGradient,
+  checkWcagContrast,
+  optimizeSvgContent,
+  generatePwaIconSuite,
+  extractSampleColorsFromBuffer,
+} from '../frontend-assets.js'
+
+
+export function registerFrontendTools(ctx, deps) {
+  const {
+    config,
+    live,
+    saveAndAttachResult,
+    resolveSource,
+    slugify,
+    resolveApiKey,
+  } = deps
+  ctx.effect(() => {
+    ctx.tools.register(
+      defineTool({
+        name: 'extract_design_tokens',
+        description: 'Extract design tokens (CSS variables, Tailwind colors config, W3C tokens JSON) from an image or palette.',
+        parameters: {
+          image: { type: 'string', description: 'Path or attachment ID of the image to extract colors from.' },
+          colors: { type: 'array', items: { type: 'string' }, description: 'Optional list of hex colors if already known.' },
+          prefix: { type: 'string', description: 'Token naming prefix (default: color).' },
+        },
+        output: {
+          schema: {
+            type: 'object',
+            additionalProperties: true,
+            properties: {
+              tokens: { type: 'object', additionalProperties: true },
+              cssVariables: { type: 'string' },
+              tailwindSnippet: { type: 'string' },
+              w3cTokens: { type: 'object', additionalProperties: true },
+            },
+          },
+        },
+        async execute(args, exec) {
+          let colors = args.colors
+          if (!colors || colors.length === 0) {
+            if (args.image) {
+              const source = await resolveSource(ctx, exec, args.image)
+              if (!source || !source.bytes) {
+                throw new Error('Image not found or unreadable: ' + args.image)
+              }
+              colors = extractSampleColorsFromBuffer(source.bytes)
+            }
+          }
+          return toLosslessJson(extractDesignTokens(colors, { prefix: args.prefix }))
+        },
+      }),
+    )
+  }, 'dsh-image-gen: tool extract_design_tokens')
+  ctx.effect(() => {
+    ctx.tools.register(
+      defineTool({
+        name: 'image_to_css_gradient',
+        description: 'Convert an image background or color palette into a lightweight pure CSS gradient (< 1KB).',
+        parameters: {
+          image: { type: 'string', description: 'Path or attachment ID of the image.' },
+          colors: { type: 'array', items: { type: 'string' }, description: 'Optional explicit hex colors for the gradient.' },
+          type: { type: 'string', enum: ['mesh', 'linear', 'radial'], description: 'Gradient type: mesh, linear, or radial (default: mesh).' },
+        },
+        output: {
+          schema: {
+            type: 'object',
+            additionalProperties: true,
+            properties: {
+              type: { type: 'string' },
+              fallbackColor: { type: 'string' },
+              gradientCss: { type: 'string' },
+              completeStyle: { type: 'string' },
+              byteSize: { type: 'number' },
+            },
+          },
+        },
+        async execute(args, exec) {
+          let colors = args.colors
+          if (!colors || colors.length === 0) {
+            if (args.image) {
+              const source = await resolveSource(ctx, exec, args.image)
+              if (!source || !source.bytes) {
+                throw new Error('Image not found or unreadable: ' + args.image)
+              }
+              colors = extractSampleColorsFromBuffer(source.bytes)
+            }
+          }
+          return toLosslessJson(generateCssGradient(colors, args.type || 'mesh'))
+        },
+      }),
+    )
+  }, 'dsh-image-gen: tool image_to_css_gradient')
+  ctx.effect(() => {
+    ctx.tools.register(
+      defineTool({
+        name: 'check_image_contrast',
+        description: 'Check image background contrast ratio against text color according to WCAG 2.1 AA/AAA standards and suggest scrim.',
+        parameters: {
+          image: { type: 'string', description: 'Path or attachment ID of the image.' },
+          colors: { type: 'array', items: { type: 'string' }, description: 'Optional list of background hex colors.' },
+          text_color: { type: 'string', description: 'Text hex color to test against (default: #ffffff).' },
+        },
+        output: {
+          schema: {
+            type: 'object',
+            additionalProperties: true,
+            properties: {
+              textHex: { type: 'string' },
+              minContrastRatio: { type: 'number' },
+              passedAA: { type: 'boolean' },
+              passedAALarge: { type: 'boolean' },
+              passedAAA: { type: 'boolean' },
+              recommendation: { type: 'string' },
+              suggestedScrimCss: { type: 'string' },
+              details: { type: 'array', items: { type: 'object', additionalProperties: true } },
+            },
+          },
+        },
+        async execute(args, exec) {
+          let colors = args.colors
+          if (!colors || colors.length === 0) {
+            if (args.image) {
+              const source = await resolveSource(ctx, exec, args.image)
+              if (!source || !source.bytes) {
+                throw new Error('Image not found or unreadable: ' + args.image)
+              }
+              colors = extractSampleColorsFromBuffer(source.bytes)
+            }
+          }
+          return toLosslessJson(checkWcagContrast(colors, args.text_color || '#ffffff'))
+        },
+      }),
+    )
+  }, 'dsh-image-gen: tool check_image_contrast')
+  ctx.effect(() => {
+    ctx.tools.register(
+      defineTool({
+        name: 'optimize_vector_svg',
+        description: 'Clean, sanitize, and minify SVG content, normalize viewBox, and export React TSX component.',
+        parameters: {
+          svg_content: { type: 'string', description: 'Raw SVG markup string to optimize.' },
+          image: { type: 'string', description: 'Path or attachment ID of an SVG file if not passing raw string.' },
+          component_name: { type: 'string', description: 'React component name for TSX export (default: VectorIcon).' },
+        },
+        output: {
+          schema: {
+            type: 'object',
+            additionalProperties: true,
+            properties: {
+              svg: { type: 'string' },
+              viewBox: { type: 'string' },
+              originalSize: { type: 'number' },
+              optimizedSize: { type: 'number' },
+              savedBytes: { type: 'number' },
+              reductionPercent: { type: 'number' },
+              reactTsx: { type: 'string' },
+            },
+          },
+        },
+        async execute(args, exec) {
+          let svgStr = args.svg_content
+          if (!svgStr && args.image) {
+            const source = await resolveSource(ctx, exec, args.image)
+            if (source && source.bytes) {
+              svgStr = source.bytes.toString('utf8')
+            }
+          }
+          if (!svgStr) {
+            throw new Error('Either svg_content or image must be provided')
+          }
+          return optimizeSvgContent(svgStr, { componentName: args.component_name })
+        },
+      }),
+    )
+  }, 'dsh-image-gen: tool optimize_vector_svg')
+  ctx.effect(() => {
+    ctx.tools.register(
+      defineTool({
+        name: 'generate_pwa_icon_suite',
+        description: 'Generate standard PWA icons specification, HTML meta tags, and web app manifest.json.',
+        parameters: {
+          image: { type: 'string', description: 'Source icon image path or attachment ID.' },
+          name: { type: 'string', description: 'App name (e.g. My Application).' },
+          short_name: { type: 'string', description: 'App short name (e.g. MyApp).' },
+          theme_color: { type: 'string', description: 'Theme color hex (e.g. #0f172a).' },
+          background_color: { type: 'string', description: 'Background color hex (e.g. #ffffff).' },
+          icons_dir: { type: 'string', description: 'Directory for icons relative to webroot (default: icons).' },
+        },
+        output: {
+          schema: {
+            type: 'object',
+            additionalProperties: true,
+            properties: {
+              name: { type: 'string' },
+              shortName: { type: 'string' },
+              themeColor: { type: 'string' },
+              backgroundColor: { type: 'string' },
+              icons: { type: 'array', items: { type: 'object', additionalProperties: true } },
+              manifestJson: { type: 'string' },
+              htmlHeadSnippet: { type: 'string' },
+            },
+          },
+        },
+        async execute(args, exec) {
+          const res = await generatePwaIconSuite({
+            name: args.name || 'App',
+            shortName: args.short_name || args.name || 'App',
+            themeColor: args.theme_color || '#0f172a',
+            backgroundColor: args.background_color || '#ffffff',
+            iconsDir: args.icons_dir || 'icons',
+            sourcePath: args.image || null,
+          })
+          return toLosslessJson(res)
+        },
+      }),
+    )
+  }, 'dsh-image-gen: tool generate_pwa_icon_suite')
+}