imagegen-smarto 0.2.0 → 0.2.1

package/README.md

@@ -115,6 +115,12 @@ The command handles its relay protocol internally; the skill only prepares the
 final image prompt, supplies reference-image paths, and consumes the returned
 image result.
 
+While the relay is producing an image, the command writes a periodic status
+heartbeat with elapsed time to stderr. This is a waiting indicator, not an
+upstream completion percentage. The final `IMAGE_PATH=` and `IMAGE_MARKDOWN=`
+records remain on stdout. Pass `--quiet` to suppress status messages while
+keeping those final records.
+
 ## Local profile switch
 
 The two profiles used by the author are:

package/bin/generate.js

@@ -8,6 +8,17 @@ const path = require('node:path')
 
 const IMAGEGEN_MARKER = '__CODEX_VPS_IMAGEGEN__'
 const DEFAULT_TIMEOUT_MS = 10 * 60 * 1000
+const DEFAULT_PROGRESS_INTERVAL_MS = 15 * 1000
+
+function progressIntervalMs() {
+  const configured = Number(process.env.IMAGEGEN_SMARTO_PROGRESS_INTERVAL_MS)
+  if (Number.isFinite(configured) && configured > 0) return configured
+  return DEFAULT_PROGRESS_INTERVAL_MS
+}
+
+function reportProgress(message, quiet) {
+  if (!quiet) console.error(`imagegen-smarto: ${message}`)
+}
 
 function printGenerateHelp() {
   console.log(`imagegen-smarto generate - generate or edit an image through the active relay
@@ -23,6 +34,7 @@ Options:
   --model <model>       Override the model from Codex config
   --base-url <url>      Override the active provider base URL
   --timeout <seconds>   Request timeout (default: 600)
+  --quiet                Suppress status messages (final paths still print)
   --help                Show this help`)
 }
 
@@ -34,6 +46,7 @@ function parseGenerateArgs(argv) {
     model: null,
     baseUrl: null,
     timeoutMs: DEFAULT_TIMEOUT_MS,
+    quiet: false,
   }
   const positional = []
 
@@ -84,6 +97,11 @@ function parseGenerateArgs(argv) {
       continue
     }
 
+    if (arg === '--quiet') {
+      options.quiet = true
+      continue
+    }
+
     if (arg.startsWith('-')) {
       throw new Error(`unknown option: ${arg}`)
     }
@@ -273,7 +291,7 @@ function outputPathForIndex(requestedPath, index) {
   return `${base.slice(0, -extension.length)}-${index + 1}${extension}`
 }
 
-async function requestImage({ prompt, images, output, model, baseUrl, timeoutMs }) {
+async function requestImage({ prompt, images, output, model, baseUrl, timeoutMs, quiet }) {
   const codexHome = resolveCodexHome()
   const active = readActiveProviderConfig(codexHome)
   const apiKey = readApiKey(codexHome)
@@ -290,6 +308,14 @@ async function requestImage({ prompt, images, output, model, baseUrl, timeoutMs
   }
   const controller = new AbortController()
   const timeout = setTimeout(() => controller.abort(), timeoutMs)
+  const startedAt = Date.now()
+  const interval = progressIntervalMs()
+  const elapsedSeconds = () => Math.floor((Date.now() - startedAt) / 1000)
+  const progressTimer = setInterval(() => {
+    reportProgress(`still waiting for the image relay (${elapsedSeconds()}s elapsed)`, quiet)
+  }, interval)
+  const clearProgress = () => clearInterval(progressTimer)
+  reportProgress('starting image generation', quiet)
   let response
   try {
     response = await fetch(normalizeResponsesUrl(baseUrl || active.baseUrl), {
@@ -303,37 +329,52 @@ async function requestImage({ prompt, images, output, model, baseUrl, timeoutMs
     })
   } catch (error) {
     clearTimeout(timeout)
+    clearProgress()
     if (error.name === 'AbortError') throw new Error(`image request timed out after ${timeoutMs / 1000}s`)
     throw new Error(`cannot reach the image relay: ${error.message}`)
   }
 
   if (!response.ok) {
     clearTimeout(timeout)
+    clearProgress()
     const errorText = (await response.text()).slice(0, 2000)
     throw new Error(`image relay returned HTTP ${response.status}: ${errorText}`)
   }
   if (!response.body) {
     clearTimeout(timeout)
+    clearProgress()
     throw new Error('image relay returned no response body')
   }
 
+  reportProgress('relay connected; waiting for streamed image result', quiet)
+
   const results = []
   let relayError = null
   let buffer = ''
+  let reader = null
+  let streamDone = false
+  let resultReported = false
   const decoder = new TextDecoder()
   const onEvent = (event) => {
     relayError ||= extractError(event)
     const item = event.type === 'response.output_item.done' ? event.item : null
     if (item?.type === 'image_generation_call' && item.result) {
       results.push(item.result)
+      if (!resultReported) {
+        resultReported = true
+        reportProgress(`image result received after ${elapsedSeconds()}s; finishing response`, quiet)
+      }
     }
   }
 
   try {
-    const reader = response.body.getReader()
+    reader = response.body.getReader()
     while (true) {
       const { value, done } = await reader.read()
-      if (done) break
+      if (done) {
+        streamDone = true
+        break
+      }
       buffer += decoder.decode(value, { stream: true })
       buffer = consumeSseText(buffer, onEvent)
     }
@@ -346,6 +387,21 @@ async function requestImage({ prompt, images, output, model, baseUrl, timeoutMs
     throw new Error(`failed while reading the image relay response: ${error.message}`)
   } finally {
     clearTimeout(timeout)
+    clearProgress()
+    if (reader && !streamDone) {
+      try {
+        await reader.cancel()
+      } catch {
+        // The original request error is more useful than cleanup failures.
+      }
+    }
+    if (reader) {
+      try {
+        reader.releaseLock()
+      } catch {
+        // The stream may already have released the lock after an abort.
+      }
+    }
   }
 
   if (relayError) throw new Error(relayError)
@@ -360,6 +416,7 @@ async function requestImage({ prompt, images, output, model, baseUrl, timeoutMs
     fs.writeFileSync(filePath, decodeImageResult(results[index]), { mode: 0o600 })
     paths.push(filePath)
   }
+  reportProgress(`saved ${paths.length} image${paths.length === 1 ? '' : 's'} in ${elapsedSeconds()}s`, quiet)
   return paths
 }
 
@@ -381,6 +438,7 @@ async function generateImage(argv) {
     model: options.model,
     baseUrl: options.baseUrl,
     timeoutMs: options.timeoutMs,
+    quiet: options.quiet,
   })
   for (const filePath of paths) {
     console.log(`IMAGE_PATH=${filePath}`)

package/imagegen-smarto/SKILL.md

@@ -34,9 +34,18 @@ reading these instructions.
 
 5. If the user named an output location, pass `--output <path>`. Do not
    overwrite an existing asset unless replacement was explicitly requested.
-6. On success, include every printed `IMAGE_MARKDOWN=...` value in the answer
+6. Keep the default status heartbeat while the relay is working. Image
+   generation can take a minute or more; silence is not evidence of failure.
+   If another tool wrapper yields while the command is still running, wait for
+   the process to finish instead of interrupting it. Use `--quiet` only when a
+   caller needs machine-clean stderr.
+7. On success, include every printed `IMAGE_MARKDOWN=...` value in the answer
    so Codex displays the generated file. Report the saved path. For a failed
    command, report the actual error and do not claim that an image exists.
 
+The CLI writes status heartbeats to stderr and keeps the final `IMAGE_PATH=`
+and `IMAGE_MARKDOWN=` records on stdout. The heartbeat reports elapsed waiting
+time; it is not an upstream completion percentage or a health guarantee.
+
 For edits, state invariants explicitly in the prompt: `change only X; keep Y
 unchanged`. When iterating, make one targeted change and repeat the invariants.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "imagegen-smarto",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Install the imagegen-smarto Codex skill on Windows and Linux.",
   "bin": {
     "imagegen-smarto": "bin/cli.js"
@@ -11,7 +11,8 @@
     "README.md"
   ],
   "scripts": {
-    "postinstall": "node bin/cli.js install --postinstall"
+    "postinstall": "node bin/cli.js install --postinstall",
+    "test": "node --test"
   },
   "engines": {
     "node": ">=18"