@goodandready/dsh-image-gen 0.10.15 → 0.10.17

package/lib/providers.js

@@ -461,6 +461,60 @@ export async function pixelDiff(a, b) {
   return { diffRatio: diff / a.length }
 }
 
+/** Извлечение детальных сообщений об ошибках нод ComfyUI из ответа /history/{pid}. */
+
+/** Безопасное сохранение вложения с fallback'ом при отсутствии ctx.attachments */
+export async function saveAttachmentSafe(ctx, { bytes, mediaType, name }) {
+  if (ctx && ctx.attachments && typeof ctx.attachments.saveImage === 'function') {
+    try {
+      const att = await ctx.attachments.saveImage({
+        data: new Uint8Array(bytes),
+        mediaType,
+        name,
+      })
+      if (att && att.attachmentId) {
+        const localUrl = '/dsh-image-gen/image?id=' + encodeURIComponent(att.attachmentId)
+          + '&mt=' + encodeURIComponent(att.mediaType || mediaType)
+          + '&b=' + encodeURIComponent(String(att.bytes || bytes.length))
+          + '&w=' + encodeURIComponent(String(att.width || 0))
+          + '&h=' + encodeURIComponent(String(att.height || 0))
+        return { attachment: att, localUrl }
+      }
+    } catch (err) {
+      // Fallback below if attachment service fails
+    }
+  }
+  return {
+    attachment: {
+      attachmentId: '',
+      mediaType,
+      bytes: bytes.length,
+      width: 0,
+      height: 0,
+      name,
+    },
+    localUrl: '',
+  }
+}
+
+export function extractComfyNodeErrors(entry) {
+  if (!entry || typeof entry !== 'object') return ''
+  const status = entry.status
+  if (status && status.status_str === 'error') {
+    const msgs = status.messages || []
+    const errList = []
+    for (const m of msgs) {
+      if (Array.isArray(m) && m[0] === 'execution_error') {
+        const d = m[1] || {}
+        errList.push(`node ${d.node_id || 'unknown'} (${d.node_type || ''}): ${d.exception_message || d.exception_type || 'execution failed'}`)
+      }
+    }
+    if (errList.length) return errList.join('; ')
+    return status.status_str || 'execution error'
+  }
+  return ''
+}
+
 export function makeProviders(deps, job) {
   const { fetchImpl, resolveKey, cfg } = deps
   const { prompt, size, format, seed, signal, negativePrompt, guidanceScale, source, mask, strength, quality, style, aspectPixels, aspectRatio } = job
@@ -553,7 +607,7 @@ export function makeProviders(deps, job) {
           throw new Error(`Custom image API has no provisioned channel for "${cfg.customModel}" (HTTP 503); check gateway channel and routing configuration`)
         }
       }
-      const detail = data?.error?.message || JSON.stringify(data).slice(0, 600)
+      const detail = formatErrorMessage(data?.error || data)
       throw new Error(`Image API failed (HTTP ${res.status}): ${detail}`)
     }
     const item = data?.data?.[0]
@@ -727,6 +781,12 @@ export function makeProviders(deps, job) {
       if (!hist.ok) continue
       const histData = await hist.json().catch(() => ({}))
       const entry = histData[pid]
+      if (entry) {
+        const comfyErr = extractComfyNodeErrors(entry)
+        if (comfyErr) {
+          throw new Error(`Local ComfyUI execution failed: ${comfyErr}`)
+        }
+      }
       if (entry && entry.outputs) {
         const outputs = entry.outputs
         const img = Object.values(outputs).flatMap((o) => o.images || []).find((i) => i && i.filename)

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')
+}