@storewright/cli 0.14.0

package/scripts/inspect-media-files.mjs

@@ -0,0 +1,334 @@
+#!/usr/bin/env node
+import { createHash } from "node:crypto";
+import { existsSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, isAbsolute, join } from "node:path";
+import { pathToFileURL } from "node:url";
+
+const defaultDimensionThreshold = 300;
+
+function parseArgs(argv) {
+  const args = {};
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "--run-dir") {
+      args.runDir = argv[index + 1];
+      index += 1;
+    } else if (arg === "--supplier-extraction-report" || arg === "--supplier-extraction") {
+      args.supplierExtractionPath = argv[index + 1];
+      index += 1;
+    } else if (arg === "--media-manifest" || arg === "--manifest") {
+      args.mediaManifestPath = argv[index + 1];
+      index += 1;
+    } else if (arg === "--output-report") {
+      args.outputReportPath = argv[index + 1];
+      index += 1;
+    } else if (arg === "--dimension-threshold") {
+      args.dimensionThreshold = Number.parseInt(argv[index + 1], 10);
+      index += 1;
+    }
+  }
+  return args;
+}
+
+function resolveRunPath(runDir, filePath) {
+  if (!filePath || isAbsolute(filePath)) return filePath;
+  return join(runDir, filePath);
+}
+
+async function readJsonIfPresent(filePath) {
+  if (!filePath) return null;
+  return JSON.parse(await readFile(filePath, "utf8"));
+}
+
+function sourceArtifactName(filePath, fallback) {
+  return filePath?.split("/").at(-1) ?? fallback;
+}
+
+function collectSupplierAssets(report, sourceArtifact) {
+  const assets = [];
+  for (const item of report?.supplierExtraction?.items ?? []) {
+    const evidence = item.localMediaEvidence ?? [];
+    if (evidence.length > 0) {
+      evidence.forEach((media, index) => {
+        assets.push({
+          assetRef: `${item.candidateId ?? "candidate"}:${index + 1}`,
+          candidateId: item.candidateId,
+          sourceArtifact,
+          sourceUrl: media.sourceUrl,
+          localPath: media.localPath,
+          declaredBytes: media.bytes
+        });
+      });
+      continue;
+    }
+
+    for (const [index, localPath] of (item.localMediaPaths ?? []).entries()) {
+      assets.push({
+        assetRef: `${item.candidateId ?? "candidate"}:${index + 1}`,
+        candidateId: item.candidateId,
+        sourceArtifact,
+        sourceUrl: item.imageSignals?.[index],
+        localPath
+      });
+    }
+  }
+  return assets;
+}
+
+function collectManifestAssets(manifest, sourceArtifact) {
+  return (manifest?.media?.assets ?? []).map((asset, index) => ({
+    assetRef: asset.assetId ?? `manifest:${index + 1}`,
+    candidateId: asset.candidateId,
+    sourceArtifact,
+    sourceUrl: asset.provenance?.sourceUrl,
+    localPath: asset.localPath,
+    declaredBytes: asset.provenance?.bytes
+  }));
+}
+
+function sha256(bytes) {
+  return createHash("sha256").update(bytes).digest("hex");
+}
+
+function readUInt24LE(buffer, offset) {
+  return buffer[offset] + (buffer[offset + 1] << 8) + (buffer[offset + 2] << 16);
+}
+
+function inspectPng(buffer) {
+  const signature = "89504e470d0a1a0a";
+  if (buffer.length < 24 || buffer.subarray(0, 8).toString("hex") !== signature) return null;
+  return {
+    detectedMimeType: "image/png",
+    width: buffer.readUInt32BE(16),
+    height: buffer.readUInt32BE(20)
+  };
+}
+
+function inspectJpeg(buffer) {
+  if (buffer.length < 4 || buffer[0] !== 0xff || buffer[1] !== 0xd8) return null;
+  let offset = 2;
+  while (offset + 9 < buffer.length) {
+    if (buffer[offset] !== 0xff) {
+      offset += 1;
+      continue;
+    }
+    const marker = buffer[offset + 1];
+    const length = buffer.readUInt16BE(offset + 2);
+    const isStartOfFrame = marker >= 0xc0 && marker <= 0xcf && ![0xc4, 0xc8, 0xcc].includes(marker);
+    if (isStartOfFrame) {
+      return {
+        detectedMimeType: "image/jpeg",
+        height: buffer.readUInt16BE(offset + 5),
+        width: buffer.readUInt16BE(offset + 7)
+      };
+    }
+    if (length < 2) break;
+    offset += 2 + length;
+  }
+  return { detectedMimeType: "image/jpeg" };
+}
+
+function inspectWebp(buffer) {
+  if (
+    buffer.length < 30 ||
+    buffer.subarray(0, 4).toString("ascii") !== "RIFF" ||
+    buffer.subarray(8, 12).toString("ascii") !== "WEBP"
+  ) {
+    return null;
+  }
+
+  const chunk = buffer.subarray(12, 16).toString("ascii");
+  if (chunk === "VP8X" && buffer.length >= 30) {
+    return {
+      detectedMimeType: "image/webp",
+      width: readUInt24LE(buffer, 24) + 1,
+      height: readUInt24LE(buffer, 27) + 1
+    };
+  }
+  if (chunk === "VP8 " && buffer.length >= 30 && buffer[23] === 0x9d && buffer[24] === 0x01 && buffer[25] === 0x2a) {
+    return {
+      detectedMimeType: "image/webp",
+      width: buffer.readUInt16LE(26) & 0x3fff,
+      height: buffer.readUInt16LE(28) & 0x3fff
+    };
+  }
+  if (chunk === "VP8L" && buffer.length >= 25 && buffer[20] === 0x2f) {
+    const bits = buffer.readUInt32LE(21);
+    return {
+      detectedMimeType: "image/webp",
+      width: (bits & 0x3fff) + 1,
+      height: ((bits >> 14) & 0x3fff) + 1
+    };
+  }
+  return { detectedMimeType: "image/webp" };
+}
+
+function inspectImageHeader(buffer) {
+  return inspectPng(buffer) ?? inspectJpeg(buffer) ?? inspectWebp(buffer) ?? {};
+}
+
+function isPlatformOrShopAssetUrl(sourceUrl) {
+  if (!sourceUrl) return false;
+  return [
+    /gtms\d*\.alicdn\.com/i,
+    /\/tps\//i,
+    /-tps-\d+-\d+/i,
+    /\/s\.gif(?:$|\?)/i,
+    /avatar/i,
+    /shopmanager/i,
+    /logo/i,
+    /\/tfs\//i
+  ].some((pattern) => pattern.test(sourceUrl));
+}
+
+function addFinding(asset, code, evidence) {
+  asset.findingCodes.push(code);
+  asset.findings.push({ code, evidence });
+}
+
+async function inspectAsset(asset, { runDir, dimensionThreshold }) {
+  const inspected = {
+    assetRef: asset.assetRef,
+    ...(asset.candidateId ? { candidateId: asset.candidateId } : {}),
+    ...(asset.sourceArtifact ? { sourceArtifact: asset.sourceArtifact } : {}),
+    ...(asset.sourceUrl ? { sourceUrl: asset.sourceUrl } : {}),
+    localPath: asset.localPath,
+    fileExists: false,
+    findingCodes: [],
+    findings: []
+  };
+
+  if (!asset.sourceUrl) {
+    addFinding(inspected, "missing-source-url", "No sourceUrl was present in the input artifact.");
+  } else if (isPlatformOrShopAssetUrl(asset.sourceUrl)) {
+    addFinding(inspected, "platform-or-shop-asset-url", asset.sourceUrl);
+  }
+
+  const absolutePath = resolveRunPath(runDir, asset.localPath);
+  if (!absolutePath || !existsSync(absolutePath)) {
+    addFinding(inspected, "missing-local-file", asset.localPath ?? "");
+    return inspected;
+  }
+
+  const bytes = await readFile(absolutePath);
+  const header = inspectImageHeader(bytes);
+  inspected.fileExists = true;
+  inspected.bytes = bytes.length;
+  inspected.sha256 = sha256(bytes);
+  if (header.detectedMimeType) inspected.detectedMimeType = header.detectedMimeType;
+  if (Number.isFinite(header.width)) inspected.width = header.width;
+  if (Number.isFinite(header.height)) inspected.height = header.height;
+
+  if (!header.detectedMimeType) {
+    addFinding(inspected, "unsupported-image-header", asset.localPath);
+  }
+  if (
+    Number.isFinite(header.width) &&
+    Number.isFinite(header.height) &&
+    (header.width < dimensionThreshold || header.height < dimensionThreshold)
+  ) {
+    addFinding(inspected, "below-dimension-threshold", `${header.width}x${header.height} < ${dimensionThreshold}x${dimensionThreshold}`);
+  }
+
+  return inspected;
+}
+
+function applyDuplicateFindings(assets) {
+  const byHash = new Map();
+  for (const asset of assets) {
+    if (!asset.sha256) continue;
+    const group = byHash.get(asset.sha256) ?? [];
+    group.push(asset);
+    byHash.set(asset.sha256, group);
+  }
+
+  const duplicateHashGroups = [];
+  for (const [hash, group] of byHash) {
+    const candidateIds = [...new Set(group.map((asset) => asset.candidateId).filter(Boolean))];
+    if (group.length < 2 || candidateIds.length < 2) continue;
+    const groupId = `duplicate-${duplicateHashGroups.length + 1}`;
+    duplicateHashGroups.push({
+      groupId,
+      sha256: hash,
+      assetRefs: group.map((asset) => asset.assetRef),
+      candidateIds
+    });
+    for (const asset of group) {
+      asset.duplicateHashGroupId = groupId;
+      addFinding(asset, "duplicate-across-candidates", groupId);
+    }
+  }
+
+  return duplicateHashGroups;
+}
+
+export async function inspectMediaFiles({
+  runDir,
+  supplierExtractionPath,
+  mediaManifestPath,
+  outputReportPath,
+  dimensionThreshold = defaultDimensionThreshold
+}) {
+  if (!runDir) throw new Error("Missing --run-dir argument");
+  if (!supplierExtractionPath && !mediaManifestPath) {
+    throw new Error("Missing media input artifact: pass --supplier-extraction-report or --media-manifest");
+  }
+
+  const supplierExtraction = await readJsonIfPresent(supplierExtractionPath);
+  const mediaManifest = await readJsonIfPresent(mediaManifestPath);
+  const sourceInputArtifacts = [
+    ...(supplierExtractionPath ? [supplierExtractionPath] : []),
+    ...(mediaManifestPath ? [mediaManifestPath] : [])
+  ];
+  const runId = supplierExtraction?.runId ?? mediaManifest?.runId ?? "unknown";
+  const inputAssets = [
+    ...collectSupplierAssets(supplierExtraction, sourceArtifactName(supplierExtractionPath, "supplier-extraction-report.json")),
+    ...collectManifestAssets(mediaManifest, sourceArtifactName(mediaManifestPath, "media-manifest.json"))
+  ];
+  const assets = [];
+  for (const asset of inputAssets) {
+    assets.push(await inspectAsset(asset, { runDir, dimensionThreshold }));
+  }
+  const duplicateHashGroups = applyDuplicateFindings(assets);
+
+  const report = {
+    schemaVersion: "1.0.0",
+    runId,
+    authoring: {
+      mode: "worker-authored",
+      createdBy: "media-file-inspection-adapter",
+      sourceInputArtifacts
+    },
+    mediaFileInspection: {
+      dimensionThreshold,
+      summary: {
+        assetCount: assets.length,
+        missingFileCount: assets.filter((asset) => asset.findingCodes.includes("missing-local-file")).length,
+        duplicateHashGroupCount: duplicateHashGroups.length,
+        findingCount: assets.reduce((total, asset) => total + asset.findingCodes.length, 0)
+      },
+      duplicateHashGroups,
+      assets
+    }
+  };
+
+  const resolvedOutputPath = outputReportPath ?? join(runDir, "media-file-inspection-report.json");
+  await mkdir(dirname(resolvedOutputPath), { recursive: true });
+  await writeFile(resolvedOutputPath, `${JSON.stringify(report, null, 2)}\n`);
+  return { outputReportPath: resolvedOutputPath, assetCount: assets.length };
+}
+
+async function main() {
+  try {
+    const result = await inspectMediaFiles(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/prepare-launch-envelope.mjs

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+
+import { createLaunchEnvelope } from "../lib/internal/launch-envelope.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 === "--input") {
+      options.inputPath = value;
+      index += 1;
+    } else if (arg === "--run-dir") {
+      options.runDir = value;
+      index += 1;
+    } else if (arg === "--package-root") {
+      options.packageRoot = value;
+      index += 1;
+    }
+  }
+  return options;
+}
+
+export async function prepareLaunchEnvelope({ packageRoot = join(import.meta.dirname, ".."), runDir, inputPath }) {
+  if (!inputPath) {
+    throw new Error("Missing --input launch envelope request JSON");
+  }
+  const request = JSON.parse(await readFile(inputPath, "utf8"));
+  return createLaunchEnvelope({ packageRoot, ...request, runDir: runDir ?? request.runDir });
+}
+
+async function main() {
+  try {
+    const result = await prepareLaunchEnvelope(parseArgs(process.argv.slice(2)));
+    console.log(JSON.stringify(result, null, 2));
+  } catch (error) {
+    console.error(error.message);
+    process.exitCode = 1;
+  }
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  await main();
+}