@cartanova/qgrid-cli 2.9.4 → 2.9.5

package/bundle/dist/utils/providers/openai/openai-refresh.js

@@ -6,7 +6,7 @@ import { getLogger } from "@logtape/logtape";
 /**
 * 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 즉시 업데이트
@@ -70,16 +70,18 @@ async function doRefresh(tokenId) {
 		const body = await resp.text().catch(() => "");
 		let errorCode;
 		try {
-			errorCode = JSON.parse(body).error;
+			const error = JSON.parse(body).error;
+			const code = typeof error === "string" ? error : error && typeof error === "object" && "code" in error ? error.code : void 0;
+			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}`);
+		logger.error(`OpenAI refresh FAILED token=${token.name}(id=${tokenId}) status=${resp.status} code=${errorCode ?? "unknown"}`);
 		if (errorCode && PERMANENT_FAILURE_CODES.has(errorCode)) await deactivateAuthDeadToken({
 			id: tokenId,
 			name: token.name,
 			provider: "openai",
 			credentials: creds
 		}, `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();
 	const newRefreshToken = data.refresh_token ?? creds.refreshToken;
@@ -114,4 +116,4 @@ async function doRefresh(tokenId) {
 //#endregion
 export { handleChatgptAuthTokensRefresh };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"openai-refresh.js","names":[],"sources":["../../../../src/utils/providers/openai/openai-refresh.ts"],"sourcesContent":["/**\n * OpenAI chatgptAuthTokens refresh handler.\n *\n * - direct HTTPS/WS transport가 401 refresh를 소유하고 저장된 refresh token으로 갱신함\n * - qgrid 가 DB 의 refresh_token 으로 새 access_token 을 발급받아 응답\n * - per-token inflight promise 로 concurrent refresh dedup\n * - rotation 감지: 새 refresh_token 있으면 DB 즉시 업데이트\n */\nimport { getLogger } from \"@logtape/logtape\";\n\nimport { deactivateAuthDeadToken } from \"../../../application/qgrid/token-death\";\nimport { TokenModel } from \"../../../application/token/token.model\";\nimport { type OpenAICredentials } from \"../../../application/token/token.types\";\n\nconst logger = getLogger([\"qgrid\", \"openai-refresh\"]);\n\nimport { OPENAI_CLIENT_ID, OPENAI_TOKEN_URL } from \"./openai-constants\";\n\n// 재로그인 외 복구 불가한 refresh 실패 코드. 어느 것이든 토큰이 죽었다는 확정 신호다.\nconst PERMANENT_FAILURE_CODES = new Set([\n  \"refresh_token_expired\",\n  \"refresh_token_reused\",\n  \"refresh_token_invalidated\",\n]);\n\n// per-token inflight promise dedup + minimum interval\nconst inflightRefresh = new Map<number, Promise<RefreshResult>>();\nconst lastRefreshTime = new Map<number, number>();\nconst REFRESH_MIN_INTERVAL_MS = 5_000;\n\ninterface RefreshResult {\n  accessToken: string;\n  chatgptAccountId: string;\n  chatgptPlanType?: string;\n}\n\nexport async function handleChatgptAuthTokensRefresh(tokenId: number): Promise<RefreshResult> {\n  logger.info(`refresh requested for token ${tokenId} (pid=${process.pid})`);\n  const existing = inflightRefresh.get(tokenId);\n  if (existing) {\n    logger.info(`refresh dedup for token ${tokenId}`);\n    return existing;\n  }\n\n  const lastAt = lastRefreshTime.get(tokenId) ?? 0;\n  if (Date.now() - lastAt < REFRESH_MIN_INTERVAL_MS) {\n    logger.info(`refresh too soon for token ${tokenId}, reading current creds from DB`);\n    return readCurrentCreds(tokenId);\n  }\n\n  lastRefreshTime.set(tokenId, Date.now());\n  const promise = doRefresh(tokenId);\n  inflightRefresh.set(tokenId, promise);\n\n  try {\n    return await promise;\n  } finally {\n    inflightRefresh.delete(tokenId);\n  }\n}\n\nasync function readCurrentCreds(tokenId: number): Promise<RefreshResult> {\n  const token = await TokenModel.findOne(\"A\", { id: tokenId });\n  if (!token || token.provider !== \"openai\") throw new Error(`token ${tokenId} not found`);\n  const creds = token.credentials as OpenAICredentials;\n  return {\n    accessToken: creds.accessToken,\n    chatgptAccountId: creds.accountId,\n    chatgptPlanType: creds.planType,\n  };\n}\n\nasync function doRefresh(tokenId: number): Promise<RefreshResult> {\n  const token = await TokenModel.findOne(\"A\", { id: tokenId });\n  if (!token || token.provider !== \"openai\") {\n    throw new Error(`token ${tokenId} not found or not openai`);\n  }\n\n  const creds = token.credentials as OpenAICredentials;\n  if (!creds.refreshToken) {\n    throw new Error(`token ${tokenId} has no refreshToken`);\n  }\n\n  logger.info(`refreshing token ${token.name} (id=${tokenId})`);\n\n  const resp = await fetch(OPENAI_TOKEN_URL, {\n    method: \"POST\",\n    // 토큰 엔드포인트는 OAuth 표준 form 인코딩 계약을 강제한다. JSON 으로 보내면\n    // access token 만료 후의 모든 refresh 가 거부되어 토큰이 통째로 죽는다.\n    headers: { \"Content-Type\": \"application/x-www-form-urlencoded\" },\n    body: new URLSearchParams({\n      grant_type: \"refresh_token\",\n      client_id: OPENAI_CLIENT_ID,\n      refresh_token: creds.refreshToken,\n    }),\n  });\n\n  if (!resp.ok) {\n    const body = await resp.text().catch(() => \"\");\n    // 401 본문의 error 코드가 토큰 사망의 결정적 사인이다.\n    //   refresh_token_expired     → refresh_token 자체 만료\n    //   refresh_token_reused      → 이미 사용된(회전 폐기된) refresh_token 재사용 → 패밀리 무효화\n    //   refresh_token_invalidated → 서버측 revoke\n    // 위 3개는 모두 영구 실패. 재등록 외 복구 불가.\n    let errorCode: string | undefined;\n    try {\n      errorCode = (JSON.parse(body) as { error?: string }).error;\n    } catch {}\n    logger.error(\n      `OpenAI refresh FAILED token=${token.name}(id=${tokenId}) status=${resp.status} ` +\n        `code=${errorCode ?? \"?\"} body=${body}`,\n    );\n    // 영구 실패는 errorCode 로만 판정한다 — status 를 함께 요구하면 provider 가\n    // 상태코드를 바꿀 때 판정이 조용히 멎는다.\n    if (errorCode && PERMANENT_FAILURE_CODES.has(errorCode)) {\n      await deactivateAuthDeadToken(\n        { id: tokenId, name: token.name, provider: \"openai\", credentials: creds },\n        `openai:${errorCode}`,\n      );\n    }\n    throw new Error(`OpenAI refresh failed: ${resp.status} ${body}`);\n  }\n\n  const data = (await resp.json()) as {\n    access_token: string;\n    refresh_token?: string;\n    expires_in?: number;\n    id_token?: string;\n  };\n\n  const newRefreshToken = data.refresh_token ?? creds.refreshToken;\n  const rotated =\n    data.refresh_token !== null &&\n    data.refresh_token !== undefined &&\n    data.refresh_token !== creds.refreshToken;\n  if (rotated) {\n    logger.info(`refresh_token rotated for token ${token.name}`);\n  }\n\n  const updatedCreds: OpenAICredentials = {\n    ...creds,\n    accessToken: data.access_token,\n    refreshToken: newRefreshToken,\n    accessTokenExpiresAt: data.expires_in\n      ? Date.now() + data.expires_in * 1000\n      : creds.accessTokenExpiresAt,\n    ...(data.id_token ? { idToken: data.id_token } : {}),\n  };\n\n  // 회전(rotated)이 일어났는데 이 save 가 실패하면, OpenAI 쪽 옛 refresh_token 은 이미\n  // 폐기된 상태에서 DB 에는 옛 토큰이 남는다 → 다음 refresh 가 refresh_token_reused 로\n  // 영구 사망. 이 구간 실패는 토큰 사망의 직접 원인이므로 반드시 크게 남긴다.\n  try {\n    await TokenModel.save([\n      {\n        id: tokenId,\n        provider: \"openai\",\n        credentials: updatedCreds,\n        name: token.name,\n        reauth_required: false,\n      },\n    ]);\n  } catch (e) {\n    logger.error(\n      `OpenAI refresh: DB save FAILED after rotation(rotated=${rotated}) ` +\n        `token=${token.name}(id=${tokenId}) — 옛 refresh_token 폐기됨, DB 미반영 → 토큰 사망 위험. err=${String(e)}`,\n    );\n    throw e;\n  }\n\n  logger.info(`token ${token.name} refreshed successfully (rotated=${rotated})`);\n\n  return {\n    accessToken: data.access_token,\n    chatgptAccountId: creds.accountId,\n    chatgptPlanType: creds.planType,\n  };\n}\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"openai-refresh.js","names":[],"sources":["../../../../src/utils/providers/openai/openai-refresh.ts"],"sourcesContent":["/**\n * OpenAI chatgptAuthTokens refresh handler.\n *\n * - direct transport와 quota 조회의 401에서 같은 refresh 경로를 사용함\n * - qgrid 가 DB 의 refresh_token 으로 새 access_token 을 발급받아 응답\n * - per-token inflight promise 로 concurrent refresh dedup\n * - rotation 감지: 새 refresh_token 있으면 DB 즉시 업데이트\n */\nimport { getLogger } from \"@logtape/logtape\";\n\nimport { deactivateAuthDeadToken } from \"../../../application/qgrid/token-death\";\nimport { TokenModel } from \"../../../application/token/token.model\";\nimport { type OpenAICredentials } from \"../../../application/token/token.types\";\n\nconst logger = getLogger([\"qgrid\", \"openai-refresh\"]);\n\nimport { OPENAI_CLIENT_ID, OPENAI_TOKEN_URL } from \"./openai-constants\";\n\n// 재로그인 외 복구 불가한 refresh 실패 코드. 어느 것이든 토큰이 죽었다는 확정 신호다.\nconst PERMANENT_FAILURE_CODES = new Set([\n  \"refresh_token_expired\",\n  \"refresh_token_reused\",\n  \"refresh_token_invalidated\",\n]);\n\n// per-token inflight promise dedup + minimum interval\nconst inflightRefresh = new Map<number, Promise<RefreshResult>>();\nconst lastRefreshTime = new Map<number, number>();\nconst REFRESH_MIN_INTERVAL_MS = 5_000;\n\ninterface RefreshResult {\n  accessToken: string;\n  chatgptAccountId: string;\n  chatgptPlanType?: string;\n}\n\nexport async function handleChatgptAuthTokensRefresh(tokenId: number): Promise<RefreshResult> {\n  logger.info(`refresh requested for token ${tokenId} (pid=${process.pid})`);\n  const existing = inflightRefresh.get(tokenId);\n  if (existing) {\n    logger.info(`refresh dedup for token ${tokenId}`);\n    return existing;\n  }\n\n  const lastAt = lastRefreshTime.get(tokenId) ?? 0;\n  if (Date.now() - lastAt < REFRESH_MIN_INTERVAL_MS) {\n    logger.info(`refresh too soon for token ${tokenId}, reading current creds from DB`);\n    return readCurrentCreds(tokenId);\n  }\n\n  lastRefreshTime.set(tokenId, Date.now());\n  const promise = doRefresh(tokenId);\n  inflightRefresh.set(tokenId, promise);\n\n  try {\n    return await promise;\n  } finally {\n    inflightRefresh.delete(tokenId);\n  }\n}\n\nasync function readCurrentCreds(tokenId: number): Promise<RefreshResult> {\n  const token = await TokenModel.findOne(\"A\", { id: tokenId });\n  if (!token || token.provider !== \"openai\") throw new Error(`token ${tokenId} not found`);\n  const creds = token.credentials as OpenAICredentials;\n  return {\n    accessToken: creds.accessToken,\n    chatgptAccountId: creds.accountId,\n    chatgptPlanType: creds.planType,\n  };\n}\n\nasync function doRefresh(tokenId: number): Promise<RefreshResult> {\n  const token = await TokenModel.findOne(\"A\", { id: tokenId });\n  if (!token || token.provider !== \"openai\") {\n    throw new Error(`token ${tokenId} not found or not openai`);\n  }\n\n  const creds = token.credentials as OpenAICredentials;\n  if (!creds.refreshToken) {\n    throw new Error(`token ${tokenId} has no refreshToken`);\n  }\n\n  logger.info(`refreshing token ${token.name} (id=${tokenId})`);\n\n  const resp = await fetch(OPENAI_TOKEN_URL, {\n    method: \"POST\",\n    // 토큰 엔드포인트는 OAuth 표준 form 인코딩 계약을 강제한다. JSON 으로 보내면\n    // access token 만료 후의 모든 refresh 가 거부되어 토큰이 통째로 죽는다.\n    headers: { \"Content-Type\": \"application/x-www-form-urlencoded\" },\n    body: new URLSearchParams({\n      grant_type: \"refresh_token\",\n      client_id: OPENAI_CLIENT_ID,\n      refresh_token: creds.refreshToken,\n    }),\n  });\n\n  if (!resp.ok) {\n    const body = await resp.text().catch(() => \"\");\n    // 401 본문의 error 코드가 토큰 사망의 결정적 사인이다.\n    //   refresh_token_expired     → refresh_token 자체 만료\n    //   refresh_token_reused      → 이미 사용된(회전 폐기된) refresh_token 재사용 → 패밀리 무효화\n    //   refresh_token_invalidated → 서버측 revoke\n    // 위 3개는 모두 영구 실패. 재등록 외 복구 불가.\n    let errorCode: string | undefined;\n    try {\n      const error = (JSON.parse(body) as { error?: unknown }).error;\n      const code =\n        typeof error === \"string\"\n          ? error\n          : error && typeof error === \"object\" && \"code\" in error\n            ? error.code\n            : undefined;\n      if (typeof code === \"string\" && /^[a-z_]{1,80}$/.test(code)) errorCode = code;\n    } catch {}\n    logger.error(\n      `OpenAI refresh FAILED token=${token.name}(id=${tokenId}) status=${resp.status} ` +\n        `code=${errorCode ?? \"unknown\"}`,\n    );\n    // 영구 실패는 errorCode 로만 판정한다 — status 를 함께 요구하면 provider 가\n    // 상태코드를 바꿀 때 판정이 조용히 멎는다.\n    if (errorCode && PERMANENT_FAILURE_CODES.has(errorCode)) {\n      await deactivateAuthDeadToken(\n        { id: tokenId, name: token.name, provider: \"openai\", credentials: creds },\n        `openai:${errorCode}`,\n      );\n    }\n    throw new Error(`OpenAI refresh failed: ${resp.status} ${errorCode ?? \"unknown\"}`);\n  }\n\n  const data = (await resp.json()) as {\n    access_token: string;\n    refresh_token?: string;\n    expires_in?: number;\n    id_token?: string;\n  };\n\n  const newRefreshToken = data.refresh_token ?? creds.refreshToken;\n  const rotated =\n    data.refresh_token !== null &&\n    data.refresh_token !== undefined &&\n    data.refresh_token !== creds.refreshToken;\n  if (rotated) {\n    logger.info(`refresh_token rotated for token ${token.name}`);\n  }\n\n  const updatedCreds: OpenAICredentials = {\n    ...creds,\n    accessToken: data.access_token,\n    refreshToken: newRefreshToken,\n    accessTokenExpiresAt: data.expires_in\n      ? Date.now() + data.expires_in * 1000\n      : creds.accessTokenExpiresAt,\n    ...(data.id_token ? { idToken: data.id_token } : {}),\n  };\n\n  // 회전(rotated)이 일어났는데 이 save 가 실패하면, OpenAI 쪽 옛 refresh_token 은 이미\n  // 폐기된 상태에서 DB 에는 옛 토큰이 남는다 → 다음 refresh 가 refresh_token_reused 로\n  // 영구 사망. 이 구간 실패는 토큰 사망의 직접 원인이므로 반드시 크게 남긴다.\n  try {\n    await TokenModel.save([\n      {\n        id: tokenId,\n        provider: \"openai\",\n        credentials: updatedCreds,\n        name: token.name,\n        reauth_required: false,\n      },\n    ]);\n  } catch (e) {\n    logger.error(\n      `OpenAI refresh: DB save FAILED after rotation(rotated=${rotated}) ` +\n        `token=${token.name}(id=${tokenId}) — 옛 refresh_token 폐기됨, DB 미반영 → 토큰 사망 위험. err=${String(e)}`,\n    );\n    throw e;\n  }\n\n  logger.info(`token ${token.name} refreshed successfully (rotated=${rotated})`);\n\n  return {\n    accessToken: data.access_token,\n    chatgptAccountId: creds.accountId,\n    chatgptPlanType: creds.planType,\n  };\n}\n"],"mappings":"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"}

package/bundle/dist/utils/slack-notify.js

@@ -12,6 +12,7 @@ import { getLogger } from "@logtape/logtape";
 const logger = getLogger(["qgrid", "slack"]);
 const SLACK_POST_MESSAGE_URL = "https://slack.com/api/chat.postMessage";
 const SLACK_TIMEOUT_MS = 5e3;
+var SlackNotificationError = class extends Error {};
 /** 상태를 색으로 먼저 읽히게 하는 attachment 색상 바. */
 const SLACK_COLOR = {
 	good: "#2eb886",
@@ -23,6 +24,7 @@ async function notifySlack(notification, readSetting = getSetting) {
 	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;
 	}
 	if (!urgent && readSetting("slack.enabled", "SLACK_ENABLED") === "false") {
@@ -65,12 +67,14 @@ async function notifySlack(notification, readSetting = getSetting) {
 			signal: AbortSignal.timeout(SLACK_TIMEOUT_MS)
 		});
 		const body = await res.json().catch(() => null);
-		if (!body?.ok) logger.warn(`slack notification rejected: ${body?.error ?? `http ${res.status}`}`);
+		if (!res.ok || body?.ok !== true) throw new SlackNotificationError(`Slack 알림 발송 실패: ${typeof body?.error === "string" && /^[a-z_]{1,80}$/.test(body.error) ? body.error : `HTTP ${res.status}`}`);
 	} catch (e) {
-		logger.warn(`slack notification failed: ${e.message}`);
+		const error = e instanceof SlackNotificationError ? e : new SlackNotificationError("Slack 알림 발송 실패: 네트워크 오류 또는 응답 시간 초과");
+		logger.warn(error.message);
+		if (notification.throwOnFailure) throw error;
 	}
 }
 //#endregion
-export { SLACK_COLOR, notifySlack };
+export { SLACK_COLOR, SlackNotificationError, notifySlack };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"slack-notify.js","names":[],"sources":["../../src/utils/slack-notify.ts"],"sourcesContent":["/**\n * Slack 알림 (chat.postMessage).\n *\n * fail-open: env 미설정이면 조용히 no-op 이고, 전송 실패는 warn 로그로만 남긴다.\n * 조용 시간(주말·20~8시)에는 `urgent` 가 아닌 알림을 보내지 않는다.\n * 알림 경로가 토큰 라우팅이나 오류 전파를 지연·차단해서는 안 된다.\n */\nimport { getLogger } from \"@logtape/logtape\";\n\nimport { getSetting } from \"../application/setting/setting.store\";\nimport { isQuietHours } from \"./quiet-hours\";\n\nconst logger = getLogger([\"qgrid\", \"slack\"]);\n\nconst SLACK_POST_MESSAGE_URL = \"https://slack.com/api/chat.postMessage\";\nconst SLACK_TIMEOUT_MS = 5_000;\n\nexport class SlackNotificationError extends Error {}\n\n/** 상태를 색으로 먼저 읽히게 하는 attachment 색상 바. */\nexport const SLACK_COLOR = {\n  good: \"#2eb886\",\n  bad: \"#e01e5a\",\n} as const;\n\nexport type SlackNotification = {\n  /** 한 줄 제목. 무슨 일이 일어났는지만 담는다. */\n  title: string;\n  /** 제목 옆 코드 스타일로 붙는 대상 식별자. */\n  subject?: string;\n  /** 제목 아래 작은 글씨로 내려가는 부가 정보 — 읽지 않아도 되는 것들. */\n  context?: string;\n  color?: (typeof SLACK_COLOR)[keyof typeof SLACK_COLOR];\n  /**\n   * 조용 시간(주말·20~8시)에도 보낸다. 서비스가 멈춘 상태처럼 지금 알지 않으면 손해가\n   * 커지는 사건에만 쓴다 — 남용하면 조용 시간 자체가 무의미해진다.\n   */\n  urgent?: boolean;\n  /** Manual sends must report delivery failures; background notifications remain fail-open. */\n  throwOnFailure?: boolean;\n  /** 조용 시간 판정 기준 시각. 테스트에서 시계를 고정할 때만 넘긴다. */\n  now?: Date;\n};\n\nexport async function notifySlack(\n  notification: SlackNotification,\n  readSetting: typeof getSetting = getSetting,\n): Promise<void> {\n  const botToken = readSetting(\"slack.botToken\", \"SLACK_BOT_TOKEN\");\n  const channel = readSetting(\"slack.channelId\", \"SLACK_CHANNEL_ID\");\n  const { title, subject, context, color, urgent, now } = notification;\n  if (!botToken || !channel) {\n    logger.debug(`slack not configured, skipping notification: ${title} ${subject ?? \"\"}`);\n    if (notification.throwOnFailure) {\n      throw new SlackNotificationError(\"Slack 봇 토큰과 채널 ID를 설정해 주세요\");\n    }\n    return;\n  }\n\n  // 연휴처럼 규칙으로 잡을 수 없는 기간에 관리자가 내리는 스위치. urgent 는 통과시킨다 —\n  // 끈 상태로 provider 가 전부 죽으면 연휴 내내 서비스가 멈춘 줄 아무도 모른다.\n  if (!urgent && readSetting(\"slack.enabled\", \"SLACK_ENABLED\") === \"false\") {\n    logger.debug(`slack disabled, skipping notification: ${title} ${subject ?? \"\"}`);\n    return;\n  }\n\n  // 만료 알림은 주기적으로 반복되므로 여기서 버려도 다음 근무 시간 첫 주기에 다시 온다.\n  if (!urgent && isQuietHours(now ?? new Date(), readSetting)) {\n    logger.debug(`quiet hours, skipping notification: ${title} ${subject ?? \"\"}`);\n    return;\n  }\n\n  const blocks: unknown[] = [\n    {\n      type: \"section\",\n      text: { type: \"mrkdwn\", text: subject ? `*${title}*  \\`${subject}\\`` : `*${title}*` },\n    },\n  ];\n  if (context) {\n    blocks.push({ type: \"context\", elements: [{ type: \"mrkdwn\", text: context }] });\n  }\n\n  try {\n    const res = await fetch(SLACK_POST_MESSAGE_URL, {\n      method: \"POST\",\n      headers: {\n        \"Content-Type\": \"application/json; charset=utf-8\",\n        Authorization: `Bearer ${botToken}`,\n      },\n      body: JSON.stringify({\n        channel,\n        // fallback 은 attachment 안에 둔다. 최상위 text 로 보내면 blocks 가 정상 렌더되는\n        // 화면에서도 함께 출력돼 제목이 두 번 보인다. attachment fallback 은 blocks 를\n        // 못 그리는 클라이언트와 푸시 알림에서만 쓰인다.\n        attachments: [\n          {\n            fallback: subject ? `${title} — ${subject}` : title,\n            ...(color ? { color } : {}),\n            blocks,\n          },\n        ],\n      }),\n      signal: AbortSignal.timeout(SLACK_TIMEOUT_MS),\n    });\n\n    // bot 미초대(not_in_channel)·잘못된 채널 등 가장 흔한 오설정은 HTTP 200 + ok:false 로 온다.\n    // status 만 보면 조용히 성공 처리돼 알림이 통째로 사라진다.\n    const body = (await res.json().catch(() => null)) as { ok?: boolean; error?: string } | null;\n    if (!res.ok || body?.ok !== true) {\n      const code =\n        typeof body?.error === \"string\" && /^[a-z_]{1,80}$/.test(body.error)\n          ? body.error\n          : `HTTP ${res.status}`;\n      throw new SlackNotificationError(`Slack 알림 발송 실패: ${code}`);\n    }\n  } catch (e) {\n    const error =\n      e instanceof SlackNotificationError\n        ? e\n        : new SlackNotificationError(\"Slack 알림 발송 실패: 네트워크 오류 또는 응답 시간 초과\");\n    logger.warn(error.message);\n    if (notification.throwOnFailure) throw error;\n  }\n}\n"],"mappings":";;;;;;;;;;;AAYA,MAAM,SAAS,UAAU,CAAC,SAAS,OAAO,CAAC;AAE3C,MAAM,yBAAyB;AAC/B,MAAM,mBAAmB;AAEzB,IAAa,yBAAb,cAA4C,MAAM,CAAC;;AAGnD,MAAa,cAAc;CACzB,MAAM;CACN,KAAK;AACP;AAqBA,eAAsB,YACpB,cACA,cAAiC,YAClB;CACf,MAAM,WAAW,YAAY,kBAAkB,iBAAiB;CAChE,MAAM,UAAU,YAAY,mBAAmB,kBAAkB;CACjE,MAAM,EAAE,OAAO,SAAS,SAAS,OAAO,QAAQ,QAAQ;CACxD,IAAI,CAAC,YAAY,CAAC,SAAS;EACzB,OAAO,MAAM,gDAAgD,MAAM,GAAG,WAAW,IAAI;EACrF,IAAI,aAAa,gBACf,MAAM,IAAI,uBAAuB,4BAA4B;EAE/D;CACF;CAIA,IAAI,CAAC,UAAU,YAAY,iBAAiB,eAAe,MAAM,SAAS;EACxE,OAAO,MAAM,0CAA0C,MAAM,GAAG,WAAW,IAAI;EAC/E;CACF;CAGA,IAAI,CAAC,UAAU,aAAa,uBAAO,IAAI,KAAK,GAAG,WAAW,GAAG;EAC3D,OAAO,MAAM,uCAAuC,MAAM,GAAG,WAAW,IAAI;EAC5E;CACF;CAEA,MAAM,SAAoB,CACxB;EACE,MAAM;EACN,MAAM;GAAE,MAAM;GAAU,MAAM,UAAU,IAAI,MAAM,OAAO,QAAQ,MAAM,IAAI,MAAM;EAAG;CACtF,CACF;CACA,IAAI,SACF,OAAO,KAAK;EAAE,MAAM;EAAW,UAAU,CAAC;GAAE,MAAM;GAAU,MAAM;EAAQ,CAAC;CAAE,CAAC;CAGhF,IAAI;EACF,MAAM,MAAM,MAAM,MAAM,wBAAwB;GAC9C,QAAQ;GACR,SAAS;IACP,gBAAgB;IAChB,eAAe,UAAU;GAC3B;GACA,MAAM,KAAK,UAAU;IACnB;IAIA,aAAa,CACX;KACE,UAAU,UAAU,GAAG,MAAM,KAAK,YAAY;KAC9C,GAAI,QAAQ,EAAE,MAAM,IAAI,CAAC;KACzB;IACF,CACF;GACF,CAAC;GACD,QAAQ,YAAY,QAAQ,gBAAgB;EAC9C,CAAC;EAID,MAAM,OAAQ,MAAM,IAAI,KAAK,CAAC,CAAC,YAAY,IAAI;EAC/C,IAAI,CAAC,IAAI,MAAM,MAAM,OAAO,MAK1B,MAAM,IAAI,uBAAuB,mBAH/B,OAAO,MAAM,UAAU,YAAY,iBAAiB,KAAK,KAAK,KAAK,IAC/D,KAAK,QACL,QAAQ,IAAI,UACwC;CAE9D,SAAS,GAAG;EACV,MAAM,QACJ,aAAa,yBACT,IACA,IAAI,uBAAuB,qCAAqC;EACtE,OAAO,KAAK,MAAM,OAAO;EACzB,IAAI,aAAa,gBAAgB,MAAM;CACzC;AACF"}

package/bundle/src/application/qgrid/expired-token-reminder.test.ts

@@ -157,7 +157,12 @@ describe("expired token reminder scheduling", () => {
     const sent = await sendExpiredTokenReminderNow(deps);
 
     expect(sent).toBe(1);
-    expect(notifySlackMock).toHaveBeenCalledWith(expect.objectContaining({ urgent: true }));
+    expect(notifySlackMock).toHaveBeenCalledWith(expect.objectContaining({ urgent: true, throwOnFailure: true }));
+  });
+
+  it("never reports a sent count when manual Slack delivery fails", async () => {
+    notifySlackMock.mockRejectedValue(new Error("Slack delivery failed"));
+    await expect(sendExpiredTokenReminderNow(deps)).rejects.toThrow("Slack delivery failed");
   });
 
   it("보낼 대상이 없으면 0을 돌려주고 아무것도 보내지 않는다", async () => {

package/bundle/src/application/qgrid/expired-token-reminder.ts

@@ -54,7 +54,10 @@ export function buildReminderContext(
   return [...lines, "재로그인이 필요합니다"].filter(Boolean).join("\n");
 }
 
-async function sendReminder(deps: ExpiredTokenReminderDeps, urgent = false): Promise<number> {
+async function sendReminder(
+  deps: ExpiredTokenReminderDeps,
+  mode: "scheduled" | "manual",
+): Promise<number> {
   const expired = await deps.findReauthRequired();
   if (expired.length === 0) return 0;
 
@@ -66,7 +69,8 @@ async function sendReminder(deps: ExpiredTokenReminderDeps, urgent = false): Pro
     subject: expired.length > 1 ? `${expired.length}건` : (expired[0]!.name ?? "unnamed"),
     context: buildReminderContext(expired, userMap),
     color: SLACK_COLOR.bad,
-    urgent,
+    urgent: mode === "manual",
+    throwOnFailure: mode === "manual",
   });
   return expired.length;
 }
@@ -80,7 +84,7 @@ async function sendReminder(deps: ExpiredTokenReminderDeps, urgent = false): Pro
 export function sendExpiredTokenReminderNow(
   deps: ExpiredTokenReminderDeps = defaultDeps,
 ): Promise<number> {
-  return sendReminder(deps, true);
+  return sendReminder(deps, "manual");
 }
 
 let timer: ReturnType<typeof setInterval> | null = null;
@@ -104,7 +108,9 @@ function scheduleExpiredTokenReminder(runNow: boolean, deps: ExpiredTokenReminde
   );
 
   const run = () =>
-    sendReminder(deps).catch((e) => logger.warn(`reminder failed: ${(e as Error).message}`));
+    sendReminder(deps, "scheduled").catch((e) =>
+      logger.warn(`reminder failed: ${(e as Error).message}`),
+    );
 
   if (runNow) void run();
   timer = setInterval(run, minutes * MINUTE_MS);

package/bundle/src/application/qgrid/qgrid-image-generation.test.ts

@@ -0,0 +1,53 @@
+import { describe, expect, it } from "vitest";
+
+import { estimateImageGenerationCostMicroUsd, imageGenerationCostMethod } from "./qgrid-image-generation";
+import { type ImageGenerationMetadata, type QgridContent, type QueryOutput } from "./qgrid.types";
+
+const options = { quality: "high" as const, size: "1024x1024" as const, background: "transparent" as const };
+const generation: ImageGenerationMetadata = {
+  route: "codex-images", model: "gpt-image-2", background: "transparent",
+  size: "1254x1254", quality: "medium",
+};
+function result(content: QgridContent[]): QueryOutput {
+  return {
+    text: "", content, finishReason: "stop", tokenName: "token", model: "gpt-image-2",
+    usage: { input_tokens: 0, output_tokens: 0, reasoning_tokens: 0, cache_creation_input_tokens: 0, cache_read_input_tokens: 0 },
+    durationMs: 10, ttftMs: 0, costUsd: 0, costSource: "pricing_table",
+  };
+}
+
+describe("standalone image cost estimates", () => {
+  it("uses response usage once for multiple outputs without pricing requested settings or driver tokens", () => {
+    const output = result([
+      { type: "image", data: "first", generation: { ...generation,
+        usage: { input_tokens: 100, output_tokens: 200, total_tokens: 300,
+          input_tokens_details: { text_tokens: 40, image_tokens: 60, cached_tokens: 50 } },
+      } },
+      { type: "image", data: "second", generation },
+    ]);
+    expect(estimateImageGenerationCostMicroUsd(output, options)).toBe(6_680);
+    expect(imageGenerationCostMethod(options, output)).toBe(
+      "estimated:gpt-image-2:reported-usage:public-prices:conservative",
+    );
+  });
+
+  it("does not substitute requested size pricing when standalone usage is missing", () => {
+    expect(estimateImageGenerationCostMicroUsd(result([{ type: "image", data: "png", generation }]), options)).toBeNull();
+  });
+
+  it("prices unknown input remainder at the image rate and ignores inconsistent splits", () => {
+    for (const [textTokens, imageTokens, expected] of [[40, 10, 6_680], [100, 60, 6_800]]) {
+      const output = result([{ type: "image", data: "png", generation: { ...generation, usage: {
+        input_tokens: 100, output_tokens: 200, total_tokens: 300,
+        input_tokens_details: { text_tokens: textTokens!, image_tokens: imageTokens! },
+      } } }]);
+      expect(estimateImageGenerationCostMicroUsd(output, options)).toBe(expected);
+    }
+  });
+
+  it("preserves legacy per-image price assumptions when response metadata is absent", () => {
+    const output = result([{ type: "image", data: "first" }, { type: "image", data: "second" }]);
+    expect(estimateImageGenerationCostMicroUsd(output, options)).toBe(422_000);
+    expect(imageGenerationCostMethod(options, output)).toBe("assumed:gpt-image-2:high:1024x1024:png");
+  });
+});

package/bundle/src/application/qgrid/qgrid-image-generation.ts

@@ -46,7 +46,17 @@ export function resolveImageGenerationOptions(
   };
 }
 
-export function imageGenerationCostMethod(options: ImageGenerationOptions | undefined): string {
+export function imageGenerationCostMethod(
+  options: ImageGenerationOptions | undefined,
+  result?: QueryOutput,
+): string {
+  if (
+    result?.content.some(
+      (item) => item.type === "image" && item.generation?.route === "codex-images",
+    )
+  ) {
+    return "estimated:gpt-image-2:reported-usage:public-prices:conservative";
+  }
   const resolved = resolveImageGenerationOptions(options);
   return `assumed:${CODEX_IMAGE_GENERATION_MODEL}:${resolved.quality}:${resolved.size}:png`;
 }
@@ -55,8 +65,28 @@ export function estimateImageGenerationCostMicroUsd(
   result: QueryOutput,
   options: ImageGenerationOptions | undefined,
 ): number | null {
-  const imageCount = result.content.filter((item) => item.type === "image").length;
+  const images = result.content.filter((item) => item.type === "image");
+  const imageCount = images.length;
   if (imageCount === 0) return null;
+  if (images.some((image) => image.generation?.route === "codex-images")) {
+    // The standalone response's aggregate usage is carried by its first image only.
+    // Do not multiply it by output count or price it as the requested text driver.
+    const usage = images.find((image) => image.generation?.usage)?.generation?.usage;
+    if (!usage) return null;
+    // Public GPT Image 2 rates verified 2026-09-08: text input $5/M, image input
+    // $8/M, output $30/M. Amounts below are microUSD, so no /1M conversion.
+    // https://developers.openai.com/api/docs/pricing#image-generation
+    // Use a consistent reported split; unknown input is conservatively priced as
+    // images. Cache discounts and private subscription billing remain unknown.
+    const details = usage.input_tokens_details;
+    const textTokens =
+      details && details.text_tokens + details.image_tokens <= usage.input_tokens
+        ? details.text_tokens
+        : 0;
+    return Math.round(
+      textTokens * 5 + (usage.input_tokens - textTokens) * 8 + usage.output_tokens * 30,
+    );
+  }
   const resolved = resolveImageGenerationOptions(options);
   return imageCount * IMAGE_OUTPUT_COST_MICRO_USD[resolved.quality][resolved.size];
 }

package/bundle/src/application/qgrid/qgrid-response-format.test.ts

@@ -2,7 +2,33 @@ import { describe, expect, it } from "vitest";
 
 import { buildImageGenerationToolSteps, imageGenerationToolArgs } from "./qgrid-response-format";
 
+it("logs observed standalone settings separately from requested controls without a requested-price assumption", () => {
+  const requestedOptions = { quality: "high" as const, size: "1024x1024" as const, background: "transparent" as const };
+  const generation = {
+    route: "codex-images" as const, model: "gpt-image-2" as const,
+    quality: "medium", size: "1254x1254", background: "transparent",
+    usage: { input_tokens: 10, output_tokens: 100, total_tokens: 110 },
+  };
+  const [step] = buildImageGenerationToolSteps({
+    prompt: "draw", model: "openai/gpt-5.5", imageGenerationOptions: requestedOptions,
+  }, [{ type: "image", data: "png", generation }], 0);
+  const args = JSON.parse(step!.tool_args);
+  expect(args.requestedOptions).toEqual(requestedOptions);
+  expect(args.observedGeneration).toEqual(generation);
+  expect(args).not.toHaveProperty("pricingAssumption");
+});
+
 describe("qgrid response log formatting", () => {
+  it("records requested image controls separately from pricing assumptions", () => {
+    const requestedOptions = { background: "transparent", size: "1024x1024", quality: "high" } as const;
+    const args = JSON.parse(imageGenerationToolArgs({
+      prompt: "an isolated circle", imageGeneration: true,
+      imageGenerationOptions: requestedOptions,
+    }));
+    expect(args.requestedOptions).toEqual(requestedOptions);
+    expect(args.pricingAssumption).not.toHaveProperty("background");
+  });
+
   it("includes input images in image-generation tool args", () => {
     expect(
       JSON.parse(

package/bundle/src/application/qgrid/qgrid-response-format.ts

@@ -2,7 +2,12 @@ import {
   CODEX_IMAGE_GENERATION_MODEL,
   resolveImageGenerationOptions,
 } from "./qgrid-image-generation";
-import { type QgridContent, type QueryInput, type QueryOutput } from "./qgrid.types";
+import {
+  type ImageGenerationMetadata,
+  type QgridContent,
+  type QueryInput,
+  type QueryOutput,
+} from "./qgrid.types";
 
 export const CODEX_IMAGE_GENERATION_TOOL_CONFIG = {
   type: "image_generation",
@@ -42,7 +47,7 @@ export function formatImagePartForLog(image: Extract<QgridContent, { type: "imag
 
 export function imageGenerationToolArgs(
   args: QueryInput,
-  options: { includeInputImages?: boolean } = {},
+  options: { includeInputImages?: boolean; generation?: ImageGenerationMetadata } = {},
 ): string {
   const resolved = resolveImageGenerationOptions(args.imageGenerationOptions);
   const inputImages =
@@ -52,11 +57,16 @@ export function imageGenerationToolArgs(
     ...(inputImages.length > 0 ? { inputImages } : {}),
     driverModel: args.model ?? null,
     tool: CODEX_IMAGE_GENERATION_TOOL_CONFIG,
-    pricingAssumption: {
-      model: CODEX_IMAGE_GENERATION_MODEL,
-      quality: resolved.quality,
-      size: resolved.size,
-    },
+    ...(args.imageGenerationOptions ? { requestedOptions: args.imageGenerationOptions } : {}),
+    ...(options.generation
+      ? { observedGeneration: options.generation }
+      : {
+          pricingAssumption: {
+            model: CODEX_IMAGE_GENERATION_MODEL,
+            quality: resolved.quality,
+            size: resolved.size,
+          },
+        }),
   });
 }
 
@@ -75,18 +85,16 @@ export function buildImageGenerationToolSteps(
 }> {
   if (images.length === 0) return [];
 
-  const firstToolArgs = imageGenerationToolArgs(args, { includeInputImages: true });
-  const laterToolArgs =
-    images.length > 1
-      ? imageGenerationToolArgs(args, { includeInputImages: false })
-      : firstToolArgs;
   return images.map((image, index) => ({
     step_index: stepIndex,
     type: "tool_call",
     tool_call_index: index,
     tool_call_id: `image_generation:${stepIndex}:${index}`,
     tool_name: "image_generation",
-    tool_args: index === 0 ? firstToolArgs : laterToolArgs,
+    tool_args: imageGenerationToolArgs(args, {
+      includeInputImages: index === 0,
+      generation: image.generation,
+    }),
     tool_result: formatImagePartForLog(image),
   }));
 }

package/bundle/src/application/qgrid/qgrid-run-lifecycle.test.ts

@@ -547,6 +547,38 @@ describe("qgrid run lifecycle TTFT", () => {
     );
   });
 
+  it("keeps standalone image accounting out of text usage and records response usage once", async () => {
+    const generation = {
+      route: "codex-images" as const, model: "gpt-image-2" as const,
+      size: "1254x1254", quality: "medium", background: "transparent",
+    };
+    aggregateStepUsageMock.mockResolvedValueOnce({
+      input_tokens: 0, output_tokens: 0, cache_read_tokens: 0, cache_creation_tokens: 0,
+      duration_ms: 120, fallback_count: 0, cost_usd: 0, cost_source: "pricing_table",
+    });
+    await afterQuery(10, 0, {
+      prompt: "draw", model: "openai/gpt-5.5", imageGeneration: true,
+      imageGenerationOptions: { quality: "high", size: "1024x1024", background: "transparent" },
+    }, queryOutput({
+      model: "gpt-image-2", requestedModel: "gpt-5.5", costUsd: 0,
+      usage: { input_tokens: 0, output_tokens: 0, reasoning_tokens: 0, cache_creation_input_tokens: 0, cache_read_input_tokens: 0 },
+      content: [
+        { type: "image", data: "first", generation: { ...generation, usage: {
+          input_tokens: 10, output_tokens: 100, total_tokens: 110,
+        } } },
+        { type: "image", data: "second", generation },
+      ],
+    }));
+    expect(appendStepMock).toHaveBeenCalledWith(10, expect.objectContaining({
+      type: "generate", model_name: "openai/gpt-image-2", requested_model_name: "openai/gpt-5.5",
+      input_tokens: 0, output_tokens: 0, cost_usd: 0,
+    }));
+    expect(finishRunMock).toHaveBeenCalledWith(10, expect.objectContaining({
+      input_tokens: 0, output_tokens: 0, cost_usd: 0, image_cost_usd: 3_080,
+      image_cost_method: "estimated:gpt-image-2:reported-usage:public-prices:conservative",
+    }));
+  });
+
   it("uses requested image quality and size for cost estimate", async () => {
     await afterQuery(
       10,

package/bundle/src/application/qgrid/qgrid-run-lifecycle.ts

@@ -242,7 +242,7 @@ export async function afterQuery(
         image_cost_usd: imageCostMicroUsd,
         image_cost_method:
           imageCostMicroUsd !== null
-            ? imageGenerationCostMethod(args.imageGenerationOptions)
+            ? imageGenerationCostMethod(args.imageGenerationOptions, result)
             : null,
         history: filterHistoryForStorage(args.history),
       });

package/bundle/src/application/qgrid/qgrid.types.ts

@@ -12,6 +12,36 @@ export const QgridTool = z.object({
 });
 export type QgridTool = z.infer<typeof QgridTool>;
 
+// Observed standalone Images response values, distinct from requested generation hints.
+export const ImageGenerationMetadata = z.object({
+  route: z.literal("codex-images"),
+  model: z.literal("gpt-image-2"),
+  background: z.string().optional(),
+  quality: z.string().optional(),
+  size: z.string().optional(),
+  usage: z
+    .object({
+      input_tokens: z.number().nonnegative(),
+      output_tokens: z.number().nonnegative(),
+      total_tokens: z.number().nonnegative(),
+      input_tokens_details: z
+        .object({
+          image_tokens: z.number().nonnegative(),
+          text_tokens: z.number().nonnegative(),
+          cached_tokens: z.number().nonnegative().optional(),
+        })
+        .optional(),
+      output_tokens_details: z
+        .object({
+          image_tokens: z.number().nonnegative(),
+          text_tokens: z.number().nonnegative(),
+        })
+        .optional(),
+    })
+    .optional(),
+});
+export type ImageGenerationMetadata = z.infer<typeof ImageGenerationMetadata>;
+
 export const QgridContent = z.discriminatedUnion("type", [
   z.object({
     type: z.literal("text"),
@@ -28,6 +58,7 @@ export const QgridContent = z.discriminatedUnion("type", [
     // Codex image_generation result base64. qgrid 는 포맷/확장자 책임을 지지 않는다.
     data: z.string(),
     revisedPrompt: z.string().nullish(),
+    generation: ImageGenerationMetadata.optional(),
   }),
 ]);
 export type QgridContent = z.infer<typeof QgridContent>;
@@ -53,6 +84,7 @@ export type ImageGenerationSize = z.infer<typeof ImageGenerationSize>;
 export const ImageGenerationOptions = z.object({
   quality: ImageGenerationQuality.optional(),
   size: ImageGenerationSize.optional(),
+  background: z.enum(["auto", "opaque", "transparent"]).optional(),
 });
 export type ImageGenerationOptions = z.infer<typeof ImageGenerationOptions>;
 

package/bundle/src/application/qgrid/tool-emulation.test.ts

@@ -56,6 +56,24 @@ describe("applyToolCallEmulation image parts", () => {
     });
     expect(out.content).toEqual([{ type: "text", text: "here is your image" }]);
   });
+
+  it("preserves observed image settings and attaches response usage only once", () => {
+    const generation = {
+      route: "codex-images" as const, model: "gpt-image-2" as const,
+      size: "1254x1254", quality: "medium", background: "transparent",
+    };
+    const usage = { input_tokens: 10, output_tokens: 100, total_tokens: 110 };
+    const out = applyToolCallEmulation(baseResult, undefined, {
+      answerKind: "text",
+      images: [
+        { ...img, generation: { ...generation, usage } },
+        { ...img, generation },
+      ],
+    });
+    expect(out.content.filter((item) => item.type === "image").map((item) => item.generation))
+      .toEqual([{ ...generation, usage }, generation]);
+    expect(out.usage).toEqual(baseResult.usage);
+  });
 });
 
 describe("applyToolCallEmulation envelope validation", () => {

package/bundle/src/application/qgrid/tool-emulation.ts

@@ -12,6 +12,7 @@ const STRUCTURED_ENVELOPE_LIMITS = {
   maxDepth: 132,
 } as const;
 import {
+  type ImageGenerationMetadata,
   type QgridContent,
   type QgridThreadCoord,
   type QgridTool,
@@ -70,6 +71,7 @@ export class ToolCallEmulationError extends Error {
 interface EmulationImage {
   data: string;
   revisedPrompt?: string | null;
+  generation?: ImageGenerationMetadata;
 }
 
 // answer 인코딩 종류. envelope 디코더는 한 벌이고 이 값은 answer 브랜치의 타입과
@@ -212,6 +214,7 @@ function appendImages(content: QgridContent[], images?: EmulationImage[]): Qgrid
         type: "image",
         data: image.data,
         revisedPrompt: image.revisedPrompt ?? null,
+        ...(image.generation ? { generation: image.generation } : {}),
       }),
     ),
   ];

package/bundle/src/application/setting/setting.model.test.ts

@@ -6,6 +6,26 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { resetNativeRunRegistryForTests } from "../qgrid/qgrid-run-lifecycle";
 import { resetServerRestartForTests } from "../../utils/server-restart";
 import { SettingModel } from "./setting.model";
+import * as reminders from "../qgrid/expired-token-reminder";
+import { SlackNotificationError } from "../../utils/slack-notify";
+
+describe("SettingModel.triggerExpiryReminder", () => {
+  afterEach(() => vi.restoreAllMocks());
+
+  it("returns the sent count after successful delivery", async () => {
+    vi.spyOn(reminders, "sendExpiredTokenReminderNow").mockResolvedValue(3);
+    await expect(SettingModel.triggerExpiryReminder()).resolves.toEqual({ sent: 3 });
+  });
+
+  it("returns a readable API error when Slack rejects a manual send", async () => {
+    vi.spyOn(reminders, "sendExpiredTokenReminderNow").mockRejectedValue(
+      new SlackNotificationError("Slack 알림 발송 실패: not_in_channel"),
+    );
+    await expect(SettingModel.triggerExpiryReminder()).rejects.toMatchObject({
+      statusCode: 400, message: "Slack 알림 발송 실패: not_in_channel",
+    });
+  });
+});
 
 function installContext(headers: Record<string, string>) {
   const raw = Object.assign(new EventEmitter(), {

package/bundle/src/application/setting/setting.model.ts

@@ -11,9 +11,10 @@ import {
   exhaustive,
 } from "sonamu";
 
-import { SD } from "../../i18n/sd.generated";
+import { SD, type LocalizedString } from "../../i18n/sd.generated";
 import { detectSupervisor } from "../../utils/process-supervisor";
 import { armServerRestartExit, beginServerRestart } from "../../utils/server-restart";
+import { SlackNotificationError } from "../../utils/slack-notify";
 import { type SettingSubsetKey, type SettingSubsetMapping } from "../sonamu.generated";
 import { settingSubsetQueries, settingLoaderQueries } from "../sonamu.generated.sso";
 import {
@@ -315,7 +316,14 @@ class SettingModelClass extends BaseModelClass<
     // setting.model → expired-token-reminder → token.model 경로가 생겨,
     // token.model 을 mock 하는 테스트가 실제 모듈을 먼저 로드하게 된다.
     const { sendExpiredTokenReminderNow } = await import("../qgrid/expired-token-reminder");
-    return { sent: await sendExpiredTokenReminderNow() };
+    try {
+      return { sent: await sendExpiredTokenReminderNow() };
+    } catch (error) {
+      if (error instanceof SlackNotificationError) {
+        throw new BadRequestException(error.message as LocalizedString);
+      }
+      throw error;
+    }
   }
 
   /**