@cartanova/qgrid-cli 2.6.4 → 2.6.6

package/README.ko.md

@@ -92,6 +92,8 @@ CLI는 실행 시 npm의 최신 버전을 확인하고 patch를 포함해 설치
 | `QGRID_DB_NAME` | `qgrid` |
 | `SLACK_BOT_TOKEN` | — (미설정 시 토큰 만료 알림 비활성) |
 | `SLACK_CHANNEL_ID` | — |
+| `SLACK_EXPIRY_REMINDER_INTERVAL_MINUTES` | — (미설정 시 만료 알림 반복 끔) |
+| `SLACK_USER_MAP` | — (`토큰명:SlackUserId` 목록) |
 
 서버 동작 관련 환경변수:
 

package/README.md

@@ -93,6 +93,8 @@ Without the `--db` flag, DB connection info is read from:
 | `QGRID_DB_NAME` | `qgrid` |
 | `SLACK_BOT_TOKEN` | — (unset disables token-expiry notifications) |
 | `SLACK_CHANNEL_ID` | — |
+| `SLACK_EXPIRY_REMINDER_INTERVAL_MINUTES` | — (unset disables session-expiry repeats) |
+| `SLACK_USER_MAP` | — (`tokenName:SlackUserId` pairs) |
 
 Server behavior variables:
 

package/bundle/dist/application/qgrid/expired-token-reminder.js

@@ -0,0 +1,61 @@
+import { SLACK_COLOR, notifySlack } from "../../utils/slack-notify.js";
+import { TokenModel } from "../token/token.model.js";
+import { getSlackUserMap, mentionFor } from "./slack-user-map.js";
+import { getLogger } from "@logtape/logtape";
+//#region src/application/qgrid/expired-token-reminder.ts
+/**
+* 세션 만료 알림 반복.
+*
+* 만료 순간의 알림(`token-death.ts`)은 그때 채널을 보지 않으면 놓친다. 재로그인은 사람이
+* 해야 하는 일이라 놓치면 토큰이 계속 빠진 채로 남는다. 그래서 아직 재로그인되지 않은
+* 토큰을 같은 문구로 다시 알린다 — 사건이 하나이므로 알림도 한 종류다.
+*
+* 여러 토큰이 만료돼 있으면 한 메시지에 모은다. 토큰마다 메시지를 보내면 채널이 시끄러워
+* 정작 읽히지 않는다.
+*
+* 비활성 토큰이 없으면 보내지 않는다 — "이상 없음"을 주기적으로 알리면 채널이 무뎌진다.
+*/
+const logger = getLogger(["qgrid", "expired-reminder"]);
+const MINUTE_MS = 6e4;
+function buildReminderContext(tokens, userMap) {
+	return tokens.map((token) => {
+		const mention = mentionFor(token.name, userMap);
+		const label = token.name ?? "unnamed";
+		return mention ? `${mention} ${label}` : label;
+	}).join("\n");
+}
+async function sendReminder(userMap) {
+	const inactive = await TokenModel.findInactive("A");
+	if (inactive.length === 0) return;
+	await notifySlack({
+		title: "세션 만료",
+		subject: inactive.length > 1 ? `${inactive.length}건` : inactive[0].name ?? "unnamed",
+		context: `${buildReminderContext(inactive, userMap)}\n재로그인이 필요합니다`,
+		color: SLACK_COLOR.bad
+	});
+}
+let timer = null;
+/**
+* `SLACK_EXPIRY_REMINDER_INTERVAL_MINUTES` 가 양수일 때만 켜진다. 미설정·0 이면 비활성.
+*
+* 인스턴스가 여러 개면 각자 보낸다. 만료 순간 알림과 달리 상태 변화가 없어 DB 로 억제할 수
+* 없고, 하루 몇 건 수준이라 중복을 감수하는 편이 잠금 장치를 두는 것보다 낫다.
+*/
+function startExpiredTokenReminder() {
+	const minutes = Number(process.env.SLACK_EXPIRY_REMINDER_INTERVAL_MINUTES ?? 0);
+	if (!Number.isFinite(minutes) || minutes <= 0) return;
+	const userMap = getSlackUserMap();
+	logger.info(`expired token reminder every ${minutes}m (${userMap.size} user mappings)`);
+	timer = setInterval(() => {
+		sendReminder(userMap).catch((e) => logger.warn(`reminder failed: ${e.message}`));
+	}, minutes * MINUTE_MS);
+}
+function stopExpiredTokenReminder() {
+	if (!timer) return;
+	clearInterval(timer);
+	timer = null;
+}
+//#endregion
+export { buildReminderContext, startExpiredTokenReminder, stopExpiredTokenReminder };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/bundle/dist/application/qgrid/qgrid.frame.js

@@ -5,10 +5,10 @@ import { ToolSchemaCompositionError } from "./tool-emulation-schema.js";
 import { QgridDispatcher, buildAndValidateStrictOutputSchema } from "./qgrid.dispatcher.js";
 import __decorateMetadata from "../../_virtual/_@oxc-project_runtime@0.140.0/helpers/esm/decorateMetadata.js";
 import __decorate from "../../_virtual/_@oxc-project_runtime@0.140.0/helpers/esm/decorate.js";
+import { TokenModel } from "../token/token.model.js";
 import { CONSOLE_CALLBACK_URL, RefreshFailedError, buildAuthUrl, exchangeCodeForTokens, fetchUsage, generatePKCE, refreshAccessToken } from "./oauth.js";
 import { MICRO_USD, RequestLogModel } from "../request-log/request-log.model.js";
 import { afterQuery, beforeQuery, finishRunAborted, finishRunWithError } from "./qgrid-run-lifecycle.js";
-import { TokenModel } from "../token/token.model.js";
 import { TokenCredentials } from "../token/token.types.js";
 import { deactivateAuthDeadToken, notifyTokenAdded } from "./token-death.js";
 import { BadRequestException, BaseFrameClass, Sonamu, api, stream } from "sonamu";

package/bundle/dist/application/qgrid/slack-user-map.js

@@ -0,0 +1,49 @@
+//#region src/application/qgrid/slack-user-map.ts
+/**
+* 토큰 소유자 → Slack 사용자 멘션.
+*
+* Slack 표시 이름과 토큰명이 자주 어긋나(haze→haze.lee, byeongjun→potados) `users.list`
+* 자동 매칭은 조용히 실패한다. 멘션이 빠지면 알림이 개인에게 닿지 않아 목적 자체가
+* 사라지므로 `SLACK_USER_MAP` 명시 매핑만 쓴다.
+*
+* 공용 계정(bysuco, dev-common 등)은 매핑에 넣지 않는다 — 멘션 없이 이름만 나가는 것이
+* 맞는 동작이다.
+*/
+/** `토큰명:SlackUserId` 목록을 파싱한다. */
+function parseSlackUserMap(raw) {
+	const map = /* @__PURE__ */ new Map();
+	if (!raw) return map;
+	for (const entry of raw.split(",")) {
+		const [name, userId] = entry.split(":").map((s) => s.trim());
+		if (name && userId) map.set(name, userId);
+	}
+	return map;
+}
+/** `anthropic/yds` → `yds`. provider prefix 없이 저장된 이름도 그대로 받는다. */
+function ownerOf(tokenName) {
+	if (!tokenName) return "";
+	const slash = tokenName.indexOf("/");
+	return slash === -1 ? tokenName : tokenName.slice(slash + 1);
+}
+/** 매핑이 있으면 `<@U...>`, 없으면 빈 문자열. 호출부가 멘션 유무로 문구를 고른다. */
+function mentionFor(tokenName, userMap) {
+	const userId = userMap.get(ownerOf(tokenName));
+	return userId ? `<@${userId}>` : "";
+}
+/**
+* 환경변수는 프로세스 수명 동안 고정이라 매번 파싱할 이유가 없다. 사망 알림은 요청 경로에서
+* 호출되므로 캐시해 둔다.
+*/
+let cached = null;
+function getSlackUserMap() {
+	cached ??= parseSlackUserMap(process.env.SLACK_USER_MAP);
+	return cached;
+}
+/** 테스트에서 env 를 바꿔 끼울 때 쓴다. */
+function resetSlackUserMapCache() {
+	cached = null;
+}
+//#endregion
+export { getSlackUserMap, mentionFor, ownerOf, parseSlackUserMap, resetSlackUserMapCache };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/bundle/dist/application/qgrid/token-death.js

@@ -1,6 +1,7 @@
 import { getRefreshToken } from "../../utils/providers/common/credentials.js";
-import { TokenModel } from "../token/token.model.js";
 import { SLACK_COLOR, notifySlack } from "../../utils/slack-notify.js";
+import { TokenModel } from "../token/token.model.js";
+import { getSlackUserMap, mentionFor } from "./slack-user-map.js";
 import { getLogger } from "@logtape/logtape";
 //#region src/application/qgrid/token-death.ts
 /**
@@ -32,10 +33,16 @@ async function deactivateAuthDeadToken(token, usedRefreshToken, reasonCode) {
 		return false;
 	}
 	logger.warn(`token deactivated (auth dead): ${token.name}(id=${token.id}) reason=${reasonCode}`);
+	const mention = mentionFor(token.name, getSlackUserMap());
 	notifySlack({
 		title: "세션 만료",
 		subject: token.name,
-		context: `${token.provider} · ${reasonCode} · 재로그인이 필요합니다`,
+		context: [
+			mention,
+			token.provider,
+			reasonCode,
+			"재로그인이 필요합니다"
+		].filter(Boolean).join(" · "),
 		color: SLACK_COLOR.bad
 	});
 	return true;
@@ -54,10 +61,15 @@ function notifyLastActiveTokenDying(token, reasonCode) {
 	const previous = lastActiveAlertAt.get(token.provider);
 	if (previous !== void 0 && now - previous < LAST_ACTIVE_ALERT_COOLDOWN_MS) return;
 	lastActiveAlertAt.set(token.provider, now);
+	const mention = mentionFor(token.name, getSlackUserMap());
 	notifySlack({
 		title: "마지막 토큰 사망",
 		subject: token.name,
-		context: `${token.provider} · ${reasonCode} · 풀이 비지 않도록 유지 중입니다. 전 토큰이 동시에 실패했다면 client_id 취소나 OAuth 계약 변경을 의심하세요`,
+		context: [
+			mention,
+			token.provider,
+			reasonCode
+		].filter(Boolean).join(" · ") + " · 풀이 비지 않도록 유지 중입니다. 전 토큰이 동시에 실패했다면 client_id 취소나 OAuth 계약 변경을 의심하세요",
 		color: SLACK_COLOR.bad
 	});
 }
@@ -67,11 +79,15 @@ function notifyTokenAdded(name, provider) {
 	notifySlack({
 		title: "토큰 추가",
 		subject: name,
-		context: `${provider} · 요청 처리에 사용됩니다`,
+		context: [
+			mentionFor(name, getSlackUserMap()),
+			provider,
+			"요청 처리에 사용됩니다"
+		].filter(Boolean).join(" · "),
 		color: SLACK_COLOR.good
 	});
 }
 //#endregion
 export { deactivateAuthDeadToken, notifyTokenAdded };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9rZW4tZGVhdGguanMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2FwcGxpY2F0aW9uL3FncmlkL3Rva2VuLWRlYXRoLnRzIl0sInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICog7IS47IWYIOunjOujjChhdXRoLWRlYWQpIO2GoO2BsOydmCDrnbzsmrDtjIUg7KCc7Jm4IOyngOygkC5cbiAqXG4gKiByZWZyZXNoIOqwgCDsnqzroZzqt7jsnbgg7Jm4IOuzteq1rCDrtojqsIDtlZwg7Iuk7Yyo66W8IOuwmO2ZmO2VnCDsiJzqsITsl5Drp4wg7Zi47Lac65Cc64ukLiDruYTtmZzshLHtmZTripRcbiAqIGBhY3RpdmU9dHJ1ZWAg7KGw6rG067aAIOqwseyLoCAx7ZqM7J206rOgLCDqt7gg6rCx7Iug7J2EIOydtOq4tCDtlITroZzshLjsiqTrp4wgU2xhY2sg7JWM66a87J2EIOuztOuCuOuLpCDigJRcbiAqIOqzteycoCBEQiDrpbwg7JOw64qUIOyduOyKpO2EtOyKpOqwgCDrqofsnbTrk6Ag7IKs6rG064u5IOyVjOumvOydgCAx6rG07J2064ukLlxuICovXG5pbXBvcnQgeyBnZXRMb2dnZXIgfSBmcm9tIFwiQGxvZ3RhcGUvbG9ndGFwZVwiO1xuXG5pbXBvcnQgeyBnZXRSZWZyZXNoVG9rZW4gfSBmcm9tIFwiLi4vLi4vdXRpbHMvcHJvdmlkZXJzL2NvbW1vbi9jcmVkZW50aWFsc1wiO1xuaW1wb3J0IHsgbm90aWZ5U2xhY2ssIFNMQUNLX0NPTE9SIH0gZnJvbSBcIi4uLy4uL3V0aWxzL3NsYWNrLW5vdGlmeVwiO1xuaW1wb3J0IHsgVG9rZW5Nb2RlbCB9IGZyb20gXCIuLi90b2tlbi90b2tlbi5tb2RlbFwiO1xuXG5jb25zdCBsb2dnZXIgPSBnZXRMb2dnZXIoW1wicWdyaWRcIiwgXCJ0b2tlbi1kZWF0aFwiXSk7XG5cbnR5cGUgRGVhZFRva2VuUmVmID0ge1xuICBpZDogbnVtYmVyO1xuICBuYW1lOiBzdHJpbmc7XG4gIHByb3ZpZGVyOiBzdHJpbmc7XG59O1xuXG4vKipcbiAqIEBwYXJhbSB1c2VkUmVmcmVzaFRva2VuIOyLpO2MqO2VnCDsmpTssq3snbQg7Iuk7KCc66GcIOyCrOyaqe2VnCByZWZyZXNoIHRva2VuLlxuICogICByZWZyZXNoIHRva2VuIOydgCDtmozsoIQg7KCA7J6l65CY66+A66GcLCDsnbTrr7gg7ZqM7KCE65CcIOyYmyDthqDtgbDsnLzroZwg64qm6rKMIOuPhOywqe2VnCDsnqzsi5zrj4TqsIBcbiAqICAgNDAwIOydhCDrsJvripQg6rKD7J2AIOygleyDgSDroIjsnbTsiqTri6QuIERCIOydmCDtmITsnqwg6rCS6rO8IOuLpOultOuptCDsgqzrp53snLzroZwg67O07KeAIOyViuuKlOuLpC5cbiAqIEBwYXJhbSByZWFzb25Db2RlIGBwcm92aWRlcjpjb2RlYCDtmJXtg5zsnZgg64K067aAIOy9lOuTnC4gcHJvdmlkZXIg7J2R64u1IOuzuOusuOyXkOuKlCDqs4TsoJUg7J2066mU7J287J2064KYXG4gKiAgIO2GoO2BsCDsobDqsIHsnbQg7ISe7J28IOyImCDsnojslrQgcmF3IOuplOyLnOyngOulvCDqt7jrjIDroZwg7JWM66a87JeQIOyLo+yngCDslYrripTri6QuXG4gKi9cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiBkZWFjdGl2YXRlQXV0aERlYWRUb2tlbihcbiAgdG9rZW46IERlYWRUb2tlblJlZixcbiAgdXNlZFJlZnJlc2hUb2tlbjogc3RyaW5nLFxuICByZWFzb25Db2RlOiBzdHJpbmcsXG4pOiBQcm9taXNlPGJvb2xlYW4+IHtcbiAgY29uc3QgY3VycmVudCA9IGF3YWl0IFRva2VuTW9kZWwuZmluZE9uZShcIkFcIiwgeyBpZDogdG9rZW4uaWQgfSk7XG4gIGlmICghY3VycmVudCkgcmV0dXJuIGZhbHNlO1xuXG4gIGNvbnN0IGN1cnJlbnRSZWZyZXNoVG9rZW4gPSBnZXRSZWZyZXNoVG9rZW4oY3VycmVudC5jcmVkZW50aWFscyk7XG4gIGlmIChjdXJyZW50UmVmcmVzaFRva2VuICYmIGN1cnJlbnRSZWZyZXNoVG9rZW4gIT09IHVzZWRSZWZyZXNoVG9rZW4pIHtcbiAgICBsb2dnZXIuaW5mbyhcbiAgICAgIGBza2lwcGluZyBhdXRoLWRlYXRoIGZvciAke3Rva2VuLm5hbWV9KGlkPSR7dG9rZW4uaWR9KTogcmVmcmVzaCB0b2tlbiByb3RhdGVkIHNpbmNlIHRoaXMgYXR0ZW1wdGAsXG4gICAgKTtcbiAgICByZXR1cm4gZmFsc2U7XG4gIH1cblxuICBjb25zdCB7IGRlYWN0aXZhdGVkLCBrZXB0QXNMYXN0QWN0aXZlIH0gPSBhd2FpdCBUb2tlbk1vZGVsLmRlYWN0aXZhdGVJZkFjdGl2ZSh0b2tlbi5pZCk7XG4gIGlmICghZGVhY3RpdmF0ZWQpIHtcbiAgICBpZiAoa2VwdEFzTGFzdEFjdGl2ZSkgbm90aWZ5TGFzdEFjdGl2ZVRva2VuRHlpbmcodG9rZW4sIHJlYXNvbkNvZGUpO1xuICAgIHJldHVybiBmYWxzZTtcbiAgfVxuXG4gIGxvZ2dlci53YXJuKGB0b2tlbiBkZWFjdGl2YXRlZCAoYXV0aCBkZWFkKTogJHt0b2tlbi5uYW1lfShpZD0ke3Rva2VuLmlkfSkgcmVhc29uPSR7cmVhc29uQ29kZX1gKTtcbiAgdm9pZCBub3RpZnlTbGFjayh7XG4gICAgdGl0bGU6IFwi7IS47IWYIOunjOujjFwiLFxuICAgIHN1YmplY3Q6IHRva2VuLm5hbWUsXG4gICAgY29udGV4dDogYCR7dG9rZW4ucHJvdmlkZXJ9IMK3ICR7cmVhc29uQ29kZX0gwrcg7J6s66Gc6re47J247J20IO2VhOyalO2VqeuLiOuLpGAsXG4gICAgY29sb3I6IFNMQUNLX0NPTE9SLmJhZCxcbiAgfSk7XG4gIHJldHVybiB0cnVlO1xufVxuXG4vKipcbiAqIOuniOyngOuniSDtmZzshLEg7Yag7YGw7J20IOyjveyXiOydhCDrlYzsnZgg7JWM66a8IOy/qOuLpOyatC5cbiAqXG4gKiDsnbQg6rK97JqwIO2GoO2BsOydgCDruYTtmZzshLHtmZTrkJjsp4Ag7JWK6rOgIOyCtOyVhOuCqOycvOuvgOuhnCwg65Kk65Sw66W064qUIOyalOyyreuniOuLpCDqsJnsnYAg7Iuk7Yyo66W8IOuwmOuzte2VtFxuICog7JWM66a87J20IO2PreyjvO2VnOuLpC4g67mE7Zmc7ISx7ZmUIOyEseqztSDqsr3roZzqsIAg7KGw6rG067aAIFVQREFURSDroZwg7KSR67O17J2EIOunieuKlCDqsoPqs7wg64us66asIOyXrOq4sOyXlFxuICog7IOB7YOcIOuzgO2ZlOqwgCDsl4bslrQgREIg66GcIOyWteygnO2VoCDsiJgg7JeG64ukIOKAlCBwcm92aWRlciDri6jsnITroZwg7Iuc6rCEIOywveydhCDrkZTri6QuXG4gKi9cbmNvbnN0IExBU1RfQUNUSVZFX0FMRVJUX0NPT0xET1dOX01TID0gMzAgKiA2MCAqIDEwMDA7XG5jb25zdCBsYXN0QWN0aXZlQWxlcnRBdCA9IG5ldyBNYXA8c3RyaW5nLCBudW1iZXI+KCk7XG5cbmZ1bmN0aW9uIG5vdGlmeUxhc3RBY3RpdmVUb2tlbkR5aW5nKHRva2VuOiBEZWFkVG9rZW5SZWYsIHJlYXNvbkNvZGU6IHN0cmluZyk6IHZvaWQge1xuICBjb25zdCBub3cgPSBEYXRlLm5vdygpO1xuICBjb25zdCBwcmV2aW91cyA9IGxhc3RBY3RpdmVBbGVydEF0LmdldCh0b2tlbi5wcm92aWRlcik7XG4gIGlmIChwcmV2aW91cyAhPT0gdW5kZWZpbmVkICYmIG5vdyAtIHByZXZpb3VzIDwgTEFTVF9BQ1RJVkVfQUxFUlRfQ09PTERPV05fTVMpIHJldHVybjtcbiAgbGFzdEFjdGl2ZUFsZXJ0QXQuc2V0KHRva2VuLnByb3ZpZGVyLCBub3cpO1xuXG4gIHZvaWQgbm90aWZ5U2xhY2soe1xuICAgIHRpdGxlOiBcIuuniOyngOuniSDthqDtgbAg7IKs66edXCIsXG4gICAgc3ViamVjdDogdG9rZW4ubmFtZSxcbiAgICBjb250ZXh0OlxuICAgICAgYCR7dG9rZW4ucHJvdmlkZXJ9IMK3ICR7cmVhc29uQ29kZX0gwrcg7ZKA7J20IOu5hOyngCDslYrrj4TroZ0g7Jyg7KeAIOykkeyeheuLiOuLpC4gYCArXG4gICAgICBg7KCEIO2GoO2BsOydtCDrj5nsi5zsl5Ag7Iuk7Yyo7ZaI64uk66m0IGNsaWVudF9pZCDst6jshozrgpggT0F1dGgg6rOE7JW9IOuzgOqyveydhCDsnZjsi6ztlZjshLjsmpRgLFxuICAgIGNvbG9yOiBTTEFDS19DT0xPUi5iYWQsXG4gIH0pO1xufVxuXG4vKiog66Gc6re47J247J20IOyZhOujjOuPvCDthqDtgbDsnbQg7KCA7J6l65CQ7J2EIOuVjC4g7Iug6recwrfsnqzroZzqt7jsnbjsnYQg6rCA66as7KeAIOyViuuKlOuLpC4gKi9cbmV4cG9ydCBmdW5jdGlvbiBub3RpZnlUb2tlbkFkZGVkKG5hbWU6IHN0cmluZywgcHJvdmlkZXI6IHN0cmluZyk6IHZvaWQge1xuICBsb2dnZXIuaW5mbyhgdG9rZW4gYWRkZWQ6ICR7bmFtZX0gKCR7cHJvdmlkZXJ9KWApO1xuICB2b2lkIG5vdGlmeVNsYWNrKHtcbiAgICB0aXRsZTogXCLthqDtgbAg7LaU6rCAXCIsXG4gICAgc3ViamVjdDogbmFtZSxcbiAgICBjb250ZXh0OiBgJHtwcm92aWRlcn0gwrcg7JqU7LKtIOyymOumrOyXkCDsgqzsmqnrkKnri4jri6RgLFxuICAgIGNvbG9yOiBTTEFDS19DT0xPUi5nb29kLFxuICB9KTtcbn1cbiJdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7O0FBYUEsTUFBTSxTQUFTLFVBQVUsQ0FBQyxTQUFTLGFBQWEsQ0FBQzs7Ozs7Ozs7QUFlakQsZUFBc0Isd0JBQ3BCLE9BQ0Esa0JBQ0EsWUFDa0I7Q0FDbEIsTUFBTSxVQUFVLE1BQU0sV0FBVyxRQUFRLEtBQUssRUFBRSxJQUFJLE1BQU0sR0FBRyxDQUFDO0NBQzlELElBQUksQ0FBQyxTQUFTLE9BQU87Q0FFckIsTUFBTSxzQkFBc0IsZ0JBQWdCLFFBQVEsV0FBVztDQUMvRCxJQUFJLHVCQUF1Qix3QkFBd0Isa0JBQWtCO0VBQ25FLE9BQU8sS0FDTCwyQkFBMkIsTUFBTSxLQUFLLE1BQU0sTUFBTSxHQUFHLDRDQUN2RDtFQUNBLE9BQU87Q0FDVDtDQUVBLE1BQU0sRUFBRSxhQUFhLHFCQUFxQixNQUFNLFdBQVcsbUJBQW1CLE1BQU0sRUFBRTtDQUN0RixJQUFJLENBQUMsYUFBYTtFQUNoQixJQUFJLGtCQUFrQiwyQkFBMkIsT0FBTyxVQUFVO0VBQ2xFLE9BQU87Q0FDVDtDQUVBLE9BQU8sS0FBSyxrQ0FBa0MsTUFBTSxLQUFLLE1BQU0sTUFBTSxHQUFHLFdBQVcsWUFBWTtDQUMvRixBQUFLLFlBQVk7RUFDZixPQUFPO0VBQ1AsU0FBUyxNQUFNO0VBQ2YsU0FBUyxHQUFHLE1BQU0sU0FBUyxLQUFLLFdBQVc7RUFDM0MsT0FBTyxZQUFZO0NBQ3JCLENBQUM7Q0FDRCxPQUFPO0FBQ1Q7Ozs7Ozs7O0FBU0EsTUFBTSxnQ0FBZ0MsT0FBVTtBQUNoRCxNQUFNLG9DQUFvQixJQUFJLElBQW9CO0FBRWxELFNBQVMsMkJBQTJCLE9BQXFCLFlBQTBCO0NBQ2pGLE1BQU0sTUFBTSxLQUFLLElBQUk7Q0FDckIsTUFBTSxXQUFXLGtCQUFrQixJQUFJLE1BQU0sUUFBUTtDQUNyRCxJQUFJLGFBQWEsVUFBYSxNQUFNLFdBQVcsK0JBQStCO0NBQzlFLGtCQUFrQixJQUFJLE1BQU0sVUFBVSxHQUFHO0NBRXpDLEFBQUssWUFBWTtFQUNmLE9BQU87RUFDUCxTQUFTLE1BQU07RUFDZixTQUNFLEdBQUcsTUFBTSxTQUFTLEtBQUssV0FBVztFQUVwQyxPQUFPLFlBQVk7Q0FDckIsQ0FBQztBQUNIOztBQUdBLFNBQWdCLGlCQUFpQixNQUFjLFVBQXdCO0NBQ3JFLE9BQU8sS0FBSyxnQkFBZ0IsS0FBSyxJQUFJLFNBQVMsRUFBRTtDQUNoRCxBQUFLLFlBQVk7RUFDZixPQUFPO0VBQ1AsU0FBUztFQUNULFNBQVMsR0FBRyxTQUFTO0VBQ3JCLE9BQU8sWUFBWTtDQUNyQixDQUFDO0FBQ0gifQ==
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"token-death.js","names":[],"sources":["../../../src/application/qgrid/token-death.ts"],"sourcesContent":["/**\n * 세션 만료(auth-dead) 토큰의 라우팅 제외 지점.\n *\n * refresh 가 재로그인 외 복구 불가한 실패를 반환한 순간에만 호출된다. 비활성화는\n * `active=true` 조건부 갱신 1회이고, 그 갱신을 이긴 프로세스만 Slack 알림을 보낸다 —\n * 공유 DB 를 쓰는 인스턴스가 몇이든 사건당 알림은 1건이다.\n */\nimport { getLogger } from \"@logtape/logtape\";\n\nimport { getRefreshToken } from \"../../utils/providers/common/credentials\";\nimport { notifySlack, SLACK_COLOR } from \"../../utils/slack-notify\";\nimport { TokenModel } from \"../token/token.model\";\nimport { getSlackUserMap, mentionFor } from \"./slack-user-map\";\n\nconst logger = getLogger([\"qgrid\", \"token-death\"]);\n\ntype DeadTokenRef = {\n  id: number;\n  name: string;\n  provider: string;\n};\n\n/**\n * @param usedRefreshToken 실패한 요청이 실제로 사용한 refresh token.\n *   refresh token 은 회전 저장되므로, 이미 회전된 옛 토큰으로 늦게 도착한 재시도가\n *   400 을 받는 것은 정상 레이스다. DB 의 현재 값과 다르면 사망으로 보지 않는다.\n * @param reasonCode `provider:code` 형태의 내부 코드. provider 응답 본문에는 계정 이메일이나\n *   토큰 조각이 섞일 수 있어 raw 메시지를 그대로 알림에 싣지 않는다.\n */\nexport async function deactivateAuthDeadToken(\n  token: DeadTokenRef,\n  usedRefreshToken: string,\n  reasonCode: string,\n): Promise<boolean> {\n  const current = await TokenModel.findOne(\"A\", { id: token.id });\n  if (!current) return false;\n\n  const currentRefreshToken = getRefreshToken(current.credentials);\n  if (currentRefreshToken && currentRefreshToken !== usedRefreshToken) {\n    logger.info(\n      `skipping auth-death for ${token.name}(id=${token.id}): refresh token rotated since this attempt`,\n    );\n    return false;\n  }\n\n  const { deactivated, keptAsLastActive } = await TokenModel.deactivateIfActive(token.id);\n  if (!deactivated) {\n    if (keptAsLastActive) notifyLastActiveTokenDying(token, reasonCode);\n    return false;\n  }\n\n  logger.warn(`token deactivated (auth dead): ${token.name}(id=${token.id}) reason=${reasonCode}`);\n  // 만료 직후가 재로그인하기 가장 좋은 타이밍이다. 소유자를 멘션해 그 순간 당사자에게\n  // 꽂는다 — 다이제스트를 기다리면 다음 주기까지 토큰이 빠진 채로 남는다.\n  const mention = mentionFor(token.name, getSlackUserMap());\n  void notifySlack({\n    title: \"세션 만료\",\n    subject: token.name,\n    context: [mention, token.provider, reasonCode, \"재로그인이 필요합니다\"]\n      .filter(Boolean)\n      .join(\" · \"),\n    color: SLACK_COLOR.bad,\n  });\n  return true;\n}\n\n/**\n * 마지막 활성 토큰이 죽었을 때의 알림 쿨다운.\n *\n * 이 경우 토큰은 비활성화되지 않고 살아남으므로, 뒤따르는 요청마다 같은 실패를 반복해\n * 알림이 폭주한다. 비활성화 성공 경로가 조건부 UPDATE 로 중복을 막는 것과 달리 여기엔\n * 상태 변화가 없어 DB 로 억제할 수 없다 — provider 단위로 시간 창을 둔다.\n */\nconst LAST_ACTIVE_ALERT_COOLDOWN_MS = 30 * 60 * 1000;\nconst lastActiveAlertAt = new Map<string, number>();\n\nfunction notifyLastActiveTokenDying(token: DeadTokenRef, reasonCode: string): void {\n  const now = Date.now();\n  const previous = lastActiveAlertAt.get(token.provider);\n  if (previous !== undefined && now - previous < LAST_ACTIVE_ALERT_COOLDOWN_MS) return;\n  lastActiveAlertAt.set(token.provider, now);\n\n  const mention = mentionFor(token.name, getSlackUserMap());\n  void notifySlack({\n    title: \"마지막 토큰 사망\",\n    subject: token.name,\n    context:\n      [mention, token.provider, reasonCode].filter(Boolean).join(\" · \") +\n      ` · 풀이 비지 않도록 유지 중입니다. ` +\n      `전 토큰이 동시에 실패했다면 client_id 취소나 OAuth 계약 변경을 의심하세요`,\n    color: SLACK_COLOR.bad,\n  });\n}\n\n/** 로그인이 완료돼 토큰이 저장됐을 때. 신규·재로그인을 가리지 않는다. */\nexport function notifyTokenAdded(name: string, provider: string): void {\n  logger.info(`token added: ${name} (${provider})`);\n  const mention = mentionFor(name, getSlackUserMap());\n  void notifySlack({\n    title: \"토큰 추가\",\n    subject: name,\n    context: [mention, provider, \"요청 처리에 사용됩니다\"].filter(Boolean).join(\" · \"),\n    color: SLACK_COLOR.good,\n  });\n}\n"],"mappings":";;;;;;;;;;;;;AAcA,MAAM,SAAS,UAAU,CAAC,SAAS,aAAa,CAAC;;;;;;;;AAejD,eAAsB,wBACpB,OACA,kBACA,YACkB;CAClB,MAAM,UAAU,MAAM,WAAW,QAAQ,KAAK,EAAE,IAAI,MAAM,GAAG,CAAC;CAC9D,IAAI,CAAC,SAAS,OAAO;CAErB,MAAM,sBAAsB,gBAAgB,QAAQ,WAAW;CAC/D,IAAI,uBAAuB,wBAAwB,kBAAkB;EACnE,OAAO,KACL,2BAA2B,MAAM,KAAK,MAAM,MAAM,GAAG,4CACvD;EACA,OAAO;CACT;CAEA,MAAM,EAAE,aAAa,qBAAqB,MAAM,WAAW,mBAAmB,MAAM,EAAE;CACtF,IAAI,CAAC,aAAa;EAChB,IAAI,kBAAkB,2BAA2B,OAAO,UAAU;EAClE,OAAO;CACT;CAEA,OAAO,KAAK,kCAAkC,MAAM,KAAK,MAAM,MAAM,GAAG,WAAW,YAAY;CAG/F,MAAM,UAAU,WAAW,MAAM,MAAM,gBAAgB,CAAC;CACxD,AAAK,YAAY;EACf,OAAO;EACP,SAAS,MAAM;EACf,SAAS;GAAC;GAAS,MAAM;GAAU;GAAY;EAAa,CAAC,CAC1D,OAAO,OAAO,CAAC,CACf,KAAK,KAAK;EACb,OAAO,YAAY;CACrB,CAAC;CACD,OAAO;AACT;;;;;;;;AASA,MAAM,gCAAgC,OAAU;AAChD,MAAM,oCAAoB,IAAI,IAAoB;AAElD,SAAS,2BAA2B,OAAqB,YAA0B;CACjF,MAAM,MAAM,KAAK,IAAI;CACrB,MAAM,WAAW,kBAAkB,IAAI,MAAM,QAAQ;CACrD,IAAI,aAAa,UAAa,MAAM,WAAW,+BAA+B;CAC9E,kBAAkB,IAAI,MAAM,UAAU,GAAG;CAEzC,MAAM,UAAU,WAAW,MAAM,MAAM,gBAAgB,CAAC;CACxD,AAAK,YAAY;EACf,OAAO;EACP,SAAS,MAAM;EACf,SACE;GAAC;GAAS,MAAM;GAAU;EAAU,CAAC,CAAC,OAAO,OAAO,CAAC,CAAC,KAAK,KAAK,IAChE;EAEF,OAAO,YAAY;CACrB,CAAC;AACH;;AAGA,SAAgB,iBAAiB,MAAc,UAAwB;CACrE,OAAO,KAAK,gBAAgB,KAAK,IAAI,SAAS,EAAE;CAEhD,AAAK,YAAY;EACf,OAAO;EACP,SAAS;EACT,SAAS;GAJK,WAAW,MAAM,gBAAgB,CAIrC;GAAS;GAAU;EAAc,CAAC,CAAC,OAAO,OAAO,CAAC,CAAC,KAAK,KAAK;EACvE,OAAO,YAAY;CACrB,CAAC;AACH"}

package/bundle/dist/application/token/token.model.js

@@ -97,6 +97,26 @@ var TokenModelClass = class extends BaseModelClass {
 			debug: false
 		})).rows;
 	}
+	/**
+	* 라우팅에서 빠진 토큰들. 세션 만료로 자동 비활성화된 것과 수동으로 끈 것이 섞여 있다 —
+	* 둘 다 "재로그인하면 살아나는" 상태라 알림 대상으로는 같게 본다.
+	*/
+	async findInactive(subset) {
+		const { qb } = this.getSubsetQueries(subset);
+		qb.where("tokens.active", false);
+		qb.orderBy("tokens.name", "asc");
+		const enhancers = this.createEnhancers({ A: (row) => ({ ...row }) });
+		return (await this.executeSubsetQuery({
+			subset,
+			qb,
+			params: {
+				num: 100,
+				page: 1
+			},
+			enhancers,
+			debug: false
+		})).rows;
+	}
 	async findActive(subset) {
 		const { qb } = this.getSubsetQueries(subset);
 		qb.where("tokens.active", true);
@@ -237,4 +257,4 @@ const TokenModel = new TokenModelClass();
 //#endregion
 export { TokenModel };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"token.model.js","names":[],"sources":["../../../src/application/token/token.model.ts"],"sourcesContent":["import { getLogger } from \"@logtape/logtape\";\nimport {\n  api,\n  asArray,\n  BadRequestException,\n  BaseModelClass,\n  exhaustive,\n  type ListResult,\n  NotFoundException,\n} from \"sonamu\";\n\nimport { SD } from \"../../i18n/sd.generated\";\nimport { type TokenSubsetKey, type TokenSubsetMapping } from \"../sonamu.generated\";\nimport { tokenLoaderQueries, tokenSubsetQueries } from \"../sonamu.generated.sso\";\nimport { type TokenListParams, type TokenSaveParams } from \"./token.types\";\n\nconst logger = getLogger([\"qgrid\", \"token\"]);\n\nconst DEFAULT_QUOTA_THRESHOLD = 80;\nconst DEFAULT_WEIGHT = 1;\n\nexport type TokenUpdateFields = {\n  name?: string;\n  quota_threshold?: number | null;\n  weight?: number;\n};\n\nfunction applyCreateDefaults(sp: TokenSaveParams): TokenSaveParams {\n  if (sp.id !== undefined) return sp;\n  return {\n    ...sp,\n    ...(sp.quota_threshold === undefined ? { quota_threshold: DEFAULT_QUOTA_THRESHOLD } : {}),\n    ...(sp.weight === undefined ? { weight: DEFAULT_WEIGHT } : {}),\n  };\n}\n\nclass TokenModelClass extends BaseModelClass<\n  TokenSubsetKey,\n  TokenSubsetMapping,\n  typeof tokenSubsetQueries,\n  typeof tokenLoaderQueries\n> {\n  constructor() {\n    super(\"Token\", tokenSubsetQueries, tokenLoaderQueries);\n  }\n\n  @api({ httpMethod: \"GET\", clients: [\"axios\", \"tanstack-query\"], resourceName: \"Token\" })\n  async findById<T extends TokenSubsetKey>(subset: T, id: number): Promise<TokenSubsetMapping[T]> {\n    const { rows } = await this.findMany(subset, { id, num: 1, page: 1 });\n    if (!rows[0]) {\n      throw new NotFoundException(SD(\"error.entityNotFound\")(\"Token\", id));\n    }\n    return rows[0];\n  }\n\n  async findOne<T extends TokenSubsetKey>(\n    subset: T,\n    listParams: TokenListParams,\n  ): Promise<TokenSubsetMapping[T] | null> {\n    const { rows } = await this.findMany(subset, { ...listParams, num: 1, page: 1 });\n    return rows[0] ?? null;\n  }\n\n  @api({ httpMethod: \"GET\", clients: [\"axios\", \"tanstack-query\"], resourceName: \"Tokens\" })\n  async findMany<T extends TokenSubsetKey, LP extends TokenListParams>(\n    subset: T,\n    rawParams?: LP,\n  ): Promise<ListResult<LP, TokenSubsetMapping[T]>> {\n    const params = {\n      num: 24,\n      page: 1,\n      search: \"id\" as const,\n      orderBy: \"ord-asc\" as const,\n      ...rawParams,\n    } satisfies TokenListParams;\n\n    const { qb, onSubset: _ } = this.getSubsetQueries(subset);\n\n    if (params.id) {\n      qb.whereIn(\"tokens.id\", asArray(params.id));\n    }\n\n    if (params.search && params.keyword && params.keyword.length > 0) {\n      if (params.search === \"id\") {\n        qb.where(\"tokens.id\", Number(params.keyword));\n      } else if (params.search === \"name\") {\n        qb.where(\"tokens.name\", \"like\", `%${params.keyword}%`);\n      } else {\n        throw new BadRequestException(SD(\"error.unknownSearchField\")(params.search));\n      }\n    }\n\n    if (params.orderBy) {\n      if (params.orderBy === \"id-desc\") {\n        qb.orderBy(\"tokens.id\", \"desc\");\n      } else if (params.orderBy === \"ord-asc\") {\n        qb.orderBy(\"tokens.ord\", \"asc\");\n        qb.orderBy(\"tokens.id\", \"asc\");\n      } else {\n        exhaustive(params.orderBy);\n      }\n    }\n\n    const enhancers = this.createEnhancers({\n      A: (row) => ({ ...row }),\n    });\n\n    return this.executeSubsetQuery({ subset, qb, params, enhancers, debug: false });\n  }\n\n  async findByAccountIdentifier<T extends TokenSubsetKey>(\n    subset: T,\n    provider: string,\n    accountId: string,\n  ): Promise<TokenSubsetMapping[T][]> {\n    const { qb } = this.getSubsetQueries(subset);\n    qb.where(\"tokens.provider\", provider);\n    const jsonKey = provider === \"anthropic\" ? \"accountUuid\" : \"accountId\";\n    qb.whereRaw(`tokens.credentials->>'${jsonKey}' = ?`, [accountId]);\n    const enhancers = this.createEnhancers({ A: (row) => ({ ...row }) });\n    const result = await this.executeSubsetQuery({\n      subset,\n      qb,\n      params: { num: 100, page: 1 },\n      enhancers,\n      debug: false,\n    });\n    return result.rows;\n  }\n\n  async findActiveByProvider<T extends TokenSubsetKey>(\n    subset: T,\n    provider: string,\n  ): Promise<TokenSubsetMapping[T][]> {\n    const { qb } = this.getSubsetQueries(subset);\n    qb.where(\"tokens.active\", true);\n    qb.where(\"tokens.provider\", provider);\n    const enhancers = this.createEnhancers({ A: (row) => ({ ...row }) });\n    const result = await this.executeSubsetQuery({\n      subset,\n      qb,\n      params: { num: 100, page: 1 },\n      enhancers,\n      debug: false,\n    });\n    return result.rows;\n  }\n\n  async findActive<T extends TokenSubsetKey>(subset: T): Promise<TokenSubsetMapping[T][]> {\n    const { qb } = this.getSubsetQueries(subset);\n    qb.where(\"tokens.active\", true);\n    const enhancers = this.createEnhancers({ A: (row) => ({ ...row }) });\n    const result = await this.executeSubsetQuery({\n      subset,\n      qb,\n      params: { num: 100, page: 1 },\n      enhancers,\n      debug: false,\n    });\n    return result.rows;\n  }\n\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async save(spa: TokenSaveParams[]): Promise<number[]> {\n    const wdb = this.getPuri(\"w\");\n    spa.forEach((sp) => {\n      wdb.ubRegister(\"tokens\", applyCreateDefaults(sp));\n    });\n    return wdb.transaction(async (trx) => {\n      return trx.ubUpsert(\"tokens\");\n    });\n  }\n\n  async updateFields(id: number, fields: TokenUpdateFields): Promise<number> {\n    const wdb = this.getPuri(\"w\");\n    return wdb.transaction((trx) => trx.table(\"tokens\").where(\"id\", id).update(fields));\n  }\n\n  /**\n   * 세션 만료 토큰을 라우팅에서 제외한다. `active=true` 조건부 갱신이므로 공유 DB 를 쓰는\n   * 여러 인스턴스가 동시에 같은 만료를 감지해도 true 를 받는 프로세스는 하나뿐이다\n   * (호출부의 알림 발송 게이트).\n   *\n   * 단, 대상이 해당 provider 의 마지막 활성 토큰이면 갱신하지 않고 false 를 반환한다.\n   * client_id 취소나 OAuth 계약 변경처럼 전 토큰이 동시에 실패하는 상황에서 풀이\n   * 통째로 비는 것을 막는 안전판이다.\n   */\n  /**\n   * 같은 계정의 기존 토큰을 지우고 새로 저장한다(로그인·재로그인 공통 경로).\n   *\n   * provider 응답에 계정 식별자가 없으면 dedup 자체가 불가능하므로 경고만 남기고\n   * 중복 제거 없이 저장한다(죽은 row 가 남는다).\n   */\n  async replaceByAccount(\n    provider: string,\n    accountId: string | undefined,\n    saveParams: TokenSaveParams,\n  ): Promise<void> {\n    if (accountId) {\n      const oldEntries = await this.findByAccountIdentifier(\"A\", provider, accountId);\n      if (oldEntries.length > 0) await this.del(oldEntries.map((o) => o.id));\n    } else {\n      logger.warn(\n        `${provider} login without account identifier: dedup skipped for ${saveParams.name ?? \"unnamed\"}`,\n      );\n    }\n\n    await this.save([saveParams]);\n  }\n\n  /**\n   * @returns `deactivated` 는 이 호출이 실제로 비활성화를 수행했는지 — 호출부의 알림\n   *   게이트다. `keptAsLastActive` 는 마지막 활성 토큰이라 거부한 경우로, 사망 자체는\n   *   사실이지만 풀을 비우지 않으려고 살려둔 상태다(systemic 실패 신호).\n   */\n  async deactivateIfActive(\n    id: number,\n  ): Promise<{ deactivated: boolean; keptAsLastActive: boolean }> {\n    const wdb = this.getPuri(\"w\");\n\n    // 활성 여부와 \"마지막 남은 토큰인가\"를 한 statement 안에서 판정한다. 두 조건을\n    // 따로 읽고 나중에 갱신하면 그 사이에 다른 인스턴스가 같은 provider 의 토큰을\n    // 비활성화해 풀이 통째로 빌 수 있다.\n    const updated = await wdb.knex.raw<{ rowCount: number }>(\n      `UPDATE tokens SET active = false\n       WHERE id = ? AND active = true\n         AND (SELECT count(*) FROM tokens peer\n              WHERE peer.provider = tokens.provider AND peer.active) > 1`,\n      [id],\n    );\n    if ((updated.rowCount ?? 0) > 0) return { deactivated: true, keptAsLastActive: false };\n\n    // 갱신되지 않은 이유는 둘 중 하나다: 이미 비활성이거나(정상 경쟁 결과), 마지막\n    // 활성 토큰이거나. 후자는 systemic 실패 신호라 남겨야 하므로 이때만 한 번 더 읽는다.\n    const survivor = (\n      await wdb.knex.raw<{ rows: { provider: string }[] }>(\n        \"SELECT provider FROM tokens WHERE id = ? AND active = true\",\n        [id],\n      )\n    ).rows[0];\n    if (survivor) {\n      logger.error(\n        `refusing to auto-deactivate token ${id}: last active ${survivor.provider} token — ` +\n          `systemic refresh failure suspected, keeping the pool non-empty`,\n      );\n      return { deactivated: false, keptAsLastActive: true };\n    }\n    return { deactivated: false, keptAsLastActive: false };\n  }\n\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async reorder(ids: number[]): Promise<{ done: boolean }> {\n    const wdb = this.getPuri(\"w\");\n    await wdb.transaction(async (trx) => {\n      for (let i = 0; i < ids.length; i++) {\n        await trx.table(\"tokens\").where(\"id\", ids[i]!).update({ ord: i });\n      }\n    });\n    return { done: true };\n  }\n\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async del(ids: number[]): Promise<number> {\n    const wdb = this.getPuri(\"w\");\n    await wdb.transaction(async (trx) => {\n      return trx.table(\"tokens\").whereIn(\"tokens.id\", ids).delete();\n    });\n    return ids.length;\n  }\n}\n\nexport const TokenModel = new TokenModelClass();\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"token.model.js","names":[],"sources":["../../../src/application/token/token.model.ts"],"sourcesContent":["import { getLogger } from \"@logtape/logtape\";\nimport {\n  api,\n  asArray,\n  BadRequestException,\n  BaseModelClass,\n  exhaustive,\n  type ListResult,\n  NotFoundException,\n} from \"sonamu\";\n\nimport { SD } from \"../../i18n/sd.generated\";\nimport { type TokenSubsetKey, type TokenSubsetMapping } from \"../sonamu.generated\";\nimport { tokenLoaderQueries, tokenSubsetQueries } from \"../sonamu.generated.sso\";\nimport { type TokenListParams, type TokenSaveParams } from \"./token.types\";\n\nconst logger = getLogger([\"qgrid\", \"token\"]);\n\nconst DEFAULT_QUOTA_THRESHOLD = 80;\nconst DEFAULT_WEIGHT = 1;\n\nexport type TokenUpdateFields = {\n  name?: string;\n  quota_threshold?: number | null;\n  weight?: number;\n};\n\nfunction applyCreateDefaults(sp: TokenSaveParams): TokenSaveParams {\n  if (sp.id !== undefined) return sp;\n  return {\n    ...sp,\n    ...(sp.quota_threshold === undefined ? { quota_threshold: DEFAULT_QUOTA_THRESHOLD } : {}),\n    ...(sp.weight === undefined ? { weight: DEFAULT_WEIGHT } : {}),\n  };\n}\n\nclass TokenModelClass extends BaseModelClass<\n  TokenSubsetKey,\n  TokenSubsetMapping,\n  typeof tokenSubsetQueries,\n  typeof tokenLoaderQueries\n> {\n  constructor() {\n    super(\"Token\", tokenSubsetQueries, tokenLoaderQueries);\n  }\n\n  @api({ httpMethod: \"GET\", clients: [\"axios\", \"tanstack-query\"], resourceName: \"Token\" })\n  async findById<T extends TokenSubsetKey>(subset: T, id: number): Promise<TokenSubsetMapping[T]> {\n    const { rows } = await this.findMany(subset, { id, num: 1, page: 1 });\n    if (!rows[0]) {\n      throw new NotFoundException(SD(\"error.entityNotFound\")(\"Token\", id));\n    }\n    return rows[0];\n  }\n\n  async findOne<T extends TokenSubsetKey>(\n    subset: T,\n    listParams: TokenListParams,\n  ): Promise<TokenSubsetMapping[T] | null> {\n    const { rows } = await this.findMany(subset, { ...listParams, num: 1, page: 1 });\n    return rows[0] ?? null;\n  }\n\n  @api({ httpMethod: \"GET\", clients: [\"axios\", \"tanstack-query\"], resourceName: \"Tokens\" })\n  async findMany<T extends TokenSubsetKey, LP extends TokenListParams>(\n    subset: T,\n    rawParams?: LP,\n  ): Promise<ListResult<LP, TokenSubsetMapping[T]>> {\n    const params = {\n      num: 24,\n      page: 1,\n      search: \"id\" as const,\n      orderBy: \"ord-asc\" as const,\n      ...rawParams,\n    } satisfies TokenListParams;\n\n    const { qb, onSubset: _ } = this.getSubsetQueries(subset);\n\n    if (params.id) {\n      qb.whereIn(\"tokens.id\", asArray(params.id));\n    }\n\n    if (params.search && params.keyword && params.keyword.length > 0) {\n      if (params.search === \"id\") {\n        qb.where(\"tokens.id\", Number(params.keyword));\n      } else if (params.search === \"name\") {\n        qb.where(\"tokens.name\", \"like\", `%${params.keyword}%`);\n      } else {\n        throw new BadRequestException(SD(\"error.unknownSearchField\")(params.search));\n      }\n    }\n\n    if (params.orderBy) {\n      if (params.orderBy === \"id-desc\") {\n        qb.orderBy(\"tokens.id\", \"desc\");\n      } else if (params.orderBy === \"ord-asc\") {\n        qb.orderBy(\"tokens.ord\", \"asc\");\n        qb.orderBy(\"tokens.id\", \"asc\");\n      } else {\n        exhaustive(params.orderBy);\n      }\n    }\n\n    const enhancers = this.createEnhancers({\n      A: (row) => ({ ...row }),\n    });\n\n    return this.executeSubsetQuery({ subset, qb, params, enhancers, debug: false });\n  }\n\n  async findByAccountIdentifier<T extends TokenSubsetKey>(\n    subset: T,\n    provider: string,\n    accountId: string,\n  ): Promise<TokenSubsetMapping[T][]> {\n    const { qb } = this.getSubsetQueries(subset);\n    qb.where(\"tokens.provider\", provider);\n    const jsonKey = provider === \"anthropic\" ? \"accountUuid\" : \"accountId\";\n    qb.whereRaw(`tokens.credentials->>'${jsonKey}' = ?`, [accountId]);\n    const enhancers = this.createEnhancers({ A: (row) => ({ ...row }) });\n    const result = await this.executeSubsetQuery({\n      subset,\n      qb,\n      params: { num: 100, page: 1 },\n      enhancers,\n      debug: false,\n    });\n    return result.rows;\n  }\n\n  async findActiveByProvider<T extends TokenSubsetKey>(\n    subset: T,\n    provider: string,\n  ): Promise<TokenSubsetMapping[T][]> {\n    const { qb } = this.getSubsetQueries(subset);\n    qb.where(\"tokens.active\", true);\n    qb.where(\"tokens.provider\", provider);\n    const enhancers = this.createEnhancers({ A: (row) => ({ ...row }) });\n    const result = await this.executeSubsetQuery({\n      subset,\n      qb,\n      params: { num: 100, page: 1 },\n      enhancers,\n      debug: false,\n    });\n    return result.rows;\n  }\n\n  /**\n   * 라우팅에서 빠진 토큰들. 세션 만료로 자동 비활성화된 것과 수동으로 끈 것이 섞여 있다 —\n   * 둘 다 \"재로그인하면 살아나는\" 상태라 알림 대상으로는 같게 본다.\n   */\n  async findInactive<T extends TokenSubsetKey>(subset: T): Promise<TokenSubsetMapping[T][]> {\n    const { qb } = this.getSubsetQueries(subset);\n    qb.where(\"tokens.active\", false);\n    qb.orderBy(\"tokens.name\", \"asc\");\n    const enhancers = this.createEnhancers({ A: (row) => ({ ...row }) });\n    const result = await this.executeSubsetQuery({\n      subset,\n      qb,\n      params: { num: 100, page: 1 },\n      enhancers,\n      debug: false,\n    });\n    return result.rows;\n  }\n\n  async findActive<T extends TokenSubsetKey>(subset: T): Promise<TokenSubsetMapping[T][]> {\n    const { qb } = this.getSubsetQueries(subset);\n    qb.where(\"tokens.active\", true);\n    const enhancers = this.createEnhancers({ A: (row) => ({ ...row }) });\n    const result = await this.executeSubsetQuery({\n      subset,\n      qb,\n      params: { num: 100, page: 1 },\n      enhancers,\n      debug: false,\n    });\n    return result.rows;\n  }\n\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async save(spa: TokenSaveParams[]): Promise<number[]> {\n    const wdb = this.getPuri(\"w\");\n    spa.forEach((sp) => {\n      wdb.ubRegister(\"tokens\", applyCreateDefaults(sp));\n    });\n    return wdb.transaction(async (trx) => {\n      return trx.ubUpsert(\"tokens\");\n    });\n  }\n\n  async updateFields(id: number, fields: TokenUpdateFields): Promise<number> {\n    const wdb = this.getPuri(\"w\");\n    return wdb.transaction((trx) => trx.table(\"tokens\").where(\"id\", id).update(fields));\n  }\n\n  /**\n   * 세션 만료 토큰을 라우팅에서 제외한다. `active=true` 조건부 갱신이므로 공유 DB 를 쓰는\n   * 여러 인스턴스가 동시에 같은 만료를 감지해도 true 를 받는 프로세스는 하나뿐이다\n   * (호출부의 알림 발송 게이트).\n   *\n   * 단, 대상이 해당 provider 의 마지막 활성 토큰이면 갱신하지 않고 false 를 반환한다.\n   * client_id 취소나 OAuth 계약 변경처럼 전 토큰이 동시에 실패하는 상황에서 풀이\n   * 통째로 비는 것을 막는 안전판이다.\n   */\n  /**\n   * 같은 계정의 기존 토큰을 지우고 새로 저장한다(로그인·재로그인 공통 경로).\n   *\n   * provider 응답에 계정 식별자가 없으면 dedup 자체가 불가능하므로 경고만 남기고\n   * 중복 제거 없이 저장한다(죽은 row 가 남는다).\n   */\n  async replaceByAccount(\n    provider: string,\n    accountId: string | undefined,\n    saveParams: TokenSaveParams,\n  ): Promise<void> {\n    if (accountId) {\n      const oldEntries = await this.findByAccountIdentifier(\"A\", provider, accountId);\n      if (oldEntries.length > 0) await this.del(oldEntries.map((o) => o.id));\n    } else {\n      logger.warn(\n        `${provider} login without account identifier: dedup skipped for ${saveParams.name ?? \"unnamed\"}`,\n      );\n    }\n\n    await this.save([saveParams]);\n  }\n\n  /**\n   * @returns `deactivated` 는 이 호출이 실제로 비활성화를 수행했는지 — 호출부의 알림\n   *   게이트다. `keptAsLastActive` 는 마지막 활성 토큰이라 거부한 경우로, 사망 자체는\n   *   사실이지만 풀을 비우지 않으려고 살려둔 상태다(systemic 실패 신호).\n   */\n  async deactivateIfActive(\n    id: number,\n  ): Promise<{ deactivated: boolean; keptAsLastActive: boolean }> {\n    const wdb = this.getPuri(\"w\");\n\n    // 활성 여부와 \"마지막 남은 토큰인가\"를 한 statement 안에서 판정한다. 두 조건을\n    // 따로 읽고 나중에 갱신하면 그 사이에 다른 인스턴스가 같은 provider 의 토큰을\n    // 비활성화해 풀이 통째로 빌 수 있다.\n    const updated = await wdb.knex.raw<{ rowCount: number }>(\n      `UPDATE tokens SET active = false\n       WHERE id = ? AND active = true\n         AND (SELECT count(*) FROM tokens peer\n              WHERE peer.provider = tokens.provider AND peer.active) > 1`,\n      [id],\n    );\n    if ((updated.rowCount ?? 0) > 0) return { deactivated: true, keptAsLastActive: false };\n\n    // 갱신되지 않은 이유는 둘 중 하나다: 이미 비활성이거나(정상 경쟁 결과), 마지막\n    // 활성 토큰이거나. 후자는 systemic 실패 신호라 남겨야 하므로 이때만 한 번 더 읽는다.\n    const survivor = (\n      await wdb.knex.raw<{ rows: { provider: string }[] }>(\n        \"SELECT provider FROM tokens WHERE id = ? AND active = true\",\n        [id],\n      )\n    ).rows[0];\n    if (survivor) {\n      logger.error(\n        `refusing to auto-deactivate token ${id}: last active ${survivor.provider} token — ` +\n          `systemic refresh failure suspected, keeping the pool non-empty`,\n      );\n      return { deactivated: false, keptAsLastActive: true };\n    }\n    return { deactivated: false, keptAsLastActive: false };\n  }\n\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async reorder(ids: number[]): Promise<{ done: boolean }> {\n    const wdb = this.getPuri(\"w\");\n    await wdb.transaction(async (trx) => {\n      for (let i = 0; i < ids.length; i++) {\n        await trx.table(\"tokens\").where(\"id\", ids[i]!).update({ ord: i });\n      }\n    });\n    return { done: true };\n  }\n\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async del(ids: number[]): Promise<number> {\n    const wdb = this.getPuri(\"w\");\n    await wdb.transaction(async (trx) => {\n      return trx.table(\"tokens\").whereIn(\"tokens.id\", ids).delete();\n    });\n    return ids.length;\n  }\n}\n\nexport const TokenModel = new TokenModelClass();\n"],"mappings":"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"}

package/bundle/dist/sonamu.config.js

@@ -1,5 +1,6 @@
 import { monitLogSink } from "./application/monit/log-buffer.js";
 import { QgridDispatcher } from "./application/qgrid/qgrid.dispatcher.js";
+import { startExpiredTokenReminder, stopExpiredTokenReminder } from "./application/qgrid/expired-token-reminder.js";
 import { QgridFrame } from "./application/qgrid/qgrid.frame.js";
 import { TokenSubscriber } from "./application/qgrid/token-subscriber.js";
 import { ensureTokensTrigger } from "./application/qgrid/token-trigger-setup.js";
@@ -160,6 +161,7 @@ var sonamu_config_default = defineConfig({
 					QgridDispatcher.startupState.anthropic = "failed";
 					log.warn(`anthropic dispatcher failed: ${e.message}`);
 				}
+				startExpiredTokenReminder();
 				const anthropicCount = QgridDispatcher.anthropicDispatcher?.tokenCount ?? 0;
 				const openaiReady = QgridDispatcher.openaiDispatcher?.readyWorkerCount ?? 0;
 				const openaiTotal = QgridDispatcher.openaiDispatcher?.workerCount ?? 0;
@@ -170,6 +172,7 @@ var sonamu_config_default = defineConfig({
 			},
 			onShutdown: async () => {
 				const log = getLogger(["qgrid", "startup"]);
+				stopExpiredTokenReminder();
 				if (QgridDispatcher.openaiDispatcher) await QgridDispatcher.openaiDispatcher.stop();
 				if (QgridDispatcher.anthropicDispatcher) await QgridDispatcher.anthropicDispatcher.stop();
 				if (QgridDispatcher.subscriber) await QgridDispatcher.subscriber.stop();
@@ -184,4 +187,4 @@ var sonamu_config_default = defineConfig({
 //#endregion
 export { sonamu_config_default as default };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"sonamu.config.js","names":["cacheDrivers"],"sources":["../src/sonamu.config.ts"],"sourcesContent":["import path from \"path\";\n\nimport { getConsoleSink } from \"@logtape/logtape\";\nimport { getLogger } from \"@logtape/logtape\";\nimport { getPrettyFormatter } from \"@logtape/pretty\";\nimport { CachePresets, defineConfig } from \"sonamu\";\nimport { drivers as cacheDrivers, store } from \"sonamu/cache\";\n\nimport { monitLogSink } from \"./application/monit/log-buffer\";\nimport { QgridDispatcher } from \"./application/qgrid/qgrid.dispatcher\";\nimport { QgridFrame } from \"./application/qgrid/qgrid.frame\";\nimport { TokenSubscriber } from \"./application/qgrid/token-subscriber\";\nimport { ensureTokensTrigger } from \"./application/qgrid/token-trigger-setup\";\nimport { handleServerError } from \"./server-error-handler\";\nimport { AnthropicDispatcher } from \"./utils/providers/anthropic/anthropic-dispatcher\";\nimport { OpenAIDispatcher } from \"./utils/providers/openai/openai-dispatcher\";\n\nconst host = process.env.HOST ?? \"localhost\";\nconst port = Number(process.env.PORT ?? 44900);\n\nconst connConfig = {\n  host: process.env.SONAMU_DB_HOST ?? \"localhost\",\n  port: Number(process.env.SONAMU_DB_PORT ?? 5432),\n  user: process.env.SONAMU_DB_USER ?? \"postgres\",\n  password: process.env.SONAMU_DB_PASSWORD ?? \"postgres\",\n  database: process.env.SONAMU_DB_NAME ?? \"qgrid\",\n};\n\nexport default defineConfig({\n  projectName: process.env.PROJECT_NAME ?? \"Qgrid\",\n  database: {\n    defaultOptions: {\n      connection: {\n        ...connConfig,\n        keepAlive: true,\n        keepAliveInitialDelayMillis: 10000,\n      },\n    },\n  },\n  api: {\n    dir: \"api\",\n    timezone: \"Asia/Seoul\",\n    route: {\n      prefix: \"/api\",\n    },\n  },\n  i18n: {\n    defaultLocale: \"ko\",\n    supportedLocales: [\"ko\", \"en\"],\n  },\n  sync: {\n    targets: [\"web\"],\n  },\n  test: {\n    parallel: true,\n    maxWorkers: 4,\n    devRunner: { enabled: true },\n  },\n  logging: {\n    sinks: {\n      console: getConsoleSink({\n        formatter: getPrettyFormatter({\n          timestamp: \"time\",\n          categoryWidth: 20,\n          categoryTruncate: \"middle\",\n        }),\n      }),\n      // Monit 탭용 in-memory ring buffer. 포맷은 sink 별 — 콘솔 출력은 그대로다.\n      monit: monitLogSink,\n    },\n    loggers: [\n      // qgrid 로그 (요청 분배, oauth/usage API)\n      { category: [\"qgrid\"], sinks: [\"console\", \"monit\"], lowestLevel: \"info\" },\n      // sonamu 로그는 warning 이상만\n      { category: [\"sonamu\"], sinks: [\"console\", \"monit\"], lowestLevel: \"warning\" },\n      // fastify 로그 차단\n      { category: [\"fastify\"], sinks: [], lowestLevel: \"fatal\" },\n    ],\n  },\n  server: {\n    listen: { port, host },\n    fastify: {\n      bodyLimit: 10 * 1024 * 1024,\n    },\n    plugins: {\n      formbody: true,\n      qs: true,\n      sse: true,\n      multipart: { limits: { fileSize: 1024 * 1024 * 30 } },\n      static: {\n        root: path.join(import.meta.dirname, \"/../\", \"public\"),\n        prefix: \"/api/public\",\n      },\n      custom: (server) => {\n        // OAuth 콜백 — Anthropic이 /callback으로 리다이렉트\n        server.get(\"/callback\", async (request, reply) => {\n          const { code, state } = request.query as { code?: string; state?: string };\n          if (!code || !state) {\n            return reply.redirect(\"/?oauth=error&reason=missing_params\");\n          }\n          try {\n            return QgridFrame.handleOAuthCallback(code, state, reply);\n          } catch (e) {\n            return reply.redirect(\n              `/?oauth=error&reason=${encodeURIComponent((e as Error).message)}`,\n            );\n          }\n        });\n\n        // OpenAI OAuth 는 codex app-server 가 자체 callback 서버를 올림\n        // handleOpenAICallback 불필요 — oauthCompleteOpenAI API 로 완료 확인\n      },\n    },\n    apiConfig: {\n      contextProvider: (defaultContext, request) => {\n        return {\n          ...defaultContext,\n          ip: request.ip,\n          body: request.body,\n        };\n      },\n      guardHandler: () => {},\n      cacheControlHandler: (req) => {\n        switch (req.type) {\n          case \"assets\":\n            // Hash 포함된 파일: 영구 캐시\n            if (req.path.match(/-[a-f0-9]+\\./)) {\n              return CachePresets.immutable;\n            }\n            return CachePresets.longLived;\n\n          case \"api\":\n            // GET 요청만 캐싱 고려\n            if (req.method === \"GET\") {\n              // 특정 경로는 짧은 캐시\n              if (req.path.startsWith(\"/api/static-data\")) {\n                return CachePresets.shortLived;\n              }\n              if (req.path.startsWith(\"/api/terms\")) {\n                return CachePresets.mediumLived;\n              }\n            }\n            // 기본: 캐시 없음\n            return CachePresets.noCache;\n\n          case \"ssr\":\n            // SSR 페이지: 10초 캐시\n            return CachePresets.ssr;\n\n          case \"csr\":\n            // CSR fallback (index.html): 1분 캐시\n            return CachePresets.shortLived;\n        }\n        return CachePresets.noCache;\n      },\n    },\n    cache: {\n      default: \"main\",\n      stores: {\n        main: store().useL1Layer(cacheDrivers.memory({ maxSize: \"50mb\" })),\n      },\n      ttl: \"5m\",\n      prefix: \"\",\n    },\n    lifecycle: {\n      onStart: async () => {\n        const log = getLogger([\"qgrid\", \"startup\"]);\n\n        let triggerReady = true;\n        try {\n          await ensureTokensTrigger(connConfig);\n        } catch (e) {\n          triggerReady = false;\n          log.warn(`trigger setup failed: ${(e as Error).message}`);\n        }\n\n        const subscriber = new TokenSubscriber(connConfig, QgridDispatcher);\n        QgridDispatcher.subscriber = subscriber;\n\n        const started = await subscriber.start();\n\n        // 기동 상태를 남긴다 — HTTP 는 이미 열려 있어서, 준비 전 요청이 \"잠시 후 되는지\"\n        // \"재시도해도 안 되는지\"를 구분해 응답해야 한다(503 vs 500).\n        try {\n          const openaiDispatcher = new OpenAIDispatcher();\n          await openaiDispatcher.start();\n          QgridDispatcher.openaiDispatcher = openaiDispatcher;\n          QgridDispatcher.startupState.openai = \"ready\";\n        } catch (e) {\n          QgridDispatcher.startupState.openai = \"failed\";\n          log.warn(`openai dispatcher failed: ${(e as Error).message}`);\n        }\n\n        try {\n          const anthropicDispatcher = new AnthropicDispatcher();\n          await anthropicDispatcher.start();\n          QgridDispatcher.anthropicDispatcher = anthropicDispatcher;\n          QgridDispatcher.startupState.anthropic = \"ready\";\n        } catch (e) {\n          QgridDispatcher.startupState.anthropic = \"failed\";\n          log.warn(`anthropic dispatcher failed: ${(e as Error).message}`);\n        }\n\n        const anthropicCount = QgridDispatcher.anthropicDispatcher?.tokenCount ?? 0;\n        const openaiReady = QgridDispatcher.openaiDispatcher?.readyWorkerCount ?? 0;\n        const openaiTotal = QgridDispatcher.openaiDispatcher?.workerCount ?? 0;\n\n        log.info(`listening on http://${host}:${port}`);\n        log.info(`anthropic: ${anthropicCount} tokens ready`);\n        log.info(`openai: ${openaiReady}/${openaiTotal} tokens ready`);\n        log.info(\n          `subscriber: ${started ? \"LISTEN active\" : \"degraded\"}${triggerReady ? \"\" : \", trigger failed\"}`,\n        );\n      },\n      onShutdown: async () => {\n        const log = getLogger([\"qgrid\", \"startup\"]);\n        if (QgridDispatcher.openaiDispatcher) {\n          await QgridDispatcher.openaiDispatcher.stop();\n        }\n        if (QgridDispatcher.anthropicDispatcher) {\n          await QgridDispatcher.anthropicDispatcher.stop();\n        }\n        if (QgridDispatcher.subscriber) {\n          await QgridDispatcher.subscriber.stop();\n        }\n        log.info(\"graceful shutdown\");\n      },\n      onError: (error, _request, reply) => {\n        handleServerError(error, reply);\n      },\n    },\n  },\n});\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"sonamu.config.js","names":["cacheDrivers"],"sources":["../src/sonamu.config.ts"],"sourcesContent":["import path from \"path\";\n\nimport { getConsoleSink } from \"@logtape/logtape\";\nimport { getLogger } from \"@logtape/logtape\";\nimport { getPrettyFormatter } from \"@logtape/pretty\";\nimport { CachePresets, defineConfig } from \"sonamu\";\nimport { drivers as cacheDrivers, store } from \"sonamu/cache\";\n\nimport { monitLogSink } from \"./application/monit/log-buffer\";\nimport {\n  startExpiredTokenReminder,\n  stopExpiredTokenReminder,\n} from \"./application/qgrid/expired-token-reminder\";\nimport { QgridDispatcher } from \"./application/qgrid/qgrid.dispatcher\";\nimport { QgridFrame } from \"./application/qgrid/qgrid.frame\";\nimport { TokenSubscriber } from \"./application/qgrid/token-subscriber\";\nimport { ensureTokensTrigger } from \"./application/qgrid/token-trigger-setup\";\nimport { handleServerError } from \"./server-error-handler\";\nimport { AnthropicDispatcher } from \"./utils/providers/anthropic/anthropic-dispatcher\";\nimport { OpenAIDispatcher } from \"./utils/providers/openai/openai-dispatcher\";\n\nconst host = process.env.HOST ?? \"localhost\";\nconst port = Number(process.env.PORT ?? 44900);\n\nconst connConfig = {\n  host: process.env.SONAMU_DB_HOST ?? \"localhost\",\n  port: Number(process.env.SONAMU_DB_PORT ?? 5432),\n  user: process.env.SONAMU_DB_USER ?? \"postgres\",\n  password: process.env.SONAMU_DB_PASSWORD ?? \"postgres\",\n  database: process.env.SONAMU_DB_NAME ?? \"qgrid\",\n};\n\nexport default defineConfig({\n  projectName: process.env.PROJECT_NAME ?? \"Qgrid\",\n  database: {\n    defaultOptions: {\n      connection: {\n        ...connConfig,\n        keepAlive: true,\n        keepAliveInitialDelayMillis: 10000,\n      },\n    },\n  },\n  api: {\n    dir: \"api\",\n    timezone: \"Asia/Seoul\",\n    route: {\n      prefix: \"/api\",\n    },\n  },\n  i18n: {\n    defaultLocale: \"ko\",\n    supportedLocales: [\"ko\", \"en\"],\n  },\n  sync: {\n    targets: [\"web\"],\n  },\n  test: {\n    parallel: true,\n    maxWorkers: 4,\n    devRunner: { enabled: true },\n  },\n  logging: {\n    sinks: {\n      console: getConsoleSink({\n        formatter: getPrettyFormatter({\n          timestamp: \"time\",\n          categoryWidth: 20,\n          categoryTruncate: \"middle\",\n        }),\n      }),\n      // Monit 탭용 in-memory ring buffer. 포맷은 sink 별 — 콘솔 출력은 그대로다.\n      monit: monitLogSink,\n    },\n    loggers: [\n      // qgrid 로그 (요청 분배, oauth/usage API)\n      { category: [\"qgrid\"], sinks: [\"console\", \"monit\"], lowestLevel: \"info\" },\n      // sonamu 로그는 warning 이상만\n      { category: [\"sonamu\"], sinks: [\"console\", \"monit\"], lowestLevel: \"warning\" },\n      // fastify 로그 차단\n      { category: [\"fastify\"], sinks: [], lowestLevel: \"fatal\" },\n    ],\n  },\n  server: {\n    listen: { port, host },\n    fastify: {\n      bodyLimit: 10 * 1024 * 1024,\n    },\n    plugins: {\n      formbody: true,\n      qs: true,\n      sse: true,\n      multipart: { limits: { fileSize: 1024 * 1024 * 30 } },\n      static: {\n        root: path.join(import.meta.dirname, \"/../\", \"public\"),\n        prefix: \"/api/public\",\n      },\n      custom: (server) => {\n        // OAuth 콜백 — Anthropic이 /callback으로 리다이렉트\n        server.get(\"/callback\", async (request, reply) => {\n          const { code, state } = request.query as { code?: string; state?: string };\n          if (!code || !state) {\n            return reply.redirect(\"/?oauth=error&reason=missing_params\");\n          }\n          try {\n            return QgridFrame.handleOAuthCallback(code, state, reply);\n          } catch (e) {\n            return reply.redirect(\n              `/?oauth=error&reason=${encodeURIComponent((e as Error).message)}`,\n            );\n          }\n        });\n\n        // OpenAI OAuth 는 codex app-server 가 자체 callback 서버를 올림\n        // handleOpenAICallback 불필요 — oauthCompleteOpenAI API 로 완료 확인\n      },\n    },\n    apiConfig: {\n      contextProvider: (defaultContext, request) => {\n        return {\n          ...defaultContext,\n          ip: request.ip,\n          body: request.body,\n        };\n      },\n      guardHandler: () => {},\n      cacheControlHandler: (req) => {\n        switch (req.type) {\n          case \"assets\":\n            // Hash 포함된 파일: 영구 캐시\n            if (req.path.match(/-[a-f0-9]+\\./)) {\n              return CachePresets.immutable;\n            }\n            return CachePresets.longLived;\n\n          case \"api\":\n            // GET 요청만 캐싱 고려\n            if (req.method === \"GET\") {\n              // 특정 경로는 짧은 캐시\n              if (req.path.startsWith(\"/api/static-data\")) {\n                return CachePresets.shortLived;\n              }\n              if (req.path.startsWith(\"/api/terms\")) {\n                return CachePresets.mediumLived;\n              }\n            }\n            // 기본: 캐시 없음\n            return CachePresets.noCache;\n\n          case \"ssr\":\n            // SSR 페이지: 10초 캐시\n            return CachePresets.ssr;\n\n          case \"csr\":\n            // CSR fallback (index.html): 1분 캐시\n            return CachePresets.shortLived;\n        }\n        return CachePresets.noCache;\n      },\n    },\n    cache: {\n      default: \"main\",\n      stores: {\n        main: store().useL1Layer(cacheDrivers.memory({ maxSize: \"50mb\" })),\n      },\n      ttl: \"5m\",\n      prefix: \"\",\n    },\n    lifecycle: {\n      onStart: async () => {\n        const log = getLogger([\"qgrid\", \"startup\"]);\n\n        let triggerReady = true;\n        try {\n          await ensureTokensTrigger(connConfig);\n        } catch (e) {\n          triggerReady = false;\n          log.warn(`trigger setup failed: ${(e as Error).message}`);\n        }\n\n        const subscriber = new TokenSubscriber(connConfig, QgridDispatcher);\n        QgridDispatcher.subscriber = subscriber;\n\n        const started = await subscriber.start();\n\n        // 기동 상태를 남긴다 — HTTP 는 이미 열려 있어서, 준비 전 요청이 \"잠시 후 되는지\"\n        // \"재시도해도 안 되는지\"를 구분해 응답해야 한다(503 vs 500).\n        try {\n          const openaiDispatcher = new OpenAIDispatcher();\n          await openaiDispatcher.start();\n          QgridDispatcher.openaiDispatcher = openaiDispatcher;\n          QgridDispatcher.startupState.openai = \"ready\";\n        } catch (e) {\n          QgridDispatcher.startupState.openai = \"failed\";\n          log.warn(`openai dispatcher failed: ${(e as Error).message}`);\n        }\n\n        try {\n          const anthropicDispatcher = new AnthropicDispatcher();\n          await anthropicDispatcher.start();\n          QgridDispatcher.anthropicDispatcher = anthropicDispatcher;\n          QgridDispatcher.startupState.anthropic = \"ready\";\n        } catch (e) {\n          QgridDispatcher.startupState.anthropic = \"failed\";\n          log.warn(`anthropic dispatcher failed: ${(e as Error).message}`);\n        }\n\n        startExpiredTokenReminder();\n\n        const anthropicCount = QgridDispatcher.anthropicDispatcher?.tokenCount ?? 0;\n        const openaiReady = QgridDispatcher.openaiDispatcher?.readyWorkerCount ?? 0;\n        const openaiTotal = QgridDispatcher.openaiDispatcher?.workerCount ?? 0;\n\n        log.info(`listening on http://${host}:${port}`);\n        log.info(`anthropic: ${anthropicCount} tokens ready`);\n        log.info(`openai: ${openaiReady}/${openaiTotal} tokens ready`);\n        log.info(\n          `subscriber: ${started ? \"LISTEN active\" : \"degraded\"}${triggerReady ? \"\" : \", trigger failed\"}`,\n        );\n      },\n      onShutdown: async () => {\n        const log = getLogger([\"qgrid\", \"startup\"]);\n        stopExpiredTokenReminder();\n        if (QgridDispatcher.openaiDispatcher) {\n          await QgridDispatcher.openaiDispatcher.stop();\n        }\n        if (QgridDispatcher.anthropicDispatcher) {\n          await QgridDispatcher.anthropicDispatcher.stop();\n        }\n        if (QgridDispatcher.subscriber) {\n          await QgridDispatcher.subscriber.stop();\n        }\n        log.info(\"graceful shutdown\");\n      },\n      onError: (error, _request, reply) => {\n        handleServerError(error, reply);\n      },\n    },\n  },\n});\n"],"mappings":"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"}

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

@@ -45,8 +45,8 @@ async function notifySlack(notification) {
 			},
 			body: JSON.stringify({
 				channel,
-				text: subject ? `${title} — ${subject}` : title,
 				attachments: [{
+					fallback: subject ? `${title} — ${subject}` : title,
 					...color ? { color } : {},
 					blocks
 				}]
@@ -62,4 +62,4 @@ async function notifySlack(notification) {
 //#endregion
 export { SLACK_COLOR, notifySlack };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -0,0 +1,53 @@
+import { describe, expect, it } from "vitest";
+
+import { buildReminderContext } from "./expired-token-reminder";
+
+const userMap = new Map([
+  ["yds", "U09NAJUQSFQ"],
+  ["haze", "U09N96NHZB7"],
+]);
+
+describe("buildReminderContext", () => {
+  it("매핑된 토큰은 멘션으로 개인에게 꽂는다", () => {
+    const text = buildReminderContext([{ name: "anthropic/yds", provider: "anthropic" }], userMap);
+
+    expect(text).toBe("<@U09NAJUQSFQ> anthropic/yds");
+  });
+
+  it("공용 계정처럼 매핑이 없으면 멘션 없이 이름만 남긴다", () => {
+    const text = buildReminderContext(
+      [{ name: "anthropic/dev-common", provider: "anthropic" }],
+      userMap,
+    );
+
+    expect(text).toBe("anthropic/dev-common");
+  });
+
+  it("같은 사람의 provider 별 토큰을 각각 구분해 보여준다", () => {
+    const text = buildReminderContext(
+      [
+        { name: "anthropic/yds", provider: "anthropic" },
+        { name: "openai/yds", provider: "openai" },
+      ],
+      userMap,
+    );
+
+    // 멘션만 두 번 나오면 어느 토큰인지 알 수 없다 — 토큰명이 함께 있어야 한다.
+    expect(text.split("\n")).toEqual([
+      "<@U09NAJUQSFQ> anthropic/yds",
+      "<@U09NAJUQSFQ> openai/yds",
+    ]);
+  });
+
+  it("provider prefix 없이 저장된 이름도 매핑한다", () => {
+    const text = buildReminderContext([{ name: "haze", provider: "anthropic" }], userMap);
+
+    expect(text).toBe("<@U09N96NHZB7> haze");
+  });
+
+  it("이름이 없는 토큰도 줄을 잃지 않는다", () => {
+    const text = buildReminderContext([{ name: null, provider: "openai" }], userMap);
+
+    expect(text).toBe("unnamed");
+  });
+});