@cartanova/qgrid-cli 2.10.10 → 2.11.1

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

@@ -7,10 +7,11 @@
  * - rotation 감지: 새 refresh_token 있으면 DB 즉시 업데이트
  */
 import { getLogger } from "@logtape/logtape";
+import { z } from "zod";
 
 import { deactivateAuthDeadToken } from "../../../application/qgrid/token-death";
 import { TokenModel } from "../../../application/token/token.model";
-import { type OpenAICredentials } from "../../../application/token/token.types";
+import { OpenAICredentials } from "../../../application/token/token.types";
 
 const logger = getLogger(["qgrid", "openai-refresh"]);
 
@@ -23,6 +24,26 @@ const PERMANENT_FAILURE_CODES = new Set([
   "refresh_token_invalidated",
 ]);
 
+// Only short snake_case codes are trusted; anything else in a 401 body reads as "unknown".
+const refreshErrorCodeSchema = z.string().regex(/^[a-z_]{1,80}$/);
+
+// `error` is either the code itself or an object carrying `code`.
+const refreshErrorBodySchema = z.looseObject({
+  error: z
+    .union([
+      refreshErrorCodeSchema,
+      z.looseObject({ code: refreshErrorCodeSchema }).transform((error) => error.code),
+    ])
+    .optional(),
+});
+
+const refreshResponseSchema = z.object({
+  access_token: z.string(),
+  refresh_token: z.string().nullish(),
+  expires_in: z.number().nullish(),
+  id_token: z.string().nullish(),
+});
+
 // per-token inflight promise dedup + minimum interval
 const inflightRefresh = new Map<number, Promise<RefreshResult>>();
 const lastRefreshTime = new Map<number, number>();
@@ -37,14 +58,18 @@ interface RefreshResult {
 export async function handleChatgptAuthTokensRefresh(tokenId: number): Promise<RefreshResult> {
   logger.info(`refresh requested for token ${tokenId} (pid=${process.pid})`);
   const existing = inflightRefresh.get(tokenId);
+
   if (existing) {
     logger.info(`refresh dedup for token ${tokenId}`);
+
     return existing;
   }
 
   const lastAt = lastRefreshTime.get(tokenId) ?? 0;
+
   if (Date.now() - lastAt < REFRESH_MIN_INTERVAL_MS) {
     logger.info(`refresh too soon for token ${tokenId}, reading current creds from DB`);
+
     return readCurrentCreds(tokenId);
   }
 
@@ -61,8 +86,10 @@ export async function handleChatgptAuthTokensRefresh(tokenId: number): Promise<R
 
 async function readCurrentCreds(tokenId: number): Promise<RefreshResult> {
   const token = await TokenModel.findOne("A", { id: tokenId });
+
   if (!token || token.provider !== "openai") throw new Error(`token ${tokenId} not found`);
-  const creds = token.credentials as OpenAICredentials;
+  const creds = OpenAICredentials.parse(token.credentials);
+
   return {
     accessToken: creds.accessToken,
     chatgptAccountId: creds.accountId,
@@ -72,11 +99,13 @@ async function readCurrentCreds(tokenId: number): Promise<RefreshResult> {
 
 async function doRefresh(tokenId: number): Promise<RefreshResult> {
   const token = await TokenModel.findOne("A", { id: tokenId });
+
   if (!token || token.provider !== "openai") {
     throw new Error(`token ${tokenId} not found or not openai`);
   }
 
-  const creds = token.credentials as OpenAICredentials;
+  const creds = OpenAICredentials.loose().parse(token.credentials);
+
   if (!creds.refreshToken) {
     throw new Error(`token ${tokenId} has no refreshToken`);
   }
@@ -103,20 +132,16 @@ async function doRefresh(tokenId: number): Promise<RefreshResult> {
     //   refresh_token_invalidated → 서버측 revoke
     // 위 3개는 모두 영구 실패. 재등록 외 복구 불가.
     let errorCode: string | undefined;
+
     try {
-      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;
+      errorCode = refreshErrorBodySchema.safeParse(JSON.parse(body)).data?.error;
     } catch {}
+
     logger.error(
       `OpenAI refresh FAILED token=${token.name}(id=${tokenId}) status=${resp.status} ` +
         `code=${errorCode ?? "unknown"}`,
     );
+
     // 영구 실패는 errorCode 로만 판정한다 — status 를 함께 요구하면 provider 가
     // 상태코드를 바꿀 때 판정이 조용히 멎는다.
     if (errorCode && PERMANENT_FAILURE_CODES.has(errorCode)) {
@@ -125,21 +150,19 @@ async function doRefresh(tokenId: number): Promise<RefreshResult> {
         `openai:${errorCode}`,
       );
     }
+
     throw new Error(`OpenAI refresh failed: ${resp.status} ${errorCode ?? "unknown"}`);
   }
 
-  const data = (await resp.json()) as {
-    access_token: string;
-    refresh_token?: string;
-    expires_in?: number;
-    id_token?: string;
-  };
+  const data = refreshResponseSchema.parse(await resp.json());
 
   const newRefreshToken = data.refresh_token ?? creds.refreshToken;
+
   const rotated =
     data.refresh_token !== null &&
     data.refresh_token !== undefined &&
     data.refresh_token !== creds.refreshToken;
+
   if (rotated) {
     logger.info(`refresh_token rotated for token ${token.name}`);
   }
@@ -151,9 +174,10 @@ async function doRefresh(tokenId: number): Promise<RefreshResult> {
     accessTokenExpiresAt: data.expires_in
       ? Date.now() + data.expires_in * 1000
       : creds.accessTokenExpiresAt,
-    ...(data.id_token ? { idToken: data.id_token } : {}),
   };
 
+  if (data.id_token) updatedCreds.idToken = data.id_token;
+
   // 회전(rotated)이 일어났는데 이 save 가 실패하면, OpenAI 쪽 옛 refresh_token 은 이미
   // 폐기된 상태에서 DB 에는 옛 토큰이 남는다 → 다음 refresh 가 refresh_token_reused 로
   // 영구 사망. 이 구간 실패는 토큰 사망의 직접 원인이므로 반드시 크게 남긴다.

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

@@ -1,4 +1,5 @@
 import {
+  type JsonValue,
   normalizeOpenAIEvent,
   OpenAIProtocolError,
   type OpenAINormalizedEvent,
@@ -6,46 +7,61 @@ import {
 
 export interface OpenAIEventStream extends AsyncIterable<OpenAINormalizedEvent> {}
 
-function parseBlock(block: string): unknown | undefined {
+function parseBlock(block: string): JsonValue | undefined {
   const data: string[] = [];
+
   for (const line of block.replaceAll("\r\n", "\n").replaceAll("\r", "\n").split("\n")) {
     if (line.startsWith(":")) continue;
     const separator = line.indexOf(":");
     const field = separator < 0 ? line : line.slice(0, separator);
     let value = separator < 0 ? "" : line.slice(separator + 1);
+
     if (value.startsWith(" ")) value = value.slice(1);
+
     if (field === "data") data.push(value);
   }
+
   if (!data.length) return undefined;
   const payload = data.join("\n");
+
   if (payload === "[DONE]") return payload;
+
   try {
-    return JSON.parse(payload) as unknown;
+    // JSON.parse without a reviver yields only JSON values.
+    const parsed: JsonValue = JSON.parse(payload);
+
+    return parsed;
   } catch (error) {
     throw new OpenAIProtocolError(`Invalid OpenAI SSE JSON: ${String(error)}`);
   }
 }
 
 /** Parses arbitrary UTF-8/chunk boundaries and all complete SSE event blocks. */
-export async function* parseOpenAISSE(body: ReadableStream<Uint8Array>): AsyncGenerator<unknown> {
+export async function* parseOpenAISSE(body: ReadableStream<Uint8Array>): AsyncGenerator<JsonValue> {
   const reader = body.getReader();
   const decoder = new TextDecoder();
   let buffer = "";
+
   try {
     while (true) {
       const { done, value } = await reader.read();
       buffer += decoder.decode(value, { stream: !done });
       let match: RegExpExecArray | null;
+
       while ((match = /\r\n\r\n|\n\n|\r\r/.exec(buffer))) {
         const block = buffer.slice(0, match.index);
         buffer = buffer.slice(match.index + match[0].length);
         const parsed = parseBlock(block);
+
         if (parsed !== undefined) yield parsed;
       }
+
       if (done) break;
     }
+
     if (buffer.trim()) {
       const parsed = parseBlock(buffer);
+
       if (parsed !== undefined) yield parsed;
     }
   } finally {
@@ -58,22 +74,30 @@ export async function* normalizeOpenAISSE(
   body: ReadableStream<Uint8Array>,
 ): AsyncGenerator<OpenAINormalizedEvent> {
   let terminal = false;
+
   for await (const raw of parseOpenAISSE(body)) {
     if (raw === "[DONE]") {
       if (!terminal) throw new OpenAIProtocolError("OpenAI stream ended before response.completed");
+
       return;
     }
+
     if (terminal) throw new OpenAIProtocolError("OpenAI stream emitted an event after termination");
     const event = normalizeOpenAIEvent(raw);
+
     if (!event) continue;
+
     if (event.type === "error") {
       terminal = true;
       yield event;
+
       return;
     }
+
     if (event.type === "completed") terminal = true;
     yield event;
   }
+
   if (!terminal)
     throw new OpenAIProtocolError("OpenAI SSE connection closed before a terminal event");
 }

package/bundle/src/utils/providers/openai/openai-transport-config.ts

@@ -8,10 +8,12 @@ export function resolveOpenAITransportKind(
   env: Record<string, string | undefined> = process.env,
 ): OpenAITransportKind {
   const transport = env.QGRID_OPENAI_TRANSPORT ?? "websocket";
+
   if (transport !== "https" && transport !== "websocket") {
     throw new Error(
       `Invalid QGRID_OPENAI_TRANSPORT value: ${transport}. Expected https or websocket.`,
     );
   }
+
   return transport;
 }

package/bundle/src/utils/quiet-hours.ts

@@ -35,10 +35,16 @@ const SEOUL_FORMATTER = new Intl.DateTimeFormat("en-US", {
   weekday: "short",
 });
 
-function seoulParts(at: Date): { hour: number; weekday: string } {
+interface SeoulTimeParts {
+  hour: number;
+  weekday: string;
+}
+
+function seoulParts(at: Date): SeoulTimeParts {
   const parts = SEOUL_FORMATTER.formatToParts(at);
   const hour = Number(parts.find((p) => p.type === "hour")?.value ?? "0");
   const weekday = parts.find((p) => p.type === "weekday")?.value ?? "";
+
   // Intl 은 자정을 24 로 줄 수 있다. 0..23 으로 맞춘다.
   return { hour: hour % 24, weekday };
 }
@@ -46,7 +52,9 @@ function seoulParts(at: Date): { hour: number; weekday: string } {
 /** 0..23 범위를 벗어나거나 숫자가 아니면 기본값으로 떨어진다. */
 function boundedHour(raw: string | undefined, fallback: number): number {
   const parsed = Number(raw);
+
   if (!Number.isInteger(parsed) || parsed < 0 || parsed > 23) return fallback;
+
   return parsed;
 }
 
@@ -60,6 +68,7 @@ export function isQuietHours(at: Date, readSetting: ReadSetting): boolean {
   const { hour, weekday } = seoulParts(at);
 
   const isWeekend = weekday === "Sat" || weekday === "Sun";
+
   if (isWeekend && readSetting("slack.notifyOnWeekends", "SLACK_NOTIFY_ON_WEEKENDS") !== "true") {
     return true;
   }
@@ -68,6 +77,7 @@ export function isQuietHours(at: Date, readSetting: ReadSetting): boolean {
     readSetting("slack.quietFromHour", "SLACK_QUIET_FROM_HOUR"),
     DEFAULT_QUIET_FROM_HOUR,
   );
+
   const until = boundedHour(
     readSetting("slack.quietUntilHour", "SLACK_QUIET_UNTIL_HOUR"),
     DEFAULT_QUIET_UNTIL_HOUR,
@@ -75,5 +85,6 @@ export function isQuietHours(at: Date, readSetting: ReadSetting): boolean {
 
   // 시작과 종료가 같으면 구간이 비어 있다는 뜻으로 읽어 조용 시간을 두지 않는다.
   if (from === until) return false;
+
   return from > until ? hour >= from || hour < until : hour >= from && hour < until;
 }

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

@@ -6,10 +6,30 @@
  * 알림 경로가 토큰 라우팅이나 오류 전파를 지연·차단해서는 안 된다.
  */
 import { getLogger } from "@logtape/logtape";
+import { z } from "zod";
 
 import { getSetting } from "../application/setting/setting.store";
 import { isQuietHours } from "./quiet-hours";
 
+type SlackTextObject = { type: "mrkdwn"; text: string };
+
+type SlackBlock =
+  | { type: "section"; text: SlackTextObject }
+  | { type: "context"; elements: SlackTextObject[] };
+
+interface SlackAttachment {
+  fallback: string;
+  color?: string;
+  blocks: SlackBlock[];
+}
+
+// chat.postMessage answers HTTP 200 with ok:false for most configuration errors. A malformed
+// error field must not hide ok:true, so it degrades to undefined instead of failing the parse.
+const slackPostMessageResponseSchema = z.looseObject({
+  ok: z.boolean().optional(),
+  error: z.string().optional().catch(undefined),
+});
+
 const logger = getLogger(["qgrid", "slack"]);
 
 const SLACK_POST_MESSAGE_URL = "https://slack.com/api/chat.postMessage";
@@ -49,11 +69,14 @@ export async function notifySlack(
   const botToken = readSetting("slack.botToken", "SLACK_BOT_TOKEN");
   const channel = readSetting("slack.channelId", "SLACK_CHANNEL_ID");
   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;
   }
 
@@ -61,26 +84,39 @@ export async function notifySlack(
   // 끈 상태로 provider 가 전부 죽으면 연휴 내내 서비스가 멈춘 줄 아무도 모른다.
   if (!urgent && readSetting("slack.enabled", "SLACK_ENABLED") === "false") {
     logger.debug(`slack disabled, skipping notification: ${title} ${subject ?? ""}`);
+
     return;
   }
 
   // 만료 알림은 주기적으로 반복되므로 여기서 버려도 다음 근무 시간 첫 주기에 다시 온다.
   if (!urgent && isQuietHours(now ?? new Date(), readSetting)) {
     logger.debug(`quiet hours, skipping notification: ${title} ${subject ?? ""}`);
+
     return;
   }
 
-  const blocks: unknown[] = [
+  const blocks: SlackBlock[] = [
     {
       type: "section",
       text: { type: "mrkdwn", text: subject ? `*${title}*  \`${subject}\`` : `*${title}*` },
     },
   ];
+
   if (context) {
     blocks.push({ type: "context", elements: [{ type: "mrkdwn", text: context }] });
   }
 
   try {
+    // fallback 은 attachment 안에 둔다. 최상위 text 로 보내면 blocks 가 정상 렌더되는
+    // 화면에서도 함께 출력돼 제목이 두 번 보인다. attachment fallback 은 blocks 를
+    // 못 그리는 클라이언트와 푸시 알림에서만 쓰인다.
+    const attachment: SlackAttachment = {
+      fallback: subject ? `${title} — ${subject}` : title,
+      blocks,
+    };
+
+    if (color) attachment.color = color;
+
     const res = await fetch(SLACK_POST_MESSAGE_URL, {
       method: "POST",
       headers: {
@@ -89,28 +125,21 @@ export async function notifySlack(
       },
       body: JSON.stringify({
         channel,
-        // fallback 은 attachment 안에 둔다. 최상위 text 로 보내면 blocks 가 정상 렌더되는
-        // 화면에서도 함께 출력돼 제목이 두 번 보인다. attachment fallback 은 blocks 를
-        // 못 그리는 클라이언트와 푸시 알림에서만 쓰인다.
-        attachments: [
-          {
-            fallback: subject ? `${title} — ${subject}` : title,
-            ...(color ? { color } : {}),
-            blocks,
-          },
-        ],
+        attachments: [attachment],
       }),
       signal: AbortSignal.timeout(SLACK_TIMEOUT_MS),
     });
 
     // bot 미초대(not_in_channel)·잘못된 채널 등 가장 흔한 오설정은 HTTP 200 + ok:false 로 온다.
     // status 만 보면 조용히 성공 처리돼 알림이 통째로 사라진다.
-    const body = (await res.json().catch(() => null)) as { ok?: boolean; error?: string } | null;
+    const body = slackPostMessageResponseSchema.safeParse(await res.json().catch(() => null)).data;
+
     if (!res.ok || body?.ok !== true) {
       const code =
-        typeof body?.error === "string" && /^[a-z_]{1,80}$/.test(body.error)
+        body?.error !== undefined && /^[a-z_]{1,80}$/.test(body.error)
           ? body.error
           : `HTTP ${res.status}`;
+
       throw new SlackNotificationError(`Slack 알림 발송 실패: ${code}`);
     }
   } catch (e) {
@@ -118,7 +147,9 @@ export async function notifySlack(
       e instanceof SlackNotificationError
         ? e
         : new SlackNotificationError("Slack 알림 발송 실패: 네트워크 오류 또는 응답 시간 초과");
+
     logger.warn(error.message);
+
     if (notification.throwOnFailure) throw error;
   }
 }

package/bundle/src/utils/subset-loaders.ts

@@ -1,11 +1,11 @@
 import { type SubsetQuery } from "sonamu";
 
 export function getSubsetLoaders(subsets: string[], subsetQueries: Record<string, SubsetQuery>) {
-  return subsets.reduce(
-    (acc, subset) => {
-      acc[subset] = subsetQueries[subset]?.loaders ?? [];
-      return acc;
-    },
-    {} as Record<string, SubsetQuery["loaders"]>,
-  );
+  const loaders: Record<string, SubsetQuery["loaders"]> = {};
+
+  for (const subset of subsets) {
+    loaders[subset] = subsetQueries[subset]?.loaders ?? [];
+  }
+
+  return loaders;
 }

package/bundle/web-dist/client/assets/clsx-5XM_pHvN.js

@@ -0,0 +1 @@
+function e(t){var n,r,i=``;if(typeof t==`string`||typeof t==`number`)i+=t;else if(typeof t==`object`)if(Array.isArray(t)){var a=t.length;for(n=0;n<a;n++)t[n]&&(r=e(t[n]))&&(i&&(i+=` `),i+=r)}else for(r in t)t[r]&&(i&&(i+=` `),i+=r);return i}function t(){for(var t,n,r=0,i=``,a=arguments.length;r<a;r++)(t=arguments[r])&&(n=e(t))&&(i&&(i+=` `),i+=n);return i}export{t};