@storewright/cli 0.14.0

package/scripts/generate-image-assets-openai.mjs

@@ -0,0 +1,342 @@
+#!/usr/bin/env node
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, isAbsolute, join } from "node:path";
+import { pathToFileURL } from "node:url";
+
+const defaultApiKeyEnv = "OPENAI_API_KEY";
+const defaultModel = "gpt-image-1.5";
+const defaultSize = "1536x1024";
+const defaultQuality = "auto";
+const defaultOutputFormat = "png";
+const openAiImagesEndpoint = "https://api.openai.com/v1/images/generations";
+
+function parseArgs(argv) {
+  const args = {};
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "--spec") {
+      args.specPath = argv[index + 1];
+      index += 1;
+    } else if (arg === "--output") {
+      args.outputPath = argv[index + 1];
+      index += 1;
+    } else if (arg === "--run-dir") {
+      args.runDir = argv[index + 1];
+      index += 1;
+    } else if (arg === "--env-file") {
+      args.envFilePath = argv[index + 1];
+      index += 1;
+    } else if (arg === "--api-key-env") {
+      args.apiKeyEnv = argv[index + 1];
+      index += 1;
+    }
+  }
+  return args;
+}
+
+function resolveRunPath(runDir, filePath) {
+  if (!filePath || isAbsolute(filePath)) {
+    return filePath;
+  }
+  return join(runDir, filePath);
+}
+
+export function parseEnvFile(source) {
+  const values = {};
+  for (const [index, rawLine] of source.split(/\r?\n/).entries()) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) {
+      continue;
+    }
+    if (line.startsWith("export ")) {
+      throw new Error(`Unsupported env-file syntax on line ${index + 1}`);
+    }
+    const match = /^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/.exec(line);
+    if (!match) {
+      throw new Error(`Invalid env-file line ${index + 1}`);
+    }
+    let value = match[2].trim();
+    if (
+      (value.startsWith("\"") && value.endsWith("\"")) ||
+      (value.startsWith("'") && value.endsWith("'"))
+    ) {
+      value = value.slice(1, -1);
+    }
+    values[match[1]] = value;
+  }
+  return values;
+}
+
+async function readEnvFile({ envFilePath, cwd }) {
+  if (!envFilePath) {
+    return {};
+  }
+  const resolvedPath = isAbsolute(envFilePath) ? envFilePath : join(cwd, envFilePath);
+  return parseEnvFile(await readFile(resolvedPath, "utf8"));
+}
+
+function openAiAssets(spec) {
+  const assets = spec.mediaGeneration?.assets ?? spec.media?.assets ?? [];
+  return assets.filter((asset) => asset.generation?.provider === "openai");
+}
+
+function redact(value, secrets) {
+  let redacted = String(value ?? "");
+  for (const secret of secrets) {
+    if (secret) {
+      redacted = redacted.split(secret).join("[redacted]");
+    }
+  }
+  return redacted;
+}
+
+function sanitizeApiError({ payload, status, secrets }) {
+  const error = payload?.error ?? {};
+  return {
+    status,
+    code: redact(error.code ?? `http_${status}`, secrets),
+    message: redact(error.message ?? `OpenAI image generation failed with HTTP ${status}`, secrets)
+  };
+}
+
+function assetResultBase(asset, model) {
+  return {
+    assetId: asset.assetId,
+    ...(asset.slotId ? { slotId: asset.slotId } : {}),
+    ...(asset.candidateId ? { candidateId: asset.candidateId } : {}),
+    localPath: asset.localPath,
+    model
+  };
+}
+
+function generationDetails(asset) {
+  const generation = asset.generation ?? {};
+  return {
+    prompt: generation.prompt,
+    model: generation.model ?? defaultModel,
+    size: generation.size ?? defaultSize,
+    quality: generation.quality ?? defaultQuality,
+    outputFormat: generation.outputFormat ?? defaultOutputFormat
+  };
+}
+
+function skippedMissingCredentialResult(asset, apiKeyEnv) {
+  const details = generationDetails(asset);
+  return {
+    ...assetResultBase(asset, details.model),
+    prompt: details.prompt,
+    size: details.size,
+    quality: details.quality,
+    outputFormat: details.outputFormat,
+    apiKeyEnv,
+    credentialStatus: "missing",
+    status: "skipped",
+    reasonCode: "missing_credential",
+    warning: `OpenAI credential missing, generation skipped. Prompt: ${details.prompt ?? ""}`.trim()
+  };
+}
+
+function skippedGenerationFailureResult({ asset, reasonCode, warning, error }) {
+  const details = generationDetails(asset);
+  return {
+    ...assetResultBase(asset, details.model),
+    prompt: details.prompt,
+    size: details.size,
+    quality: details.quality,
+    outputFormat: details.outputFormat,
+    status: "skipped",
+    reasonCode,
+    warning,
+    ...(error ? { error } : {})
+  };
+}
+
+function missingPromptResult(asset) {
+  const details = generationDetails(asset);
+  return {
+    ...assetResultBase(asset, details.model),
+    prompt: details.prompt,
+    size: details.size,
+    quality: details.quality,
+    outputFormat: details.outputFormat,
+    status: "error",
+    reasonCode: "missing_prompt",
+    error: {
+      code: "missing_prompt",
+      message: "Missing OpenAI image generation prompt"
+    }
+  };
+}
+
+async function readResponseJson(response) {
+  try {
+    return await response.json();
+  } catch {
+    return {};
+  }
+}
+
+function sanitizeThrownError({ error, secrets }) {
+  return {
+    code: "fetch_error",
+    message: redact(error?.message ?? "OpenAI image generation request failed", secrets)
+  };
+}
+
+async function generateAsset({ asset, apiKey, fetchImpl, runDir }) {
+  const generation = asset.generation ?? {};
+  const model = generation.model ?? defaultModel;
+  const prompt = generation.prompt;
+  const secrets = [apiKey];
+
+  if (!prompt) {
+    return missingPromptResult(asset);
+  }
+
+  const body = {
+    model,
+    prompt,
+    size: generation.size ?? defaultSize,
+    quality: generation.quality ?? defaultQuality,
+    output_format: generation.outputFormat ?? defaultOutputFormat
+  };
+
+  let response;
+  try {
+    response = await fetchImpl(openAiImagesEndpoint, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body)
+    });
+  } catch (error) {
+    return skippedGenerationFailureResult({
+      asset,
+      reasonCode: "fetch_error",
+      warning: "OpenAI image generation request failed, generation skipped.",
+      error: sanitizeThrownError({ error, secrets })
+    });
+  }
+  const payload = await readResponseJson(response);
+
+  if (!response.ok) {
+    return skippedGenerationFailureResult({
+      asset,
+      reasonCode: "api_error",
+      warning: "OpenAI image generation API error, generation skipped.",
+      error: sanitizeApiError({ payload, status: response.status, secrets })
+    });
+  }
+
+  const imageBase64 = payload.data?.[0]?.b64_json;
+  if (!imageBase64) {
+    return skippedGenerationFailureResult({
+      asset,
+      reasonCode: "missing_b64_json",
+      warning: "OpenAI image generation response missing image data, generation skipped.",
+      error: {
+        code: "missing_b64_json",
+        message: "OpenAI image generation response did not include b64_json"
+      }
+    });
+  }
+
+  const absoluteLocalPath = resolveRunPath(runDir, asset.localPath);
+  await mkdir(dirname(absoluteLocalPath), { recursive: true });
+  await writeFile(absoluteLocalPath, Buffer.from(imageBase64, "base64"));
+
+  return {
+    ...assetResultBase(asset, model),
+    status: "generated",
+    usage: payload.usage ?? {}
+  };
+}
+
+async function writeReport({ outputPath, runDir, report }) {
+  const resolvedOutputPath = outputPath ?? join(runDir, "openai-image-generation-report.json");
+  await mkdir(dirname(resolvedOutputPath), { recursive: true });
+  await writeFile(resolvedOutputPath, `${JSON.stringify(report, null, 2)}\n`);
+  return resolvedOutputPath;
+}
+
+export async function generateOpenAiImageAssets({
+  specPath,
+  outputPath,
+  runDir,
+  envFilePath,
+  apiKeyEnv,
+  cwd = process.cwd(),
+  processEnv = process.env,
+  fetchImpl = globalThis.fetch
+}) {
+  if (!specPath) {
+    throw new Error("Missing --spec argument");
+  }
+  if (typeof fetchImpl !== "function") {
+    throw new Error("A fetch implementation is required");
+  }
+
+  const resolvedRunDir = runDir ?? dirname(specPath);
+  const spec = JSON.parse(await readFile(specPath, "utf8"));
+  const assets = openAiAssets(spec);
+  const requestedApiKeyEnv = apiKeyEnv ?? assets[0]?.generation?.apiKeyEnv ?? defaultApiKeyEnv;
+  const envFileValues = await readEnvFile({ envFilePath, cwd });
+  const apiKey = processEnv[requestedApiKeyEnv] ?? envFileValues[requestedApiKeyEnv];
+  const credentialStatus = apiKey ? "present" : "missing";
+
+  const report = {
+    schemaVersion: "1.0.0",
+    runId: spec.runId,
+    authoring: {
+      mode: "worker-authored",
+      createdBy: "media-production-worker",
+      sourceInputArtifacts: spec.authoring?.sourceInputArtifacts ?? ["media-generation-spec.json"]
+    },
+    openaiImageGeneration: {
+      apiKeyEnv: requestedApiKeyEnv,
+      credentialStatus,
+      envFileUsed: Boolean(envFilePath),
+      assets: []
+    }
+  };
+
+  if (!apiKey) {
+    report.openaiImageGeneration.assets = assets.map((asset) => (
+      asset.generation?.prompt
+        ? skippedMissingCredentialResult(asset, requestedApiKeyEnv)
+        : missingPromptResult(asset)
+    ));
+    const resolvedOutputPath = await writeReport({ outputPath, runDir: resolvedRunDir, report });
+    const ok = report.openaiImageGeneration.assets.every((asset) => asset.status === "skipped");
+    return { ok, outputPath: resolvedOutputPath, assetCount: assets.length };
+  }
+
+  for (const asset of assets) {
+    report.openaiImageGeneration.assets.push(await generateAsset({ asset, apiKey, fetchImpl, runDir: resolvedRunDir }));
+  }
+
+  const ok = report.openaiImageGeneration.assets.every((asset) => (
+    asset.status === "generated" || asset.status === "skipped"
+  ));
+  const resolvedOutputPath = await writeReport({ outputPath, runDir: resolvedRunDir, report });
+  return { ok, outputPath: resolvedOutputPath, assetCount: assets.length };
+}
+
+async function main() {
+  try {
+    const result = await generateOpenAiImageAssets(parseArgs(process.argv.slice(2)));
+    console.log(JSON.stringify(result));
+    if (!result.ok) {
+      process.exitCode = 1;
+    }
+  } catch (error) {
+    console.error(error.message);
+    process.exitCode = 1;
+  }
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  await main();
+}

package/scripts/generate-media-assets.mjs

@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+import { copyFile, mkdir, readFile, writeFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { dirname, isAbsolute, join } from "node:path";
+import { pathToFileURL } from "node:url";
+
+function parseArgs(argv) {
+  const args = {};
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "--spec") {
+      args.specPath = argv[index + 1];
+      index += 1;
+    } else if (arg === "--output") {
+      args.outputPath = argv[index + 1];
+      index += 1;
+    } else if (arg === "--run-dir") {
+      args.runDir = argv[index + 1];
+      index += 1;
+    }
+  }
+  return args;
+}
+
+function resolveRunPath(runDir, filePath) {
+  if (!filePath || isAbsolute(filePath)) {
+    return filePath;
+  }
+  return join(runDir, filePath);
+}
+
+function decodeDataUri(dataUri) {
+  const match = /^data:([^;,]+)?(;base64)?,(.*)$/s.exec(dataUri);
+  if (!match) {
+    throw new Error("Invalid data URI");
+  }
+  return Buffer.from(decodeURIComponent(match[3]), match[2] ? "base64" : "utf8");
+}
+
+async function materializeAsset({ asset, runDir }) {
+  const localPath = asset.localPath;
+  if (!localPath) {
+    return { ...asset, status: "generation-required", warnings: ["missing localPath"] };
+  }
+
+  const absoluteLocalPath = resolveRunPath(runDir, localPath);
+  await mkdir(dirname(absoluteLocalPath), { recursive: true });
+
+  if (asset.dataUri) {
+    await writeFile(absoluteLocalPath, decodeDataUri(asset.dataUri));
+  } else if (asset.sourceLocalPath) {
+    await copyFile(resolveRunPath(runDir, asset.sourceLocalPath), absoluteLocalPath);
+  }
+
+  const fileExists = existsSync(absoluteLocalPath);
+  const warnings = [...(asset.warnings ?? [])];
+  let status = asset.status;
+
+  if (fileExists) {
+    status = status === "generation-required" ? "ready-for-upload" : (status ?? "ready-for-upload");
+  } else if (status === "ready-for-upload" || status === "source-downloaded" || status === "uploaded") {
+    status = "upload-blocked";
+    warnings.push(`localPath does not exist: ${localPath}`);
+  } else {
+    status ??= "generation-required";
+  }
+
+  const { dataUri, sourceLocalPath, generation, ...manifestAsset } = asset;
+  return {
+    ...manifestAsset,
+    status,
+    ...(warnings.length > 0 ? { warnings } : {})
+  };
+}
+
+export async function generateMediaAssets({ specPath, outputPath, runDir }) {
+  if (!specPath) {
+    throw new Error("Missing --spec argument");
+  }
+
+  const resolvedRunDir = runDir ?? dirname(specPath);
+  const spec = JSON.parse(await readFile(specPath, "utf8"));
+  const assets = spec.mediaGeneration?.assets ?? spec.media?.assets ?? [];
+  const manifestAssets = [];
+
+  for (const asset of assets) {
+    manifestAssets.push(await materializeAsset({ asset, runDir: resolvedRunDir }));
+  }
+
+  const manifest = {
+    schemaVersion: "1.0.0",
+    runId: spec.runId,
+    authoring: {
+      mode: "worker-authored",
+      createdBy: "media-production-worker",
+      sourceInputArtifacts: spec.authoring?.sourceInputArtifacts ?? ["media-generation-spec.json"]
+    },
+    media: {
+      assets: manifestAssets
+    }
+  };
+
+  const resolvedOutputPath = outputPath ?? join(resolvedRunDir, "media-manifest.json");
+  await mkdir(dirname(resolvedOutputPath), { recursive: true });
+  await writeFile(resolvedOutputPath, `${JSON.stringify(manifest, null, 2)}\n`);
+  return { outputPath: resolvedOutputPath, assetCount: manifestAssets.length };
+}
+
+async function main() {
+  try {
+    const result = await generateMediaAssets(parseArgs(process.argv.slice(2)));
+    console.log(JSON.stringify(result));
+  } catch (error) {
+    console.error(error.message);
+    process.exitCode = 1;
+  }
+}
+
+if (import.meta.url === pathToFileURL(process.argv[1]).href) {
+  await main();
+}

package/scripts/init-run-state.mjs

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+import { mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+
+import { writeInitialProgress } from "../lib/internal/run-state-helpers.mjs";
+
+function parseArgs(argv) {
+  const options = {};
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    const value = argv[index + 1];
+    if (arg === "--help" || arg === "-h") {
+      options.help = true;
+    } else if (arg === "--workspace-dir") {
+      options.workspaceDir = value;
+      index += 1;
+    } else if (arg === "--run-id") {
+      options.runId = value;
+      index += 1;
+    } else if (arg === "--run-dir") {
+      options.runDir = value;
+      index += 1;
+    }
+  }
+  return options;
+}
+
+function usage() {
+  return [
+    "Usage: init-run-state.mjs [--workspace-dir <path>] [--run-id <id>] [--run-dir <path>]",
+    "",
+    "Initializes .storewright/runs/<run-id>/PROGRESS.md before Stage 1."
+  ].join("\n");
+}
+
+function timestampRunId(date = new Date()) {
+  return date.toISOString().replace(/[:.]/g, "").replace("T", "-").replace("Z", "Z");
+}
+
+export async function initRunState(options = {}) {
+  const workspaceDir = options.workspaceDir ?? process.cwd();
+  const runId = options.runId ?? timestampRunId();
+  const runDir = options.runDir ?? join(workspaceDir, ".storewright", "runs", runId);
+  await mkdir(runDir, { recursive: true });
+  const progressPath = await writeInitialProgress({ runDir, runId });
+  return { runId, runDir, progressPath };
+}
+
+async function main() {
+  try {
+    const options = parseArgs(process.argv.slice(2));
+    if (options.help) {
+      console.log(usage());
+      return;
+    }
+    const result = await initRunState(options);
+    console.log(`Run ID: ${result.runId}`);
+    console.log(`Run directory: ${result.runDir}`);
+    console.log(`Progress: ${result.progressPath}`);
+  } catch (error) {
+    console.error(error.message);
+    process.exitCode = 1;
+  }
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  await main();
+}