ima2-gen 1.1.7 → 1.1.9

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,
+    }));
 }

package/lib/logger.ts

@@ -0,0 +1,150 @@
+const REDACTED = "[redacted]";
+const MAX_VALUE_LEN = 240;
+const LOG_LEVELS = {
+  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",
+]);
+
+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")
+  );
+}
+
+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;
+}
+
+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"),
+  };
+}
+
+export function sanitizeFields(fields = {}) {
+  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));
+}
+
+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}`;
+    })
+    .filter(Boolean);
+  return `[${scope}.${event}]${parts.length ? ` ${parts.join(" ")}` : ""}`;
+}
+
+export function normalizeLogLevel(level) {
+  return typeof level === "string" && Object.hasOwn(LOG_LEVELS, level) ? level : "info";
+}
+
+export function configureLogger(options: any = {}) {
+  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";
+}
+
+function writeLog(level, 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));
+}
+
+export function logEvent(scope, event, fields = {}) {
+  writeLog("info", formatLog(scope, event, fields));
+}
+
+export function logWarn(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,
+  }));
+}

package/lib/nodeStore.js

@@ -3,79 +3,80 @@ import { join, resolve, sep } from "path";
 import { randomBytes } from "crypto";
 import { config } from "../config.js";
 import { embedImageMetadataBestEffort } from "./imageMetadataStore.js";
-
 export function newNodeId() {
-  return "n_" + randomBytes(config.ids.nodeHexBytes).toString("hex");
+    return "n_" + randomBytes(config.ids.nodeHexBytes).toString("hex");
 }
-
 export async function saveNode(rootDir, { nodeId, b64, meta, ext = "png", generatedDir = config.storage.generatedDir }) {
-  void rootDir;
-  const filename = `${nodeId}.${ext}`;
-  await mkdir(generatedDir, { recursive: true });
-  const imageMeta = {
-    ...meta,
-    kind: meta?.kind || "node",
-    nodeId: meta?.nodeId || nodeId,
-    format: meta?.format || ext,
-  };
-  const rawBuffer = Buffer.from(b64, "base64");
-  const embedded = await embedImageMetadataBestEffort(rawBuffer, ext, imageMeta);
-  if (!embedded.embedded) {
-    console.warn("[nodeStore] metadata embed skipped:", embedded.warning);
-  }
-  await writeFile(join(generatedDir, filename), embedded.buffer);
-  await writeFile(join(generatedDir, filename + ".json"), JSON.stringify(meta, null, 2));
-  return { filename };
+    void rootDir;
+    const filename = `${nodeId}.${ext}`;
+    await mkdir(generatedDir, { recursive: true });
+    const imageMeta = {
+        ...meta,
+        kind: meta?.kind || "node",
+        nodeId: meta?.nodeId || nodeId,
+        format: meta?.format || ext,
+    };
+    const rawBuffer = Buffer.from(b64, "base64");
+    const embedded = await embedImageMetadataBestEffort(rawBuffer, ext, imageMeta);
+    if (!embedded.embedded) {
+        console.warn("[nodeStore] metadata embed skipped:", embedded.warning);
+    }
+    await writeFile(join(generatedDir, filename), embedded.buffer);
+    await writeFile(join(generatedDir, filename + ".json"), JSON.stringify(meta, null, 2));
+    return { filename };
 }
-
 export async function loadNodeB64(rootDir, filename, generatedDir = config.storage.generatedDir) {
-  const p = resolveGeneratedPath(rootDir, filename, generatedDir);
-  try { await access(p); } catch {
-    const err = new Error(`Node file not found: ${filename}`);
-    err.code = "NODE_NOT_FOUND";
-    err.status = 404;
-    throw err;
-  }
-  const buf = await readFile(p);
-  return buf.toString("base64");
+    const p = resolveGeneratedPath(rootDir, filename, generatedDir);
+    try {
+        await access(p);
+    }
+    catch {
+        const err = new Error(`Node file not found: ${filename}`);
+        err.code = "NODE_NOT_FOUND";
+        err.status = 404;
+        throw err;
+    }
+    const buf = await readFile(p);
+    return buf.toString("base64");
 }
-
 export async function loadNodeMeta(rootDir, nodeId, ext = "png", generatedDir = config.storage.generatedDir) {
-  void rootDir;
-  try {
-    return JSON.parse(await readFile(join(generatedDir, `${nodeId}.${ext}.json`), "utf-8"));
-  } catch {
-    return null;
-  }
+    void rootDir;
+    try {
+        return JSON.parse(await readFile(join(generatedDir, `${nodeId}.${ext}.json`), "utf-8"));
+    }
+    catch {
+        return null;
+    }
 }
-
 export async function loadAssetB64(rootDir, externalSrc, generatedDir = config.storage.generatedDir) {
-  const p = resolveGeneratedPath(rootDir, externalSrc, generatedDir);
-  try { await access(p); } catch {
-    const err = new Error(`Asset file not found: ${externalSrc}`);
-    err.code = "NODE_NOT_FOUND";
-    err.status = 404;
-    throw err;
-  }
-  const buf = await readFile(p);
-  return buf.toString("base64");
+    const p = resolveGeneratedPath(rootDir, externalSrc, generatedDir);
+    try {
+        await access(p);
+    }
+    catch {
+        const err = new Error(`Asset file not found: ${externalSrc}`);
+        err.code = "NODE_NOT_FOUND";
+        err.status = 404;
+        throw err;
+    }
+    const buf = await readFile(p);
+    return buf.toString("base64");
 }
-
 function resolveGeneratedPath(rootDir, relPath, generatedDir = config.storage.generatedDir) {
-  void rootDir;
-  if (typeof relPath !== "string" || relPath.length === 0) {
-    const err = new Error("Asset path is required");
-    err.code = "NODE_SOURCE_INVALID";
-    err.status = 400;
-    throw err;
-  }
-  const baseDir = resolve(generatedDir);
-  const target = resolve(baseDir, relPath);
-  if (target !== baseDir && !target.startsWith(baseDir + sep)) {
-    const err = new Error(`Asset path escapes generated/: ${relPath}`);
-    err.code = "NODE_SOURCE_INVALID";
-    err.status = 400;
-    throw err;
-  }
-  return target;
+    void rootDir;
+    if (typeof relPath !== "string" || relPath.length === 0) {
+        const err = new Error("Asset path is required");
+        err.code = "NODE_SOURCE_INVALID";
+        err.status = 400;
+        throw err;
+    }
+    const baseDir = resolve(generatedDir);
+    const target = resolve(baseDir, relPath);
+    if (target !== baseDir && !target.startsWith(baseDir + sep)) {
+        const err = new Error(`Asset path escapes generated/: ${relPath}`);
+        err.code = "NODE_SOURCE_INVALID";
+        err.status = 400;
+        throw err;
+    }
+    return target;
 }