flavor-code 1.2.8 → 1.2.10

package/dist/desktop/pixel-worker.js

@@ -0,0 +1,73 @@
+// src/d2c/pixel-worker.ts
+import { parentPort } from "worker_threads";
+
+// src/d2c/pixel.ts
+import { Buffer as Buffer2 } from "buffer";
+import pixelmatch from "pixelmatch";
+import { PNG } from "pngjs";
+var D2C_MAX_PNG_BYTES = 32 * 1024 * 1024;
+var D2C_MAX_PIXELS = 8388608;
+var PNG_SIGNATURE = Buffer2.from([137, 80, 78, 71, 13, 10, 26, 10]);
+function assertPngDimensions(png) {
+  if (png.byteLength > D2C_MAX_PNG_BYTES) throw new Error("PNG buffer exceeds the supported size");
+  if (png.byteLength < 24 || !png.subarray(0, PNG_SIGNATURE.length).equals(PNG_SIGNATURE) || png.toString("ascii", 12, 16) !== "IHDR") {
+    throw new Error("Invalid PNG header");
+  }
+  const width = png.readUInt32BE(16);
+  const height = png.readUInt32BE(20);
+  if (width === 0 || height === 0 || width * height > D2C_MAX_PIXELS) {
+    throw new Error(`PNG dimensions exceed the supported pixel limit: ${width}x${height}`);
+  }
+  return { width, height };
+}
+function padToCanvas(image, width, height) {
+  if (image.width === width && image.height === height) return image;
+  const canvas = new PNG({ width, height });
+  canvas.data.fill(255);
+  for (let y = 0; y < Math.min(image.height, height); y += 1) {
+    const sourceStart = y * image.width * 4;
+    const targetStart = y * width * 4;
+    image.data.copy(canvas.data, targetStart, sourceStart, sourceStart + Math.min(image.width, width) * 4);
+  }
+  return canvas;
+}
+function comparePngs(leftPng, rightPng) {
+  if (leftPng.byteLength === 0 || rightPng.byteLength === 0) throw new Error("Empty PNG buffer");
+  if (leftPng.byteLength > D2C_MAX_PNG_BYTES || rightPng.byteLength > D2C_MAX_PNG_BYTES) {
+    throw new Error("PNG buffer exceeds the supported size");
+  }
+  assertPngDimensions(leftPng);
+  assertPngDimensions(rightPng);
+  const left = PNG.sync.read(leftPng);
+  const right = PNG.sync.read(rightPng);
+  const width = Math.max(left.width, right.width);
+  const height = Math.max(left.height, right.height);
+  if (width * height > D2C_MAX_PIXELS) throw new Error("Unified PNG canvas exceeds the supported pixel limit");
+  const canvasLeft = padToCanvas(left, width, height);
+  const canvasRight = padToCanvas(right, width, height);
+  const heatmap = new PNG({ width, height });
+  const mismatches = pixelmatch(canvasLeft.data, canvasRight.data, heatmap.data, width, height, { threshold: 0.1 });
+  return {
+    width,
+    height,
+    mismatchRate: mismatches / (width * height),
+    heatmapPng: PNG.sync.write(heatmap)
+  };
+}
+
+// src/d2c/pixel-worker.ts
+if (parentPort === null) throw new Error("D2C pixel worker must run in a worker thread");
+parentPort.on("message", (message) => {
+  try {
+    const result = comparePngs(Buffer.from(message.left), Buffer.from(message.right));
+    parentPort.postMessage({
+      ok: true,
+      result: { ...result, heatmapPng: new Uint8Array(result.heatmapPng) }
+    });
+  } catch (cause) {
+    parentPort.postMessage({
+      ok: false,
+      error: cause instanceof Error ? cause.message : String(cause)
+    });
+  }
+});

package/dist/desktop/preload.cjs

@@ -35,6 +35,36 @@ var DESKTOP_CHANNELS = {
   deleteMemory: "desktop:delete-memory",
   switchModel: "desktop:switch-model",
   addModel: "desktop:add-model",
+  d2cImport: "desktop:d2c-import",
+  d2cCreateProduct: "desktop:d2c-create-product",
+  d2cGetProduct: "desktop:d2c-get-product",
+  d2cRegeneratePrd: "desktop:d2c-regenerate-prd",
+  d2cUpdatePrdSection: "desktop:d2c-update-prd-section",
+  d2cDecideProduct: "desktop:d2c-decide-product",
+  d2cStartProductPreview: "desktop:d2c-start-product-preview",
+  d2cStopProductPreview: "desktop:d2c-stop-product-preview",
+  d2cGetProductPreviewStatus: "desktop:d2c-get-product-preview-status",
+  d2cOpenProductPreview: "desktop:d2c-open-product-preview",
+  d2cListReports: "desktop:d2c-list-reports",
+  d2cGetReport: "desktop:d2c-get-report",
+  d2cUpdateReview: "desktop:d2c-update-review",
+  d2cImportOpenApi: "desktop:d2c-import-openapi",
+  d2cGetIntegration: "desktop:d2c-get-integration",
+  d2cConfirmMapping: "desktop:d2c-confirm-mapping",
+  d2cGenerateIntegration: "desktop:d2c-generate-integration",
+  d2cStartMock: "desktop:d2c-start-mock",
+  d2cStopMock: "desktop:d2c-stop-mock",
+  d2cGetMockStatus: "desktop:d2c-get-mock-status",
+  d2cStartPreview: "desktop:d2c-start-preview",
+  d2cStopPreview: "desktop:d2c-stop-preview",
+  d2cGetPreviewStatus: "desktop:d2c-get-preview-status",
+  d2cOpenPreview: "desktop:d2c-open-preview",
+  d2cRunInteractionTests: "desktop:d2c-run-interaction-tests",
+  d2cGetJudgeConfig: "desktop:d2c-get-judge-config",
+  d2cSaveJudgeConfig: "desktop:d2c-save-judge-config",
+  d2cRunQualityJudge: "desktop:d2c-run-quality-judge",
+  d2cResolveQualityIssue: "desktop:d2c-resolve-quality-issue",
+  d2cSetManualAcceptance: "desktop:d2c-set-manual-acceptance",
   event: "desktop:event"
 };
 
@@ -50,10 +80,11 @@ var api = {
   ),
   deleteSession: (sessionId) => import_electron.ipcRenderer.invoke(DESKTOP_CHANNELS.deleteSession, { sessionId }),
   showAppMenu: (menu, x, y) => import_electron.ipcRenderer.invoke(DESKTOP_CHANNELS.showAppMenu, { menu, x, y }),
-  submit: (prompt, delivery = "prompt", attachments = []) => import_electron.ipcRenderer.invoke(DESKTOP_CHANNELS.submit, {
+  submit: (prompt, delivery = "prompt", attachments = [], permissionProfile) => import_electron.ipcRenderer.invoke(DESKTOP_CHANNELS.submit, {
     prompt,
     delivery,
-    ...attachments.length === 0 ? {} : { attachments }
+    ...attachments.length === 0 ? {} : { attachments },
+    ...permissionProfile === void 0 ? {} : { permissionProfile }
   }),
   finishTask: () => import_electron.ipcRenderer.invoke(DESKTOP_CHANNELS.finishTask),
   interrupt: () => import_electron.ipcRenderer.invoke(DESKTOP_CHANNELS.interrupt),
@@ -80,6 +111,53 @@ var api = {
   deleteMemory: (id) => import_electron.ipcRenderer.invoke(DESKTOP_CHANNELS.deleteMemory, { id }),
   switchModel: (modelId) => import_electron.ipcRenderer.invoke(DESKTOP_CHANNELS.switchModel, { modelId }),
   addModel: (input) => import_electron.ipcRenderer.invoke(DESKTOP_CHANNELS.addModel, input),
+  listD2cReports: () => import_electron.ipcRenderer.invoke(DESKTOP_CHANNELS.d2cListReports),
+  getD2cReport: (task, reportId) => import_electron.ipcRenderer.invoke(DESKTOP_CHANNELS.d2cGetReport, {
+    task,
+    ...reportId === void 0 ? {} : { reportId }
+  }),
+  importD2cDesign: (task) => import_electron.ipcRenderer.invoke(DESKTOP_CHANNELS.d2cImport, { task }),
+  createD2cProduct: (input) => import_electron.ipcRenderer.invoke(DESKTOP_CHANNELS.d2cCreateProduct, input),
+  getD2cProduct: (task) => import_electron.ipcRenderer.invoke(DESKTOP_CHANNELS.d2cGetProduct, { task }),
+  regenerateD2cPrd: (task, query) => import_electron.ipcRenderer.invoke(DESKTOP_CHANNELS.d2cRegeneratePrd, { task, query }),
+  updateD2cPrdSection: (task, sectionId, body, expectedHash) => import_electron.ipcRenderer.invoke(
+    DESKTOP_CHANNELS.d2cUpdatePrdSection,
+    { task, sectionId, body, expectedHash }
+  ),
+  decideD2cProduct: (task, stage, accepted, feedback) => import_electron.ipcRenderer.invoke(DESKTOP_CHANNELS.d2cDecideProduct, {
+    task,
+    stage,
+    accepted,
+    ...feedback === void 0 ? {} : { feedback }
+  }),
+  startD2cProductPreview: (task) => import_electron.ipcRenderer.invoke(DESKTOP_CHANNELS.d2cStartProductPreview, { task }),
+  stopD2cProductPreview: (task) => import_electron.ipcRenderer.invoke(DESKTOP_CHANNELS.d2cStopProductPreview, { task }),
+  getD2cProductPreviewStatus: (task) => import_electron.ipcRenderer.invoke(DESKTOP_CHANNELS.d2cGetProductPreviewStatus, { task }),
+  openD2cProductPreview: (task) => import_electron.ipcRenderer.invoke(DESKTOP_CHANNELS.d2cOpenProductPreview, { task }),
+  updateD2cReview: (task, reportId, fingerprints, decision, instruction) => import_electron.ipcRenderer.invoke(DESKTOP_CHANNELS.d2cUpdateReview, {
+    task,
+    reportId,
+    fingerprints,
+    decision,
+    ...instruction === void 0 ? {} : { instruction }
+  }),
+  importD2cOpenApi: (task) => import_electron.ipcRenderer.invoke(DESKTOP_CHANNELS.d2cImportOpenApi, { task }),
+  getD2cIntegration: (task) => import_electron.ipcRenderer.invoke(DESKTOP_CHANNELS.d2cGetIntegration, { task }),
+  confirmD2cMapping: (task, moduleId, operationKey) => import_electron.ipcRenderer.invoke(DESKTOP_CHANNELS.d2cConfirmMapping, { task, moduleId, operationKey }),
+  generateD2cIntegration: (task) => import_electron.ipcRenderer.invoke(DESKTOP_CHANNELS.d2cGenerateIntegration, { task }),
+  startD2cMock: (task) => import_electron.ipcRenderer.invoke(DESKTOP_CHANNELS.d2cStartMock, { task }),
+  stopD2cMock: (task) => import_electron.ipcRenderer.invoke(DESKTOP_CHANNELS.d2cStopMock, { task }),
+  getD2cMockStatus: (task) => import_electron.ipcRenderer.invoke(DESKTOP_CHANNELS.d2cGetMockStatus, { task }),
+  startD2cPreview: (task) => import_electron.ipcRenderer.invoke(DESKTOP_CHANNELS.d2cStartPreview, { task }),
+  stopD2cPreview: (task) => import_electron.ipcRenderer.invoke(DESKTOP_CHANNELS.d2cStopPreview, { task }),
+  getD2cPreviewStatus: (task) => import_electron.ipcRenderer.invoke(DESKTOP_CHANNELS.d2cGetPreviewStatus, { task }),
+  openD2cPreview: (task) => import_electron.ipcRenderer.invoke(DESKTOP_CHANNELS.d2cOpenPreview, { task }),
+  runD2cInteractionTests: (task) => import_electron.ipcRenderer.invoke(DESKTOP_CHANNELS.d2cRunInteractionTests, { task }),
+  setD2cManualAcceptance: (task, accepted) => import_electron.ipcRenderer.invoke(DESKTOP_CHANNELS.d2cSetManualAcceptance, { task, accepted }),
+  getD2cJudgeConfig: () => import_electron.ipcRenderer.invoke(DESKTOP_CHANNELS.d2cGetJudgeConfig),
+  saveD2cJudgeConfig: (input) => import_electron.ipcRenderer.invoke(DESKTOP_CHANNELS.d2cSaveJudgeConfig, input),
+  runD2cQualityJudge: (task) => import_electron.ipcRenderer.invoke(DESKTOP_CHANNELS.d2cRunQualityJudge, { task }),
+  resolveD2cQualityIssue: (task, issueId, decision) => import_electron.ipcRenderer.invoke(DESKTOP_CHANNELS.d2cResolveQualityIssue, { task, issueId, decision }),
   onEvent(listener) {
     const handler = (_event, value) => listener(value);
     import_electron.ipcRenderer.on(DESKTOP_CHANNELS.event, handler);