@cartanova/qgrid-cli 2.9.4 → 2.9.5

package/bundle/src/utils/providers/openai/openai-image-generation.ts

@@ -0,0 +1,177 @@
+import { PNG } from "pngjs";
+import { z } from "zod";
+
+import { ImageGenerationMetadata } from "../../../application/qgrid/qgrid.types";
+import {
+  CHATGPT_CODEX_RESPONSES_URL,
+  OpenAIProtocolError,
+  type OpenAINormalizedEvent,
+  type OpenAIResponsesOptions,
+} from "./openai-backend-protocol";
+
+const MAX_PNG_BYTES = 32 * 1024 * 1024;
+const MAX_IMAGE_PIXELS = 4096 * 4096;
+const MAX_RESPONSE_BYTES = 64 * 1024 * 1024;
+const PNG_SIGNATURE = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
+
+export function buildStandaloneImageRequest(options: OpenAIResponsesOptions) {
+  if (options.outputSchema || options.tools?.length) {
+    throw new OpenAIProtocolError(
+      "Transparent image generation does not support tools or structured output",
+    );
+  }
+  const controls = options.imageGeneration;
+  if (!controls || controls === true || controls.background !== "transparent") {
+    throw new OpenAIProtocolError(
+      "Standalone images require an explicit transparent background request",
+    );
+  }
+  const text: string[] = [];
+  const images: Array<{ image_url: string }> = [];
+  if (options.instructions) text.push(`System instructions:\n${options.instructions}`);
+  for (const item of options.history) {
+    if (item.type === "reasoning") continue;
+    if (item.type === "image_generation_call" && typeof item.result === "string") {
+      images.push({ image_url: `data:image/png;base64,${item.result}` });
+      continue;
+    }
+    if (item.type !== "message" && typeof item.role !== "string") {
+      throw new OpenAIProtocolError(
+        "Unsupported conversation item for transparent image generation",
+      );
+    }
+    if (typeof item.content === "string") {
+      text.push(`${item.role ?? "user"}:\n${item.content}`);
+      continue;
+    }
+    if (!Array.isArray(item.content)) {
+      throw new OpenAIProtocolError("Unsupported message content for transparent image generation");
+    }
+    for (const part of item.content) {
+      if (!part || typeof part !== "object") {
+        throw new OpenAIProtocolError("Unsupported message part for transparent image generation");
+      }
+      if (
+        ["input_text", "output_text", "text"].includes(part.type) &&
+        typeof part.text === "string"
+      ) {
+        text.push(`${item.role ?? "user"}:\n${part.text}`);
+      } else if (part.type === "input_image" || part.type === "image_url") {
+        const url = typeof part.image_url === "string" ? part.image_url : part.image_url?.url;
+        if (typeof url !== "string" || !/^(https:\/\/|data:image\/)/i.test(url)) {
+          throw new OpenAIProtocolError("Image references must be HTTPS URLs or image data URLs");
+        }
+        images.push({ image_url: url });
+      } else {
+        throw new OpenAIProtocolError("Unsupported message part for transparent image generation");
+      }
+    }
+  }
+  if (images.length > 5)
+    throw new OpenAIProtocolError("Transparent image editing supports at most 5 reference images");
+  if (!text.some((part) => part.trim())) throw new OpenAIProtocolError("Image prompt is empty");
+  return {
+    url: CHATGPT_CODEX_RESPONSES_URL.replace(
+      /\/responses$/,
+      `/images/${images.length ? "edits" : "generations"}`,
+    ),
+    body: {
+      model: "gpt-image-2",
+      prompt: text.join("\n\n"),
+      background: "transparent",
+      ...(controls.quality ? { quality: controls.quality } : {}),
+      ...(controls.size ? { size: controls.size } : {}),
+      ...(images.length ? { images } : {}),
+    },
+  };
+}
+
+// Decode before accepting the result: an alpha channel alone can still be fully opaque.
+export function inspectTransparentPng(base64: string): { width: number; height: number } {
+  if (base64.length > Math.ceil(MAX_PNG_BYTES / 3) * 4 || !/^[A-Za-z0-9+/]+={0,2}$/.test(base64)) {
+    throw new OpenAIProtocolError("Invalid or oversized generated PNG");
+  }
+  const bytes = Buffer.from(base64, "base64");
+  if (
+    bytes.length < 33 ||
+    !bytes.subarray(0, 8).equals(PNG_SIGNATURE) ||
+    bytes.toString("ascii", 12, 16) !== "IHDR"
+  ) {
+    throw new OpenAIProtocolError("Image generation did not return a PNG");
+  }
+  const width = bytes.readUInt32BE(16);
+  const height = bytes.readUInt32BE(20);
+  if (!width || !height || width * height > MAX_IMAGE_PIXELS) {
+    throw new OpenAIProtocolError("Generated PNG dimensions exceed the decoding limit");
+  }
+  let image: PNG;
+  try {
+    image = PNG.sync.read(bytes);
+  } catch {
+    throw new OpenAIProtocolError("Image generation returned an invalid PNG");
+  }
+  let transparent = false;
+  let visible = false;
+  for (let i = 3; i < image.data.length; i += 4) {
+    transparent ||= image.data[i] === 0;
+    visible ||= image.data[i]! > 0;
+    if (transparent && visible) return { width: image.width, height: image.height };
+  }
+  throw new OpenAIProtocolError(
+    "Image generation did not return visible content on a transparent background",
+  );
+}
+
+export async function readStandaloneImageResponse(
+  response: Response,
+): Promise<OpenAINormalizedEvent[]> {
+  if (!response.body) throw new OpenAIProtocolError("Image response had no body");
+  const reader = response.body.getReader();
+  const chunks: Uint8Array[] = [];
+  let size = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      size += value.byteLength;
+      if (size > MAX_RESPONSE_BYTES) {
+        await reader.cancel();
+        throw new OpenAIProtocolError("Image response exceeded the size limit");
+      }
+      chunks.push(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const schema = z.object({
+    data: z
+      .array(z.object({ b64_json: z.string().min(1), revised_prompt: z.string().nullish() }))
+      .min(1)
+      .max(16),
+    quality: z.string().optional(),
+    usage: ImageGenerationMetadata.shape.usage,
+  });
+  let parsed: z.infer<typeof schema>;
+  try {
+    parsed = schema.parse(JSON.parse(Buffer.concat(chunks).toString("utf8")));
+  } catch {
+    throw new OpenAIProtocolError("Invalid standalone image response");
+  }
+  return parsed.data.map((item, index) => {
+    const dimensions = inspectTransparentPng(item.b64_json);
+    return {
+      type: "image",
+      base64: item.b64_json,
+      mimeType: "image/png",
+      ...(item.revised_prompt ? { revisedPrompt: item.revised_prompt } : {}),
+      generation: {
+        route: "codex-images",
+        model: "gpt-image-2",
+        background: "transparent",
+        size: `${dimensions.width}x${dimensions.height}`,
+        ...(parsed.quality ? { quality: parsed.quality } : {}),
+        ...(index === 0 && parsed.usage ? { usage: parsed.usage } : {}),
+      },
+    };
+  });
+}

package/bundle/src/utils/providers/openai/openai-quota.test.ts

@@ -186,4 +186,36 @@ describe("readOpenAIQuotaUsage", () => {
       }),
     ).resolves.toEqual({ kind: "lookup_failed", reason: "OpenAI quota lookup failed: HTTP 503" });
   });
+
+  it("does not refresh a cancelled 401 lookup", async () => {
+    const controller = new AbortController();
+    const refreshCredentials = vi.fn();
+    const result = await readOpenAIQuotaUsage({
+      credentials: { accessToken: "old", accountId: "acct" },
+      signal: controller.signal,
+      refreshCredentials,
+      fetch: async () => {
+        controller.abort(new Error("cancelled"));
+        return new Response("", { status: 401 });
+      },
+    });
+    expect(result).toEqual({ kind: "lookup_failed", reason: "cancelled" });
+    expect(refreshCredentials).not.toHaveBeenCalled();
+  });
+
+  it("does not retry when cancelled while refreshing", async () => {
+    const controller = new AbortController();
+    const fetchMock = vi.fn().mockResolvedValue(new Response("", { status: 401 }));
+    const result = await readOpenAIQuotaUsage({
+      credentials: { accessToken: "old", accountId: "acct" },
+      signal: controller.signal,
+      fetch: fetchMock,
+      refreshCredentials: async () => {
+        controller.abort(new Error("cancelled"));
+        return { accessToken: "new", accountId: "acct" };
+      },
+    });
+    expect(result).toEqual({ kind: "lookup_failed", reason: "cancelled" });
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+  });
 });

package/bundle/src/utils/providers/openai/openai-quota.ts

@@ -23,19 +23,26 @@ export type OpenAIQuotaUsageResult =
 
 export interface OpenAIQuotaHttpOptions {
   credentials: Pick<OpenAICredentials, "accessToken" | "accountId">;
+  refreshCredentials?: () => Promise<Pick<OpenAICredentials, "accessToken" | "accountId">>;
   fetch?: typeof fetch;
   signal?: AbortSignal;
 }
 
 async function readDirect(options: OpenAIQuotaHttpOptions): Promise<OpenAIRateLimitsWithMeta> {
-  const response = await (options.fetch ?? fetch)(CHATGPT_WHAM_USAGE_URL, {
-    method: "GET",
-    headers: buildCodexIdentityHeaders(
-      options.credentials.accessToken,
-      options.credentials.accountId,
-    ),
-    ...(options.signal ? { signal: options.signal } : {}),
-  });
+  const read = (credentials: OpenAIQuotaHttpOptions["credentials"]) =>
+    (options.fetch ?? fetch)(CHATGPT_WHAM_USAGE_URL, {
+      method: "GET",
+      headers: buildCodexIdentityHeaders(credentials.accessToken, credentials.accountId),
+      ...(options.signal ? { signal: options.signal } : {}),
+    });
+  let response = await read(options.credentials);
+  if (response.status === 401 && options.refreshCredentials) {
+    await response.body?.cancel();
+    options.signal?.throwIfAborted();
+    const credentials = await options.refreshCredentials();
+    options.signal?.throwIfAborted();
+    response = await read(credentials);
+  }
   if (!response.ok) throw new Error(`OpenAI quota lookup failed: HTTP ${response.status}`);
   const body = (await response.json()) as Record<string, unknown>;
   const data = normalizeWhamUsage(body);

package/bundle/src/utils/providers/openai/openai-refresh.test.ts

@@ -126,4 +126,22 @@ describe("OpenAI refresh", () => {
       "openai:refresh_token_reused",
     );
   });
+
+  it("recognizes nested permanent error codes without exposing the provider body", async () => {
+    findOneMock.mockResolvedValue(token(12));
+    vi.stubGlobal("fetch", vi.fn().mockResolvedValue(new Response(JSON.stringify({
+      error: { code: "refresh_token_invalidated", message: "private provider detail" },
+    }), { status: 401 })));
+    await expect(handleChatgptAuthTokensRefresh(12)).rejects.toThrow(
+      "OpenAI refresh failed: 401 refresh_token_invalidated",
+    );
+    expect(deactivateMock).toHaveBeenCalledWith(expect.objectContaining({ id: 12 }), "openai:refresh_token_invalidated");
+  });
+
+  it.each([429, 500, 503])("does not deactivate a token on transient refresh HTTP %s", async (status) => {
+    findOneMock.mockResolvedValue(token(status));
+    vi.stubGlobal("fetch", vi.fn().mockResolvedValue(new Response("upstream failure", { status })));
+    await expect(handleChatgptAuthTokensRefresh(status)).rejects.toThrow(`OpenAI refresh failed: ${status} unknown`);
+    expect(deactivateMock).not.toHaveBeenCalled();
+  });
 });

package/bundle/src/utils/providers/openai/openai-refresh.ts

@@ -1,7 +1,7 @@
 /**
  * OpenAI chatgptAuthTokens refresh handler.
  *
- * - direct HTTPS/WS transport가 401 refresh를 소유하고 저장된 refresh token으로 갱신함
+ * - direct transport와 quota 조회의 401에서 같은 refresh 경로를 사용함
  * - qgrid 가 DB 의 refresh_token 으로 새 access_token 을 발급받아 응답
  * - per-token inflight promise 로 concurrent refresh dedup
  * - rotation 감지: 새 refresh_token 있으면 DB 즉시 업데이트
@@ -104,11 +104,18 @@ async function doRefresh(tokenId: number): Promise<RefreshResult> {
     // 위 3개는 모두 영구 실패. 재등록 외 복구 불가.
     let errorCode: string | undefined;
     try {
-      errorCode = (JSON.parse(body) as { error?: string }).error;
+      const error = (JSON.parse(body) as { error?: unknown }).error;
+      const code =
+        typeof error === "string"
+          ? error
+          : error && typeof error === "object" && "code" in error
+            ? error.code
+            : undefined;
+      if (typeof code === "string" && /^[a-z_]{1,80}$/.test(code)) errorCode = code;
     } catch {}
     logger.error(
       `OpenAI refresh FAILED token=${token.name}(id=${tokenId}) status=${resp.status} ` +
-        `code=${errorCode ?? "?"} body=${body}`,
+        `code=${errorCode ?? "unknown"}`,
     );
     // 영구 실패는 errorCode 로만 판정한다 — status 를 함께 요구하면 provider 가
     // 상태코드를 바꿀 때 판정이 조용히 멎는다.
@@ -118,7 +125,7 @@ async function doRefresh(tokenId: number): Promise<RefreshResult> {
         `openai:${errorCode}`,
       );
     }
-    throw new Error(`OpenAI refresh failed: ${resp.status} ${body}`);
+    throw new Error(`OpenAI refresh failed: ${resp.status} ${errorCode ?? "unknown"}`);
   }
 
   const data = (await resp.json()) as {

package/bundle/src/utils/slack-notify.test.ts

@@ -19,6 +19,20 @@ const noSettings = () => undefined;
 const WORKING_HOURS = seoul("2026-08-05T14:00:00");
 
 describe("notifySlack", () => {
+  it.each([
+    ["not_in_channel", () => Promise.resolve(new Response(JSON.stringify({ ok: false, error: "not_in_channel" })))],
+    ["HTTP 503", () => Promise.resolve(new Response("unavailable", { status: 503 }))],
+    ["network", () => Promise.reject(new Error("private network detail"))],
+  ] as const)("reports %s to manual send callers", async (_name, response) => {
+    vi.spyOn(globalThis, "fetch").mockImplementation(response);
+    await expect(notify({ title: "hello", urgent: true, throwOnFailure: true })).rejects.toThrow("Slack");
+  });
+
+  it("reports missing configuration to manual send callers", async () => {
+    settingMock.mockReturnValue(undefined);
+    await expect(notify({ title: "hello", urgent: true, throwOnFailure: true })).rejects.toThrow("Slack");
+  });
+
   beforeEach(() => {
     settingMock.mockImplementation((key: string) =>
       key === "slack.botToken" ? "xoxb-test" : key === "slack.channelId" ? "C123" : undefined,

package/bundle/src/utils/slack-notify.ts

@@ -15,6 +15,8 @@ const logger = getLogger(["qgrid", "slack"]);
 const SLACK_POST_MESSAGE_URL = "https://slack.com/api/chat.postMessage";
 const SLACK_TIMEOUT_MS = 5_000;
 
+export class SlackNotificationError extends Error {}
+
 /** 상태를 색으로 먼저 읽히게 하는 attachment 색상 바. */
 export const SLACK_COLOR = {
   good: "#2eb886",
@@ -34,6 +36,8 @@ export type SlackNotification = {
    * 커지는 사건에만 쓴다 — 남용하면 조용 시간 자체가 무의미해진다.
    */
   urgent?: boolean;
+  /** Manual sends must report delivery failures; background notifications remain fail-open. */
+  throwOnFailure?: boolean;
   /** 조용 시간 판정 기준 시각. 테스트에서 시계를 고정할 때만 넘긴다. */
   now?: Date;
 };
@@ -47,6 +51,9 @@ export async function notifySlack(
   const { title, subject, context, color, urgent, now } = notification;
   if (!botToken || !channel) {
     logger.debug(`slack not configured, skipping notification: ${title} ${subject ?? ""}`);
+    if (notification.throwOnFailure) {
+      throw new SlackNotificationError("Slack 봇 토큰과 채널 ID를 설정해 주세요");
+    }
     return;
   }
 
@@ -99,10 +106,19 @@ export async function notifySlack(
     // bot 미초대(not_in_channel)·잘못된 채널 등 가장 흔한 오설정은 HTTP 200 + ok:false 로 온다.
     // status 만 보면 조용히 성공 처리돼 알림이 통째로 사라진다.
     const body = (await res.json().catch(() => null)) as { ok?: boolean; error?: string } | null;
-    if (!body?.ok) {
-      logger.warn(`slack notification rejected: ${body?.error ?? `http ${res.status}`}`);
+    if (!res.ok || body?.ok !== true) {
+      const code =
+        typeof body?.error === "string" && /^[a-z_]{1,80}$/.test(body.error)
+          ? body.error
+          : `HTTP ${res.status}`;
+      throw new SlackNotificationError(`Slack 알림 발송 실패: ${code}`);
     }
   } catch (e) {
-    logger.warn(`slack notification failed: ${(e as Error).message}`);
+    const error =
+      e instanceof SlackNotificationError
+        ? e
+        : new SlackNotificationError("Slack 알림 발송 실패: 네트워크 오류 또는 응답 시간 초과");
+    logger.warn(error.message);
+    if (notification.throwOnFailure) throw error;
   }
 }