ima2-gen 1.1.8 → 1.1.9

package/lib/localImportStore.js

@@ -2,110 +2,104 @@ import { mkdir, writeFile } from "fs/promises";
 import { basename, join, normalize } from "path";
 import { randomBytes } from "crypto";
 import { embedImageMetadataBestEffort } from "./imageMetadataStore.js";
-
 const PNG_SIGNATURE_HEX = "89504e470d0a1a0a";
 const JPEG_SIGNATURE_HEX = "ffd8ff";
 const WEBP_RIFF_HEAD = "52494646";
 const WEBP_VP_TAIL = "57454250";
-
 function detectFormat(buffer) {
-  if (!Buffer.isBuffer(buffer) || buffer.length < 12) return null;
-  const head8 = buffer.subarray(0, 8).toString("hex");
-  if (head8 === PNG_SIGNATURE_HEX) return "png";
-  if (head8.startsWith(JPEG_SIGNATURE_HEX)) return "jpeg";
-  if (
-    buffer.subarray(0, 4).toString("hex") === WEBP_RIFF_HEAD &&
-    buffer.subarray(8, 12).toString("hex") === WEBP_VP_TAIL
-  ) {
-    return "webp";
-  }
-  return null;
+    if (!Buffer.isBuffer(buffer) || buffer.length < 12)
+        return null;
+    const head8 = buffer.subarray(0, 8).toString("hex");
+    if (head8 === PNG_SIGNATURE_HEX)
+        return "png";
+    if (head8.startsWith(JPEG_SIGNATURE_HEX))
+        return "jpeg";
+    if (buffer.subarray(0, 4).toString("hex") === WEBP_RIFF_HEAD &&
+        buffer.subarray(8, 12).toString("hex") === WEBP_VP_TAIL) {
+        return "webp";
+    }
+    return null;
 }
-
 function ensureInsideGeneratedDir(generatedDir, filename) {
-  const full = normalize(join(generatedDir, filename));
-  const root = normalize(generatedDir);
-  if (!full.startsWith(root)) {
-    const err = new Error("Imported path escapes generated directory");
-    err.status = 400;
-    err.code = "IMPORT_PATH_ESCAPE";
-    throw err;
-  }
-  return full;
+    const full = normalize(join(generatedDir, filename));
+    const root = normalize(generatedDir);
+    if (!full.startsWith(root)) {
+        const err = new Error("Imported path escapes generated directory");
+        err.status = 400;
+        err.code = "IMPORT_PATH_ESCAPE";
+        throw err;
+    }
+    return full;
 }
-
 function makeImportedFilename(format) {
-  const stamp = new Date().toISOString().slice(0, 19).replace(/[-:T]/g, "");
-  const rand = randomBytes(3).toString("hex");
-  return `imported-${stamp}-${rand}.${format}`;
+    const stamp = new Date().toISOString().slice(0, 19).replace(/[-:T]/g, "");
+    const rand = randomBytes(3).toString("hex");
+    return `imported-${stamp}-${rand}.${format}`;
 }
-
 function safeOriginalName(input) {
-  if (typeof input !== "string" || !input) return null;
-  const trimmed = input.slice(0, 200);
-  return basename(trimmed);
+    if (typeof input !== "string" || !input)
+        return null;
+    const trimmed = input.slice(0, 200);
+    return basename(trimmed);
 }
-
 export async function createLocalImport(ctx, { buffer, originalFilename }) {
-  if (!Buffer.isBuffer(buffer) || buffer.length === 0) {
-    const err = new Error("Image body is required");
-    err.status = 400;
-    err.code = "EMPTY_IMPORT";
-    throw err;
-  }
-  const format = detectFormat(buffer);
-  if (!format) {
-    const err = new Error("Only PNG, JPEG, or WebP is supported");
-    err.status = 400;
-    err.code = "IMPORT_BAD_FORMAT";
-    throw err;
-  }
-  const filename = makeImportedFilename(format);
-  const fullPath = ensureInsideGeneratedDir(ctx.config.storage.generatedDir, filename);
-  await mkdir(ctx.config.storage.generatedDir, { recursive: true });
-
-  const meta = {
-    schema: "ima2.generation.v1",
-    app: "ima2-gen",
-    version: ctx.packageVersion,
-    createdAt: Date.now(),
-    kind: "imported",
-    canvasVersion: false,
-    originalFilename: safeOriginalName(originalFilename),
-    format,
-  };
-  const embedded = await embedImageMetadataBestEffort(buffer, format, meta, {
-    version: ctx.packageVersion,
-  });
-  await writeFile(fullPath, embedded.buffer);
-  await writeFile(`${fullPath}.json`, JSON.stringify(meta)).catch(() => {});
-
-  const url = `/generated/${encodeURIComponent(filename)}`;
-  return {
-    filename,
-    url,
-    image: url,
-    thumb: url,
-    createdAt: meta.createdAt,
-    format,
-    kind: "imported",
-    canvasVersion: false,
-    canvasSourceFilename: null,
-    canvasEditableFilename: null,
-    prompt: null,
-    userPrompt: null,
-    revisedPrompt: null,
-    promptMode: null,
-    quality: null,
-    size: null,
-    model: null,
-    provider: null,
-    usage: null,
-    webSearchCalls: 0,
-    sessionId: null,
-    nodeId: null,
-    parentNodeId: null,
-    refsCount: 0,
-    isFavorite: false,
-  };
+    if (!Buffer.isBuffer(buffer) || buffer.length === 0) {
+        const err = new Error("Image body is required");
+        err.status = 400;
+        err.code = "EMPTY_IMPORT";
+        throw err;
+    }
+    const format = detectFormat(buffer);
+    if (!format) {
+        const err = new Error("Only PNG, JPEG, or WebP is supported");
+        err.status = 400;
+        err.code = "IMPORT_BAD_FORMAT";
+        throw err;
+    }
+    const filename = makeImportedFilename(format);
+    const fullPath = ensureInsideGeneratedDir(ctx.config.storage.generatedDir, filename);
+    await mkdir(ctx.config.storage.generatedDir, { recursive: true });
+    const meta = {
+        schema: "ima2.generation.v1",
+        app: "ima2-gen",
+        version: ctx.packageVersion,
+        createdAt: Date.now(),
+        kind: "imported",
+        canvasVersion: false,
+        originalFilename: safeOriginalName(originalFilename),
+        format,
+    };
+    const embedded = await embedImageMetadataBestEffort(buffer, format, meta, {
+        version: ctx.packageVersion,
+    });
+    await writeFile(fullPath, embedded.buffer);
+    await writeFile(`${fullPath}.json`, JSON.stringify(meta)).catch(() => { });
+    const url = `/generated/${encodeURIComponent(filename)}`;
+    return {
+        filename,
+        url,
+        image: url,
+        thumb: url,
+        createdAt: meta.createdAt,
+        format,
+        kind: "imported",
+        canvasVersion: false,
+        canvasSourceFilename: null,
+        canvasEditableFilename: null,
+        prompt: null,
+        userPrompt: null,
+        revisedPrompt: null,
+        promptMode: null,
+        quality: null,
+        size: null,
+        model: null,
+        provider: null,
+        usage: null,
+        webSearchCalls: 0,
+        sessionId: null,
+        nodeId: null,
+        parentNodeId: null,
+        refsCount: 0,
+        isFavorite: false,
+    };
 }

package/lib/localImportStore.ts

@@ -0,0 +1,111 @@
+import { mkdir, writeFile } from "fs/promises";
+import { basename, join, normalize } from "path";
+import { randomBytes } from "crypto";
+import { embedImageMetadataBestEffort } from "./imageMetadataStore.js";
+
+const PNG_SIGNATURE_HEX = "89504e470d0a1a0a";
+const JPEG_SIGNATURE_HEX = "ffd8ff";
+const WEBP_RIFF_HEAD = "52494646";
+const WEBP_VP_TAIL = "57454250";
+
+function detectFormat(buffer) {
+  if (!Buffer.isBuffer(buffer) || buffer.length < 12) return null;
+  const head8 = buffer.subarray(0, 8).toString("hex");
+  if (head8 === PNG_SIGNATURE_HEX) return "png";
+  if (head8.startsWith(JPEG_SIGNATURE_HEX)) return "jpeg";
+  if (
+    buffer.subarray(0, 4).toString("hex") === WEBP_RIFF_HEAD &&
+    buffer.subarray(8, 12).toString("hex") === WEBP_VP_TAIL
+  ) {
+    return "webp";
+  }
+  return null;
+}
+
+function ensureInsideGeneratedDir(generatedDir, filename) {
+  const full = normalize(join(generatedDir, filename));
+  const root = normalize(generatedDir);
+  if (!full.startsWith(root)) {
+    const err: any = new Error("Imported path escapes generated directory");
+    err.status = 400;
+    err.code = "IMPORT_PATH_ESCAPE";
+    throw err;
+  }
+  return full;
+}
+
+function makeImportedFilename(format) {
+  const stamp = new Date().toISOString().slice(0, 19).replace(/[-:T]/g, "");
+  const rand = randomBytes(3).toString("hex");
+  return `imported-${stamp}-${rand}.${format}`;
+}
+
+function safeOriginalName(input) {
+  if (typeof input !== "string" || !input) return null;
+  const trimmed = input.slice(0, 200);
+  return basename(trimmed);
+}
+
+export async function createLocalImport(ctx, { buffer, originalFilename }) {
+  if (!Buffer.isBuffer(buffer) || buffer.length === 0) {
+    const err: any = new Error("Image body is required");
+    err.status = 400;
+    err.code = "EMPTY_IMPORT";
+    throw err;
+  }
+  const format = detectFormat(buffer);
+  if (!format) {
+    const err: any = new Error("Only PNG, JPEG, or WebP is supported");
+    err.status = 400;
+    err.code = "IMPORT_BAD_FORMAT";
+    throw err;
+  }
+  const filename = makeImportedFilename(format);
+  const fullPath = ensureInsideGeneratedDir(ctx.config.storage.generatedDir, filename);
+  await mkdir(ctx.config.storage.generatedDir, { recursive: true });
+
+  const meta = {
+    schema: "ima2.generation.v1",
+    app: "ima2-gen",
+    version: ctx.packageVersion,
+    createdAt: Date.now(),
+    kind: "imported",
+    canvasVersion: false,
+    originalFilename: safeOriginalName(originalFilename),
+    format,
+  };
+  const embedded = await embedImageMetadataBestEffort(buffer, format, meta, {
+    version: ctx.packageVersion,
+  });
+  await writeFile(fullPath, embedded.buffer);
+  await writeFile(`${fullPath}.json`, JSON.stringify(meta)).catch(() => {});
+
+  const url = `/generated/${encodeURIComponent(filename)}`;
+  return {
+    filename,
+    url,
+    image: url,
+    thumb: url,
+    createdAt: meta.createdAt,
+    format,
+    kind: "imported",
+    canvasVersion: false,
+    canvasSourceFilename: null,
+    canvasEditableFilename: null,
+    prompt: null,
+    userPrompt: null,
+    revisedPrompt: null,
+    promptMode: null,
+    quality: null,
+    size: null,
+    model: null,
+    provider: null,
+    usage: null,
+    webSearchCalls: 0,
+    sessionId: null,
+    nodeId: null,
+    parentNodeId: null,
+    refsCount: 0,
+    isFavorite: false,
+  };
+}

package/lib/logger.js

@@ -1,150 +1,143 @@
 const REDACTED = "[redacted]";
 const MAX_VALUE_LEN = 240;
 const LOG_LEVELS = {
-  debug: 10,
-  info: 20,
-  warn: 30,
-  error: 40,
-  silent: 50,
+    debug: 10,
+    info: 20,
+    warn: 30,
+    error: 40,
+    silent: 50,
 };
-
 const SECRET_KEYS = new Set([
-  "authorization",
-  "cookie",
-  "headers",
-  "apiKey",
-  "token",
-  "password",
-  "secret",
-  "body",
-  "prompt",
-  "effectivePrompt",
-  "userPrompt",
-  "revisedPrompt",
-  "textPrompt",
-  "styleSheet",
-  "style_sheet",
-  "image",
-  "imageB64",
-  "image_url",
-  "references",
-  "rawResponse",
+    "authorization",
+    "cookie",
+    "headers",
+    "apiKey",
+    "token",
+    "password",
+    "secret",
+    "body",
+    "prompt",
+    "effectivePrompt",
+    "userPrompt",
+    "revisedPrompt",
+    "textPrompt",
+    "styleSheet",
+    "style_sheet",
+    "image",
+    "imageB64",
+    "image_url",
+    "references",
+    "rawResponse",
 ]);
-
 const ALLOWED_PROMPT_METRICS = new Set(["promptChars", "promptMode"]);
-
 let activeLevel = "info";
 let activeSink = console;
-
 function shouldRedactKey(key) {
-  if (ALLOWED_PROMPT_METRICS.has(key)) return false;
-  if (SECRET_KEYS.has(key)) return true;
-  const lower = key.toLowerCase();
-  return (
-    lower.includes("token") ||
-    lower.includes("authorization") ||
-    lower.includes("cookie") ||
-    lower.includes("apikey") ||
-    lower.includes("api_key") ||
-    lower.includes("secret") ||
-    lower.includes("b64") ||
-    lower.includes("base64") ||
-    lower.includes("dataurl")
-  );
+    if (ALLOWED_PROMPT_METRICS.has(key))
+        return false;
+    if (SECRET_KEYS.has(key))
+        return true;
+    const lower = key.toLowerCase();
+    return (lower.includes("token") ||
+        lower.includes("authorization") ||
+        lower.includes("cookie") ||
+        lower.includes("apikey") ||
+        lower.includes("api_key") ||
+        lower.includes("secret") ||
+        lower.includes("b64") ||
+        lower.includes("base64") ||
+        lower.includes("dataurl"));
 }
-
 function sanitizeValue(value) {
-  if (value == null) return value;
-  if (value instanceof Error) return sanitizeError(value);
-  if (Array.isArray(value)) return `[array:${value.length}]`;
-  if (Buffer.isBuffer(value)) return `[buffer:${value.length}]`;
-  if (typeof value === "object") return "[object]";
-  if (typeof value === "string") {
-    const oneLine = value
-      .replace(/Bearer\s+[A-Za-z0-9._~+/=-]+/gi, "Bearer [redacted]")
-      .replace(/data:image\/[a-z0-9.+-]+;base64,[A-Za-z0-9+/=]+/gi, "data:image/[redacted]")
-      .replace(/\s+/g, " ")
-      .trim();
-    return oneLine.length > MAX_VALUE_LEN ? `${oneLine.slice(0, MAX_VALUE_LEN)}...` : oneLine;
-  }
-  return value;
+    if (value == null)
+        return value;
+    if (value instanceof Error)
+        return sanitizeError(value);
+    if (Array.isArray(value))
+        return `[array:${value.length}]`;
+    if (Buffer.isBuffer(value))
+        return `[buffer:${value.length}]`;
+    if (typeof value === "object")
+        return "[object]";
+    if (typeof value === "string") {
+        const oneLine = value
+            .replace(/Bearer\s+[A-Za-z0-9._~+/=-]+/gi, "Bearer [redacted]")
+            .replace(/data:image\/[a-z0-9.+-]+;base64,[A-Za-z0-9+/=]+/gi, "data:image/[redacted]")
+            .replace(/\s+/g, " ")
+            .trim();
+        return oneLine.length > MAX_VALUE_LEN ? `${oneLine.slice(0, MAX_VALUE_LEN)}...` : oneLine;
+    }
+    return value;
 }
-
 export function sanitizeError(err) {
-  if (!err) return { message: "Unknown error" };
-  return {
-    name: err.name || "Error",
-    code: err.code || undefined,
-    status: err.status || undefined,
-    message: sanitizeValue(err.message || "Unknown error"),
-  };
+    if (!err)
+        return { message: "Unknown error" };
+    return {
+        name: err.name || "Error",
+        code: err.code || undefined,
+        status: err.status || undefined,
+        message: sanitizeValue(err.message || "Unknown error"),
+    };
 }
-
 export function sanitizeFields(fields = {}) {
-  const out = {};
-  for (const [key, value] of Object.entries(fields)) {
-    out[key] = shouldRedactKey(key) ? REDACTED : sanitizeValue(value);
-  }
-  return out;
+    const out = {};
+    for (const [key, value] of Object.entries(fields)) {
+        out[key] = shouldRedactKey(key) ? REDACTED : sanitizeValue(value);
+    }
+    return out;
 }
-
 function formatValue(value) {
-  if (value === undefined) return undefined;
-  if (value === null) return "null";
-  if (typeof value === "boolean" || typeof value === "number") return String(value);
-  return JSON.stringify(String(value));
+    if (value === undefined)
+        return undefined;
+    if (value === null)
+        return "null";
+    if (typeof value === "boolean" || typeof value === "number")
+        return String(value);
+    return JSON.stringify(String(value));
 }
-
 export function formatLog(scope, event, fields = {}) {
-  const safeFields = sanitizeFields(fields);
-  const parts = Object.entries(safeFields)
-    .map(([key, value]) => {
-      const formatted = formatValue(value);
-      return formatted === undefined ? null : `${key}=${formatted}`;
+    const safeFields = sanitizeFields(fields);
+    const parts = Object.entries(safeFields)
+        .map(([key, value]) => {
+        const formatted = formatValue(value);
+        return formatted === undefined ? null : `${key}=${formatted}`;
     })
-    .filter(Boolean);
-  return `[${scope}.${event}]${parts.length ? ` ${parts.join(" ")}` : ""}`;
+        .filter(Boolean);
+    return `[${scope}.${event}]${parts.length ? ` ${parts.join(" ")}` : ""}`;
 }
-
 export function normalizeLogLevel(level) {
-  return typeof level === "string" && Object.hasOwn(LOG_LEVELS, level) ? level : "info";
+    return typeof level === "string" && Object.hasOwn(LOG_LEVELS, level) ? level : "info";
 }
-
 export function configureLogger(options = {}) {
-  activeLevel = normalizeLogLevel(options.level);
-  activeSink = options.sink || console;
+    activeLevel = normalizeLogLevel(options.level);
+    activeSink = options.sink || console;
 }
-
 export function shouldLog(level) {
-  const normalized = normalizeLogLevel(level);
-  return LOG_LEVELS[normalized] >= LOG_LEVELS[activeLevel] && activeLevel !== "silent";
+    const normalized = normalizeLogLevel(level);
+    return LOG_LEVELS[normalized] >= LOG_LEVELS[activeLevel] && activeLevel !== "silent";
 }
-
 function writeLog(level, line) {
-  if (!shouldLog(level)) return;
-  const writer = activeSink[level] || activeSink.log || console.log;
-  writer.call(activeSink, line);
+    if (!shouldLog(level))
+        return;
+    const writer = activeSink[level] || activeSink.log || console.log;
+    writer.call(activeSink, line);
 }
-
 export function logDebug(scope, event, fields = {}) {
-  writeLog("debug", formatLog(scope, event, fields));
+    writeLog("debug", formatLog(scope, event, fields));
 }
-
 export function logEvent(scope, event, fields = {}) {
-  writeLog("info", formatLog(scope, event, fields));
+    writeLog("info", formatLog(scope, event, fields));
 }
-
 export function logWarn(scope, event, fields = {}) {
-  writeLog("warn", formatLog(scope, event, fields));
+    writeLog("warn", formatLog(scope, event, fields));
 }
-
 export function logError(scope, event, err, fields = {}) {
-  const safe = sanitizeError(err);
-  writeLog("error", formatLog(scope, event, {
-    ...fields,
-    errorName: safe.name,
-    errorCode: safe.code,
-    errorStatus: safe.status,
-    errorMessage: safe.message,
-  }));
+    const safe = sanitizeError(err);
+    writeLog("error", formatLog(scope, event, {
+        ...fields,
+        errorName: safe.name,
+        errorCode: safe.code,
+        errorStatus: safe.status,
+        errorMessage: safe.message,
+    }));
 }