ima2-gen 1.1.7 → 1.1.9

package/lib/comfyBridge.ts

@@ -0,0 +1,214 @@
+import { constants as fsConstants } from "node:fs";
+import { access, readFile, realpath, stat } from "node:fs/promises";
+import { basename, extname, isAbsolute, join, relative } from "node:path";
+
+export const COMFY_ERROR = {
+  URL_NOT_LOCAL: "COMFY_URL_NOT_LOCAL",
+  IMAGE_INVALID: "COMFY_IMAGE_INVALID",
+  IMAGE_NOT_FOUND: "COMFY_IMAGE_NOT_FOUND",
+  UPLOAD_FAILED: "COMFY_UPLOAD_FAILED",
+};
+
+const LOCAL_HOSTS = new Set(["127.0.0.1", "localhost", "[::1]"]);
+
+class ComfyBridgeError extends Error {
+  constructor(code, message, status) {
+    super(message);
+    this.name = "ComfyBridgeError";
+    (this as any).code = code;
+    (this as any).status = status;
+  }
+}
+
+function bridgeError(code, message, status) {
+  return new ComfyBridgeError(code, message, status);
+}
+
+export function isComfyBridgeError(error) {
+  return error instanceof ComfyBridgeError;
+}
+
+export function normalizeComfyOrigin(rawUrl) {
+  if (typeof rawUrl !== "string" || !rawUrl.trim()) {
+    throw bridgeError(COMFY_ERROR.URL_NOT_LOCAL, "ComfyUI URL is not configured.", 400);
+  }
+  const trimmed = rawUrl.trim();
+  const rawHost = trimmed.match(/^http:\/\/(?:[^@/]+@)?(\[[^\]]+\]|[^/:?#]+)/i)?.[1] ?? "";
+  if (
+    rawHost === "localhost." ||
+    /^\d+$/.test(rawHost) ||
+    /^0x/i.test(rawHost) ||
+    /^0[0-9]+/.test(rawHost) ||
+    (/^[0-9.]+$/.test(rawHost) && rawHost.split(".").length !== 4) ||
+    rawHost.split(".").some((part) => part.length > 1 && part.startsWith("0"))
+  ) {
+    throw bridgeError(COMFY_ERROR.URL_NOT_LOCAL, "ComfyUI URL is not local.", 400);
+  }
+  let url;
+  try {
+    url = new URL(trimmed);
+  } catch {
+    throw bridgeError(COMFY_ERROR.URL_NOT_LOCAL, "ComfyUI URL is invalid.", 400);
+  }
+  if (url.protocol !== "http:") {
+    throw bridgeError(COMFY_ERROR.URL_NOT_LOCAL, "ComfyUI URL must use HTTP.", 400);
+  }
+  if (url.username || url.password || !url.port) {
+    throw bridgeError(COMFY_ERROR.URL_NOT_LOCAL, "ComfyUI URL is not local.", 400);
+  }
+  if (!LOCAL_HOSTS.has(url.hostname)) {
+    throw bridgeError(COMFY_ERROR.URL_NOT_LOCAL, "ComfyUI URL is not local.", 400);
+  }
+  if (url.pathname !== "/" || url.search || url.hash) {
+    throw bridgeError(COMFY_ERROR.URL_NOT_LOCAL, "ComfyUI URL must be an origin.", 400);
+  }
+  return url.origin;
+}
+
+function hasEncodedSeparator(filename) {
+  try {
+    const decoded = decodeURIComponent(filename);
+    return decoded.includes("/") || decoded.includes("\\");
+  } catch {
+    return true;
+  }
+}
+
+function validateFilename(filename) {
+  if (typeof filename !== "string" || !filename.trim()) {
+    throw bridgeError(COMFY_ERROR.IMAGE_INVALID, "A generated filename is required.", 400);
+  }
+  if (
+    isAbsolute(filename) ||
+    filename !== basename(filename) ||
+    filename.includes("/") ||
+    filename.includes("\\") ||
+    filename.includes("..") ||
+    /^[a-z][a-z0-9+.-]*:/i.test(filename) ||
+    hasEncodedSeparator(filename)
+  ) {
+    throw bridgeError(COMFY_ERROR.IMAGE_INVALID, "Generated filename is invalid.", 400);
+  }
+  return filename;
+}
+
+function isInsideDirectory(parent, candidate) {
+  const rel = relative(parent, candidate);
+  return rel !== "" && !rel.startsWith("..") && !isAbsolute(rel);
+}
+
+function sniffImage(buffer) {
+  if (
+    buffer.length >= 8 &&
+    buffer[0] === 0x89 &&
+    buffer[1] === 0x50 &&
+    buffer[2] === 0x4e &&
+    buffer[3] === 0x47 &&
+    buffer[4] === 0x0d &&
+    buffer[5] === 0x0a &&
+    buffer[6] === 0x1a &&
+    buffer[7] === 0x0a
+  ) {
+    return { ext: "png", mime: "image/png" };
+  }
+  if (buffer.length >= 3 && buffer[0] === 0xff && buffer[1] === 0xd8 && buffer[2] === 0xff) {
+    return { ext: "jpg", mime: "image/jpeg" };
+  }
+  if (
+    buffer.length >= 12 &&
+    buffer.subarray(0, 4).toString("ascii") === "RIFF" &&
+    buffer.subarray(8, 12).toString("ascii") === "WEBP"
+  ) {
+    return { ext: "webp", mime: "image/webp" };
+  }
+  throw bridgeError(COMFY_ERROR.IMAGE_INVALID, "Generated file is not a supported image.", 400);
+}
+
+function sanitizeBaseName(filename) {
+  const raw = basename(filename, extname(filename));
+  const safe = raw.replace(/[^a-zA-Z0-9._-]+/g, "_").replace(/^_+|_+$/g, "");
+  return safe || "image";
+}
+
+async function readGeneratedImage(ctx, filename) {
+  const safeFilename = validateFilename(filename);
+  const generatedDir = await realpath(ctx.config.storage.generatedDir);
+  const candidatePath = join(ctx.config.storage.generatedDir, safeFilename);
+  try {
+    await access(candidatePath, fsConstants.F_OK);
+  } catch {
+    throw bridgeError(COMFY_ERROR.IMAGE_NOT_FOUND, "Generated image was not found.", 404);
+  }
+  let candidateReal;
+  try {
+    candidateReal = await realpath(candidatePath);
+  } catch {
+    throw bridgeError(COMFY_ERROR.IMAGE_NOT_FOUND, "Generated image was not found.", 404);
+  }
+  if (!isInsideDirectory(generatedDir, candidateReal)) {
+    throw bridgeError(COMFY_ERROR.IMAGE_INVALID, "Generated filename is invalid.", 400);
+  }
+  const info = await stat(candidateReal);
+  if (!info.isFile()) {
+    throw bridgeError(COMFY_ERROR.IMAGE_INVALID, "Generated filename is invalid.", 400);
+  }
+  if (info.size > ctx.config.comfy.maxUploadBytes) {
+    throw bridgeError(COMFY_ERROR.IMAGE_INVALID, "Generated image is too large.", 400);
+  }
+  const buffer = await readFile(candidateReal);
+  const imageType = sniffImage(buffer);
+  return {
+    buffer,
+    imageType,
+    sourceFilename: safeFilename,
+    uploadFilename: `ima2_${Date.now()}_${sanitizeBaseName(safeFilename)}.${imageType.ext}`,
+  };
+}
+
+async function postToComfy(origin, image, timeoutMs, fetchImpl = fetch) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const form = new FormData();
+    form.append("image", new Blob([image.buffer], { type: image.imageType.mime }), image.uploadFilename);
+    form.append("type", "input");
+    const res = await fetchImpl(`${origin}/upload/image`, {
+      method: "POST",
+      body: form,
+      redirect: "manual",
+      signal: controller.signal,
+    });
+    if (res.status >= 300 && res.status < 400) {
+      throw bridgeError(COMFY_ERROR.UPLOAD_FAILED, "Could not upload image to ComfyUI.", 502);
+    }
+    if (!res.ok) {
+      throw bridgeError(COMFY_ERROR.UPLOAD_FAILED, "Could not upload image to ComfyUI.", 502);
+    }
+    const data: any = await res.json().catch(() => null);
+    if (!data || typeof data.name !== "string" || !data.name.trim()) {
+      throw bridgeError(COMFY_ERROR.UPLOAD_FAILED, "Could not upload image to ComfyUI.", 502);
+    }
+    return data.name;
+  } catch (error) {
+    if (isComfyBridgeError(error)) throw error;
+    throw bridgeError(COMFY_ERROR.UPLOAD_FAILED, "Could not upload image to ComfyUI.", 502);
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+export async function exportImageToComfy(ctx, input, options: any = {}) {
+  const origin = normalizeComfyOrigin(options.comfyUrl ?? ctx.config.comfy.defaultUrl);
+  const image = await readGeneratedImage(ctx, input.filename);
+  const uploadedFilename = await postToComfy(
+    origin,
+    image,
+    ctx.config.comfy.uploadTimeoutMs,
+    options.fetchImpl,
+  );
+  return {
+    ok: true,
+    sourceFilename: image.sourceFilename,
+    uploadedFilename,
+  };
+}

package/lib/db.js

@@ -2,28 +2,25 @@ import Database from "better-sqlite3";
 import { mkdirSync, existsSync } from "fs";
 import { dirname } from "path";
 import { config } from "../config.js";
-
 let db = null;
-
 export function getDbPath() {
-  return config.storage.dbPath;
+    return config.storage.dbPath;
 }
-
 export function getDb() {
-  if (db) return db;
-  const dbPath = getDbPath();
-  const dir = dirname(dbPath);
-  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-
-  db = new Database(dbPath);
-  db.pragma("journal_mode = WAL");
-  db.pragma("foreign_keys = ON");
-  migrate(db);
-  return db;
+    if (db)
+        return db;
+    const dbPath = getDbPath();
+    const dir = dirname(dbPath);
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    db = new Database(dbPath);
+    db.pragma("journal_mode = WAL");
+    db.pragma("foreign_keys = ON");
+    migrate(db);
+    return db;
 }
-
 function migrate(database) {
-  database.exec(`
+    database.exec(`
     CREATE TABLE IF NOT EXISTS _meta (
       key   TEXT PRIMARY KEY,
       value TEXT NOT NULL
@@ -77,27 +74,21 @@ function migrate(database) {
     CREATE INDEX IF NOT EXISTS idx_inflight_kind ON inflight(kind);
     CREATE INDEX IF NOT EXISTS idx_inflight_session ON inflight(session_id);
   `);
-
-  const sessionColumns = database
-    .prepare("PRAGMA table_info(sessions)")
-    .all()
-    .map((row) => row.name);
-  if (!sessionColumns.includes("graph_version")) {
-    database.exec(
-      "ALTER TABLE sessions ADD COLUMN graph_version INTEGER NOT NULL DEFAULT 0",
-    );
-  }
-  if (!sessionColumns.includes("style_sheet")) {
-    database.exec("ALTER TABLE sessions ADD COLUMN style_sheet TEXT");
-  }
-  if (!sessionColumns.includes("style_sheet_enabled")) {
-    database.exec(
-      "ALTER TABLE sessions ADD COLUMN style_sheet_enabled INTEGER NOT NULL DEFAULT 0",
-    );
-  }
-
-  // ── Prompt Library (schema v4) ──
-  database.exec(`
+    const sessionColumns = database
+        .prepare("PRAGMA table_info(sessions)")
+        .all()
+        .map((row) => row.name);
+    if (!sessionColumns.includes("graph_version")) {
+        database.exec("ALTER TABLE sessions ADD COLUMN graph_version INTEGER NOT NULL DEFAULT 0");
+    }
+    if (!sessionColumns.includes("style_sheet")) {
+        database.exec("ALTER TABLE sessions ADD COLUMN style_sheet TEXT");
+    }
+    if (!sessionColumns.includes("style_sheet_enabled")) {
+        database.exec("ALTER TABLE sessions ADD COLUMN style_sheet_enabled INTEGER NOT NULL DEFAULT 0");
+    }
+    // ── Prompt Library (schema v4) ──
+    database.exec(`
     CREATE TABLE IF NOT EXISTS prompt_folders (
       id          TEXT PRIMARY KEY,
       parent_id   TEXT NOT NULL,
@@ -147,20 +138,19 @@ function migrate(database) {
       ('__root__', '__root__', '__root__'),
       ('__trash__', '__root__', '__trash__');
   `);
-
-  const row = database.prepare("SELECT value FROM _meta WHERE key = 'schema_version'").get();
-  if (!row) {
-    database.prepare("INSERT INTO _meta (key, value) VALUES ('schema_version', '4')").run();
-  } else if (row.value !== "4") {
-    database
-      .prepare("UPDATE _meta SET value = '4' WHERE key = 'schema_version'")
-      .run();
-  }
+    const row = database.prepare("SELECT value FROM _meta WHERE key = 'schema_version'").get();
+    if (!row) {
+        database.prepare("INSERT INTO _meta (key, value) VALUES ('schema_version', '4')").run();
+    }
+    else if (row.value !== "4") {
+        database
+            .prepare("UPDATE _meta SET value = '4' WHERE key = 'schema_version'")
+            .run();
+    }
 }
-
 export function closeDb() {
-  if (db) {
-    db.close();
-    db = null;
-  }
+    if (db) {
+        db.close();
+        db = null;
+    }
 }

package/lib/db.ts

@@ -0,0 +1,166 @@
+import Database from "better-sqlite3";
+import { mkdirSync, existsSync } from "fs";
+import { dirname } from "path";
+import { config } from "../config.js";
+
+let db = null;
+
+export function getDbPath() {
+  return config.storage.dbPath;
+}
+
+export function getDb() {
+  if (db) return db;
+  const dbPath = getDbPath();
+  const dir = dirname(dbPath);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+
+  db = new Database(dbPath);
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  migrate(db);
+  return db;
+}
+
+function migrate(database) {
+  database.exec(`
+    CREATE TABLE IF NOT EXISTS _meta (
+      key   TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS sessions (
+      id          TEXT PRIMARY KEY,
+      title       TEXT NOT NULL DEFAULT 'Untitled',
+      created_at  INTEGER NOT NULL,
+      updated_at  INTEGER NOT NULL,
+      graph_version INTEGER NOT NULL DEFAULT 0
+    );
+
+    CREATE TABLE IF NOT EXISTS nodes (
+      session_id  TEXT NOT NULL,
+      id          TEXT NOT NULL,
+      x           REAL NOT NULL DEFAULT 0,
+      y           REAL NOT NULL DEFAULT 0,
+      data        TEXT NOT NULL DEFAULT '{}',
+      PRIMARY KEY (session_id, id),
+      FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE
+    );
+
+    CREATE TABLE IF NOT EXISTS edges (
+      session_id  TEXT NOT NULL,
+      id          TEXT NOT NULL,
+      source      TEXT NOT NULL,
+      target      TEXT NOT NULL,
+      data        TEXT NOT NULL DEFAULT '{}',
+      PRIMARY KEY (session_id, id),
+      FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_nodes_session ON nodes(session_id);
+    CREATE INDEX IF NOT EXISTS idx_edges_session ON edges(session_id);
+
+    CREATE TABLE IF NOT EXISTS inflight (
+      request_id     TEXT PRIMARY KEY,
+      kind           TEXT NOT NULL,
+      prompt         TEXT NOT NULL DEFAULT '',
+      meta           TEXT NOT NULL DEFAULT '{}',
+      session_id     TEXT,
+      parent_node_id TEXT,
+      client_node_id TEXT,
+      started_at     INTEGER NOT NULL,
+      phase          TEXT NOT NULL DEFAULT 'queued',
+      phase_at       INTEGER NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_inflight_started ON inflight(started_at);
+    CREATE INDEX IF NOT EXISTS idx_inflight_kind ON inflight(kind);
+    CREATE INDEX IF NOT EXISTS idx_inflight_session ON inflight(session_id);
+  `);
+
+  const sessionColumns = database
+    .prepare("PRAGMA table_info(sessions)")
+    .all()
+    .map((row) => row.name);
+  if (!sessionColumns.includes("graph_version")) {
+    database.exec(
+      "ALTER TABLE sessions ADD COLUMN graph_version INTEGER NOT NULL DEFAULT 0",
+    );
+  }
+  if (!sessionColumns.includes("style_sheet")) {
+    database.exec("ALTER TABLE sessions ADD COLUMN style_sheet TEXT");
+  }
+  if (!sessionColumns.includes("style_sheet_enabled")) {
+    database.exec(
+      "ALTER TABLE sessions ADD COLUMN style_sheet_enabled INTEGER NOT NULL DEFAULT 0",
+    );
+  }
+
+  // ── Prompt Library (schema v4) ──
+  database.exec(`
+    CREATE TABLE IF NOT EXISTS prompt_folders (
+      id          TEXT PRIMARY KEY,
+      parent_id   TEXT NOT NULL,
+      name        TEXT NOT NULL COLLATE NOCASE,
+      created_at  INTEGER NOT NULL DEFAULT (unixepoch()),
+      updated_at  INTEGER NOT NULL DEFAULT (unixepoch()),
+      UNIQUE(parent_id, name)
+    );
+
+    CREATE TABLE IF NOT EXISTS prompts (
+      id            TEXT PRIMARY KEY,
+      folder_id     TEXT NOT NULL DEFAULT '__root__',
+      name          TEXT NOT NULL,
+      text          TEXT NOT NULL,
+      tags          TEXT,
+      mode          TEXT,
+      is_favorite   INTEGER NOT NULL DEFAULT 0,
+      favorited_at  INTEGER,
+      created_at    INTEGER NOT NULL DEFAULT (unixepoch()),
+      updated_at    INTEGER NOT NULL DEFAULT (unixepoch()),
+      FOREIGN KEY (folder_id) REFERENCES prompt_folders(id) ON DELETE SET DEFAULT
+    );
+
+    CREATE TABLE IF NOT EXISTS gallery_favorites (
+      id            TEXT PRIMARY KEY,
+      browser_id    TEXT NOT NULL,
+      filename      TEXT NOT NULL,
+      favorited_at  INTEGER NOT NULL DEFAULT (unixepoch()),
+      UNIQUE(browser_id, filename)
+    );
+
+    CREATE TABLE IF NOT EXISTS image_annotations (
+      id             TEXT PRIMARY KEY,
+      browser_id     TEXT NOT NULL,
+      filename       TEXT NOT NULL,
+      payload        TEXT NOT NULL,
+      schema_version INTEGER NOT NULL DEFAULT 1,
+      created_at     INTEGER NOT NULL DEFAULT (unixepoch()),
+      updated_at     INTEGER NOT NULL DEFAULT (unixepoch()),
+      UNIQUE(browser_id, filename)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_image_annotations_filename
+      ON image_annotations(filename);
+
+    INSERT OR IGNORE INTO prompt_folders (id, parent_id, name) VALUES
+      ('__root__', '__root__', '__root__'),
+      ('__trash__', '__root__', '__trash__');
+  `);
+
+  const row = database.prepare("SELECT value FROM _meta WHERE key = 'schema_version'").get();
+  if (!row) {
+    database.prepare("INSERT INTO _meta (key, value) VALUES ('schema_version', '4')").run();
+  } else if (row.value !== "4") {
+    database
+      .prepare("UPDATE _meta SET value = '4' WHERE key = 'schema_version'")
+      .run();
+  }
+}
+
+export function closeDb() {
+  if (db) {
+    db.close();
+    db = null;
+  }
+}

package/lib/errorClassify.js

@@ -1,35 +1,34 @@
 // 0.09.8 — upstream error classifier.
 // Pattern-match upstream OpenAI / OAuth / network errors into stable ImaErrorCode
 // values so the UI can surface localized, actionable messages with CTAs.
-
 /** @typedef {"REF_TOO_LARGE"|"REF_NOT_BASE64"|"REF_EMPTY"|"REF_TOO_MANY"|"MODERATION_REFUSED"|"UPSTREAM_5XX"|"AUTH_CHATGPT_EXPIRED"|"AUTH_API_KEY_INVALID"|"NETWORK_FAILED"|"OAUTH_UNAVAILABLE"|"INVALID_REQUEST"|"INVALID_MODERATION"|"APIKEY_DISABLED"|"SAFETY_REFUSAL"|"EMPTY_RESPONSE"|"OAUTH_UPSTREAM_ERROR"|"DB_ERROR"|"UNKNOWN"} ImaErrorCode */
-
 const INVALID_REQUEST_CODES = new Set([
-  "bad_request",
-  "invalid_request",
-  "invalid_request_error",
-  "invalid_value",
-  "invalid_size",
-  "invalid_type",
-  "invalid_parameter",
-  "missing_required_parameter",
-  "unsupported_parameter",
-  "unsupported_value",
+    "bad_request",
+    "invalid_request",
+    "invalid_request_error",
+    "invalid_value",
+    "invalid_size",
+    "invalid_type",
+    "invalid_parameter",
+    "missing_required_parameter",
+    "unsupported_parameter",
+    "unsupported_value",
 ]);
-
 /**
  * Normalize provider-specific request/validation codes into app codes.
  * @param {string | undefined | null} code
  * @returns {ImaErrorCode}
  */
 export function classifyUpstreamErrorCode(code) {
-  const s = String(code || "").toLowerCase();
-  if (!s) return "UNKNOWN";
-  if (INVALID_REQUEST_CODES.has(s)) return "INVALID_REQUEST";
-  if (s.includes("moderation_blocked") || s.includes("moderation refused")) return "MODERATION_REFUSED";
-  return "UNKNOWN";
+    const s = String(code || "").toLowerCase();
+    if (!s)
+        return "UNKNOWN";
+    if (INVALID_REQUEST_CODES.has(s))
+        return "INVALID_REQUEST";
+    if (s.includes("moderation_blocked") || s.includes("moderation refused"))
+        return "MODERATION_REFUSED";
+    return "UNKNOWN";
 }
-
 /**
  * Classify an upstream error message into an ImaErrorCode.
  * Order matters: auth session expiry must beat generic "token" matches,
@@ -38,63 +37,48 @@ export function classifyUpstreamErrorCode(code) {
  * @returns {ImaErrorCode}
  */
 export function classifyUpstreamError(msg) {
-  const s = String(msg || "").toLowerCase();
-  if (!s) return "UNKNOWN";
-
-  if (s.includes("moderation_blocked") || s.includes("moderation refused")) {
-    return "MODERATION_REFUSED";
-  }
-
-  // ChatGPT sign-in session expiry must precede the generic api-key checks
-  // so it is not misclassified when messages contain both "token" and "api".
-  if (
-    s.includes("token is expired") ||
-    s.includes("sign in again") ||
-    (s.includes("access token") && s.includes("expired")) ||
-    (s.includes("token") && s.includes("expired") && !s.includes("api key"))
-  ) {
-    return "AUTH_CHATGPT_EXPIRED";
-  }
-
-  if (
-    s.includes("incorrect api key") ||
-    s.includes("invalid authentication") ||
-    s.includes("exceeded your current quota") ||
-    s.includes("incorrect organization")
-  ) {
-    return "AUTH_API_KEY_INVALID";
-  }
-
-  if (
-    s.includes("failed to fetch") ||
-    s.includes("econnrefused") ||
-    s.includes("econnreset") ||
-    s.includes("enotfound") ||
-    s.includes("etimedout") ||
-    s.includes("network error")
-  ) {
-    return "NETWORK_FAILED";
-  }
-
-  if (s.includes("oauth") && (s.includes("not running") || s.includes("unavailable") || s.includes("not ready"))) {
-    return "OAUTH_UNAVAILABLE";
-  }
-
-  if (
-    s.includes("invalid_request_error") ||
-    s.includes("invalid_value") ||
-    s.includes("invalid size") ||
-    s.includes("invalid request") ||
-    s.includes("requested resolution") ||
-    s.includes("minimum pixel budget") ||
-    s.includes("unsupported value")
-  ) {
-    return "INVALID_REQUEST";
-  }
-
-  if (s.includes("an error occurred while processing") || /\b5\d\d\b/.test(s)) {
-    return "UPSTREAM_5XX";
-  }
-
-  return "UNKNOWN";
+    const s = String(msg || "").toLowerCase();
+    if (!s)
+        return "UNKNOWN";
+    if (s.includes("moderation_blocked") || s.includes("moderation refused")) {
+        return "MODERATION_REFUSED";
+    }
+    // ChatGPT sign-in session expiry must precede the generic api-key checks
+    // so it is not misclassified when messages contain both "token" and "api".
+    if (s.includes("token is expired") ||
+        s.includes("sign in again") ||
+        (s.includes("access token") && s.includes("expired")) ||
+        (s.includes("token") && s.includes("expired") && !s.includes("api key"))) {
+        return "AUTH_CHATGPT_EXPIRED";
+    }
+    if (s.includes("incorrect api key") ||
+        s.includes("invalid authentication") ||
+        s.includes("exceeded your current quota") ||
+        s.includes("incorrect organization")) {
+        return "AUTH_API_KEY_INVALID";
+    }
+    if (s.includes("failed to fetch") ||
+        s.includes("econnrefused") ||
+        s.includes("econnreset") ||
+        s.includes("enotfound") ||
+        s.includes("etimedout") ||
+        s.includes("network error")) {
+        return "NETWORK_FAILED";
+    }
+    if (s.includes("oauth") && (s.includes("not running") || s.includes("unavailable") || s.includes("not ready"))) {
+        return "OAUTH_UNAVAILABLE";
+    }
+    if (s.includes("invalid_request_error") ||
+        s.includes("invalid_value") ||
+        s.includes("invalid size") ||
+        s.includes("invalid request") ||
+        s.includes("requested resolution") ||
+        s.includes("minimum pixel budget") ||
+        s.includes("unsupported value")) {
+        return "INVALID_REQUEST";
+    }
+    if (s.includes("an error occurred while processing") || /\b5\d\d\b/.test(s)) {
+        return "UPSTREAM_5XX";
+    }
+    return "UNKNOWN";
 }