@cartanova/qgrid-cli 2.6.5 → 2.6.6

package/README.ko.md

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

package/README.md

@@ -93,7 +93,7 @@ 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_DIGEST_INTERVAL_MINUTES` | — (unset disables inactive-token reminders) |
+| `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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXhwaXJlZC10b2tlbi1yZW1pbmRlci5qcyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYXBwbGljYXRpb24vcWdyaWQvZXhwaXJlZC10b2tlbi1yZW1pbmRlci50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIOyEuOyFmCDrp4zro4wg7JWM66a8IOuwmOuztS5cbiAqXG4gKiDrp4zro4wg7Iic6rCE7J2YIOyVjOumvChgdG9rZW4tZGVhdGgudHNgKeydgCDqt7jrlYwg7LGE64SQ7J2EIOuztOyngCDslYrsnLzrqbQg64aT7Lmc64ukLiDsnqzroZzqt7jsnbjsnYAg7IKs656M7J20XG4gKiDtlbTslbwg7ZWY64qUIOydvOydtOudvCDrhpPsuZjrqbQg7Yag7YGw7J20IOqzhOyGjSDruaDsp4Qg7LGE66GcIOuCqOuKlOuLpC4g6re4656Y7IScIOyVhOyngSDsnqzroZzqt7jsnbjrkJjsp4Ag7JWK7J2AXG4gKiDthqDtgbDsnYQg6rCZ7J2AIOusuOq1rOuhnCDri6Tsi5wg7JWM66aw64ukIOKAlCDsgqzqsbTsnbQg7ZWY64KY7J2066+A66GcIOyVjOumvOuPhCDtlZwg7KKF66WY64ukLlxuICpcbiAqIOyXrOufrCDthqDtgbDsnbQg66eM66OM64+8IOyeiOycvOuptCDtlZwg66mU7Iuc7KeA7JeQIOuqqOydgOuLpC4g7Yag7YGw66eI64ukIOuplOyLnOyngOulvCDrs7TrgrTrqbQg7LGE64SQ7J20IOyLnOuBhOufrOybjFxuICog7KCV7J6RIOydve2eiOyngCDslYrripTri6QuXG4gKlxuICog67mE7Zmc7ISxIO2GoO2BsOydtCDsl4bsnLzrqbQg67O064K07KeAIOyViuuKlOuLpCDigJQgXCLsnbTsg4Eg7JeG7J2MXCLsnYQg7KO86riw7KCB7Jy866GcIOyVjOumrOuptCDssYTrhJDsnbQg66y0646M7KeE64ukLlxuICovXG5pbXBvcnQgeyBnZXRMb2dnZXIgfSBmcm9tIFwiQGxvZ3RhcGUvbG9ndGFwZVwiO1xuXG5pbXBvcnQgeyBub3RpZnlTbGFjaywgU0xBQ0tfQ09MT1IgfSBmcm9tIFwiLi4vLi4vdXRpbHMvc2xhY2stbm90aWZ5XCI7XG5pbXBvcnQgeyBUb2tlbk1vZGVsIH0gZnJvbSBcIi4uL3Rva2VuL3Rva2VuLm1vZGVsXCI7XG5pbXBvcnQgeyBnZXRTbGFja1VzZXJNYXAsIG1lbnRpb25Gb3IgfSBmcm9tIFwiLi9zbGFjay11c2VyLW1hcFwiO1xuXG5jb25zdCBsb2dnZXIgPSBnZXRMb2dnZXIoW1wicWdyaWRcIiwgXCJleHBpcmVkLXJlbWluZGVyXCJdKTtcblxuY29uc3QgTUlOVVRFX01TID0gNjBfMDAwO1xuXG5leHBvcnQgZnVuY3Rpb24gYnVpbGRSZW1pbmRlckNvbnRleHQoXG4gIHRva2VuczogeyBuYW1lOiBzdHJpbmcgfCBudWxsOyBwcm92aWRlcjogc3RyaW5nIH1bXSxcbiAgdXNlck1hcDogTWFwPHN0cmluZywgc3RyaW5nPixcbik6IHN0cmluZyB7XG4gIHJldHVybiB0b2tlbnNcbiAgICAubWFwKCh0b2tlbikgPT4ge1xuICAgICAgY29uc3QgbWVudGlvbiA9IG1lbnRpb25Gb3IodG9rZW4ubmFtZSwgdXNlck1hcCk7XG4gICAgICBjb25zdCBsYWJlbCA9IHRva2VuLm5hbWUgPz8gXCJ1bm5hbWVkXCI7XG4gICAgICAvLyDrqZjshZjsnbQg7J6I7Ja064+EIOyWtOuWpCDthqDtgbDsnbjsp4DripQg64Ko6ri064ukIOKAlCDtlZwg7IKs656M7J20IHByb3ZpZGVyIOuzhOuhnCDsl6zrn6wg6rCc66W8IOqwgOynhOuLpC5cbiAgICAgIHJldHVybiBtZW50aW9uID8gYCR7bWVudGlvbn0gJHtsYWJlbH1gIDogbGFiZWw7XG4gICAgfSlcbiAgICAuam9pbihcIlxcblwiKTtcbn1cblxuYXN5bmMgZnVuY3Rpb24gc2VuZFJlbWluZGVyKHVzZXJNYXA6IE1hcDxzdHJpbmcsIHN0cmluZz4pOiBQcm9taXNlPHZvaWQ+IHtcbiAgY29uc3QgaW5hY3RpdmUgPSBhd2FpdCBUb2tlbk1vZGVsLmZpbmRJbmFjdGl2ZShcIkFcIik7XG4gIGlmIChpbmFjdGl2ZS5sZW5ndGggPT09IDApIHJldHVybjtcblxuICBhd2FpdCBub3RpZnlTbGFjayh7XG4gICAgLy8g66eM66OMIOyInOqwhCDslYzrprzqs7wg6rCZ7J2AIOygnOuqqeydhCDsk7Tri6QuIOqwmeydgCDsgqzqsbTsnbTrr4DroZwg64uk66W4IOydtOumhOydhCDrtpnsnbTrqbQg67OE6rCcIOusuOygnOuhnCDsnb3tnozri6QuXG4gICAgdGl0bGU6IFwi7IS47IWYIOunjOujjFwiLFxuICAgIHN1YmplY3Q6IGluYWN0aXZlLmxlbmd0aCA+IDEgPyBgJHtpbmFjdGl2ZS5sZW5ndGh96rG0YCA6IChpbmFjdGl2ZVswXSEubmFtZSA/PyBcInVubmFtZWRcIiksXG4gICAgY29udGV4dDogYCR7YnVpbGRSZW1pbmRlckNvbnRleHQoaW5hY3RpdmUsIHVzZXJNYXApfVxcbuyerOuhnOq3uOyduOydtCDtlYTsmpTtlanri4jri6RgLFxuICAgIGNvbG9yOiBTTEFDS19DT0xPUi5iYWQsXG4gIH0pO1xufVxuXG5sZXQgdGltZXI6IFJldHVyblR5cGU8dHlwZW9mIHNldEludGVydmFsPiB8IG51bGwgPSBudWxsO1xuXG4vKipcbiAqIGBTTEFDS19FWFBJUllfUkVNSU5ERVJfSU5URVJWQUxfTUlOVVRFU2Ag6rCAIOyWkeyImOydvCDrlYzrp4wg7Lyc7KeE64ukLiDrr7jshKTsoJXCtzAg7J2066m0IOu5hO2ZnOyEsS5cbiAqXG4gKiDsnbjsiqTthLTsiqTqsIAg7Jes65+sIOqwnOuptCDqsIHsnpAg67O064K464ukLiDrp4zro4wg7Iic6rCEIOyVjOumvOqzvCDri6zrpqwg7IOB7YOcIOuzgO2ZlOqwgCDsl4bslrQgREIg66GcIOyWteygnO2VoCDsiJhcbiAqIOyXhuqzoCwg7ZWY66OoIOuqhyDqsbQg7IiY7KSA7J206528IOykkeuzteydhCDqsJDsiJjtlZjripQg7Y647J20IOyeoOq4iCDsnqXsuZjrpbwg65GQ64qUIOqyg+uztOuLpCDrgqvri6QuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBzdGFydEV4cGlyZWRUb2tlblJlbWluZGVyKCk6IHZvaWQge1xuICBjb25zdCBtaW51dGVzID0gTnVtYmVyKHByb2Nlc3MuZW52LlNMQUNLX0VYUElSWV9SRU1JTkRFUl9JTlRFUlZBTF9NSU5VVEVTID8/IDApO1xuICBpZiAoIU51bWJlci5pc0Zpbml0ZShtaW51dGVzKSB8fCBtaW51dGVzIDw9IDApIHJldHVybjtcblxuICBjb25zdCB1c2VyTWFwID0gZ2V0U2xhY2tVc2VyTWFwKCk7XG4gIGxvZ2dlci5pbmZvKGBleHBpcmVkIHRva2VuIHJlbWluZGVyIGV2ZXJ5ICR7bWludXRlc31tICgke3VzZXJNYXAuc2l6ZX0gdXNlciBtYXBwaW5ncylgKTtcblxuICB0aW1lciA9IHNldEludGVydmFsKCgpID0+IHtcbiAgICBzZW5kUmVtaW5kZXIodXNlck1hcCkuY2F0Y2goKGUpID0+IGxvZ2dlci53YXJuKGByZW1pbmRlciBmYWlsZWQ6ICR7KGUgYXMgRXJyb3IpLm1lc3NhZ2V9YCkpO1xuICB9LCBtaW51dGVzICogTUlOVVRFX01TKTtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIHN0b3BFeHBpcmVkVG9rZW5SZW1pbmRlcigpOiB2b2lkIHtcbiAgaWYgKCF0aW1lcikgcmV0dXJuO1xuICBjbGVhckludGVydmFsKHRpbWVyKTtcbiAgdGltZXIgPSBudWxsO1xufVxuIl0sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7OztBQWtCQSxNQUFNLFNBQVMsVUFBVSxDQUFDLFNBQVMsa0JBQWtCLENBQUM7QUFFdEQsTUFBTSxZQUFZO0FBRWxCLFNBQWdCLHFCQUNkLFFBQ0EsU0FDUTtDQUNSLE9BQU8sT0FDSixLQUFLLFVBQVU7RUFDZCxNQUFNLFVBQVUsV0FBVyxNQUFNLE1BQU0sT0FBTztFQUM5QyxNQUFNLFFBQVEsTUFBTSxRQUFRO0VBRTVCLE9BQU8sVUFBVSxHQUFHLFFBQVEsR0FBRyxVQUFVO0NBQzNDLENBQUMsQ0FBQyxDQUNELEtBQUssSUFBSTtBQUNkO0FBRUEsZUFBZSxhQUFhLFNBQTZDO0NBQ3ZFLE1BQU0sV0FBVyxNQUFNLFdBQVcsYUFBYSxHQUFHO0NBQ2xELElBQUksU0FBUyxXQUFXLEdBQUc7Q0FFM0IsTUFBTSxZQUFZO0VBRWhCLE9BQU87RUFDUCxTQUFTLFNBQVMsU0FBUyxJQUFJLEdBQUcsU0FBUyxPQUFPLEtBQU0sU0FBUyxFQUFFLENBQUUsUUFBUTtFQUM3RSxTQUFTLEdBQUcscUJBQXFCLFVBQVUsT0FBTyxFQUFFO0VBQ3BELE9BQU8sWUFBWTtDQUNyQixDQUFDO0FBQ0g7QUFFQSxJQUFJLFFBQStDOzs7Ozs7O0FBUW5ELFNBQWdCLDRCQUFrQztDQUNoRCxNQUFNLFVBQVUsT0FBTyxRQUFRLElBQUksMENBQTBDLENBQUM7Q0FDOUUsSUFBSSxDQUFDLE9BQU8sU0FBUyxPQUFPLEtBQUssV0FBVyxHQUFHO0NBRS9DLE1BQU0sVUFBVSxnQkFBZ0I7Q0FDaEMsT0FBTyxLQUFLLGdDQUFnQyxRQUFRLEtBQUssUUFBUSxLQUFLLGdCQUFnQjtDQUV0RixRQUFRLGtCQUFrQjtFQUN4QixhQUFhLE9BQU8sQ0FBQyxDQUFDLE9BQU8sTUFBTSxPQUFPLEtBQUssb0JBQXFCLEVBQVksU0FBUyxDQUFDO0NBQzVGLEdBQUcsVUFBVSxTQUFTO0FBQ3hCO0FBRUEsU0FBZ0IsMkJBQWlDO0NBQy9DLElBQUksQ0FBQyxPQUFPO0NBQ1osY0FBYyxLQUFLO0NBQ25CLFFBQVE7QUFDViJ9

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 { 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,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
+//# 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/sonamu.config.js

@@ -1,6 +1,6 @@
 import { monitLogSink } from "./application/monit/log-buffer.js";
 import { QgridDispatcher } from "./application/qgrid/qgrid.dispatcher.js";
-import { startExpiredTokenDigest, stopExpiredTokenDigest } from "./application/qgrid/expired-token-digest.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";
@@ -161,7 +161,7 @@ var sonamu_config_default = defineConfig({
 					QgridDispatcher.startupState.anthropic = "failed";
 					log.warn(`anthropic dispatcher failed: ${e.message}`);
 				}
-				startExpiredTokenDigest();
+				startExpiredTokenReminder();
 				const anthropicCount = QgridDispatcher.anthropicDispatcher?.tokenCount ?? 0;
 				const openaiReady = QgridDispatcher.openaiDispatcher?.readyWorkerCount ?? 0;
 				const openaiTotal = QgridDispatcher.openaiDispatcher?.workerCount ?? 0;
@@ -172,7 +172,7 @@ var sonamu_config_default = defineConfig({
 			},
 			onShutdown: async () => {
 				const log = getLogger(["qgrid", "startup"]);
-				stopExpiredTokenDigest();
+				stopExpiredTokenReminder();
 				if (QgridDispatcher.openaiDispatcher) await QgridDispatcher.openaiDispatcher.stop();
 				if (QgridDispatcher.anthropicDispatcher) await QgridDispatcher.anthropicDispatcher.stop();
 				if (QgridDispatcher.subscriber) await QgridDispatcher.subscriber.stop();
@@ -187,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 {\n  startExpiredTokenDigest,\n  stopExpiredTokenDigest,\n} from \"./application/qgrid/expired-token-digest\";\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        startExpiredTokenDigest();\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        stopExpiredTokenDigest();\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/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");
+  });
+});

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

@@ -0,0 +1,74 @@
+/**
+ * 세션 만료 알림 반복.
+ *
+ * 만료 순간의 알림(`token-death.ts`)은 그때 채널을 보지 않으면 놓친다. 재로그인은 사람이
+ * 해야 하는 일이라 놓치면 토큰이 계속 빠진 채로 남는다. 그래서 아직 재로그인되지 않은
+ * 토큰을 같은 문구로 다시 알린다 — 사건이 하나이므로 알림도 한 종류다.
+ *
+ * 여러 토큰이 만료돼 있으면 한 메시지에 모은다. 토큰마다 메시지를 보내면 채널이 시끄러워
+ * 정작 읽히지 않는다.
+ *
+ * 비활성 토큰이 없으면 보내지 않는다 — "이상 없음"을 주기적으로 알리면 채널이 무뎌진다.
+ */
+import { getLogger } from "@logtape/logtape";
+
+import { notifySlack, SLACK_COLOR } from "../../utils/slack-notify";
+import { TokenModel } from "../token/token.model";
+import { getSlackUserMap, mentionFor } from "./slack-user-map";
+
+const logger = getLogger(["qgrid", "expired-reminder"]);
+
+const MINUTE_MS = 60_000;
+
+export function buildReminderContext(
+  tokens: { name: string | null; provider: string }[],
+  userMap: Map<string, string>,
+): string {
+  return tokens
+    .map((token) => {
+      const mention = mentionFor(token.name, userMap);
+      const label = token.name ?? "unnamed";
+      // 멘션이 있어도 어떤 토큰인지는 남긴다 — 한 사람이 provider 별로 여러 개를 가진다.
+      return mention ? `${mention} ${label}` : label;
+    })
+    .join("\n");
+}
+
+async function sendReminder(userMap: Map<string, string>): Promise<void> {
+  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: ReturnType<typeof setInterval> | null = null;
+
+/**
+ * `SLACK_EXPIRY_REMINDER_INTERVAL_MINUTES` 가 양수일 때만 켜진다. 미설정·0 이면 비활성.
+ *
+ * 인스턴스가 여러 개면 각자 보낸다. 만료 순간 알림과 달리 상태 변화가 없어 DB 로 억제할 수
+ * 없고, 하루 몇 건 수준이라 중복을 감수하는 편이 잠금 장치를 두는 것보다 낫다.
+ */
+export function startExpiredTokenReminder(): void {
+  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 as Error).message}`));
+  }, minutes * MINUTE_MS);
+}
+
+export function stopExpiredTokenReminder(): void {
+  if (!timer) return;
+  clearInterval(timer);
+  timer = null;
+}

package/bundle/src/application/qgrid/slack-user-map.ts

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

package/bundle/src/application/qgrid/token-death.ts

@@ -10,6 +10,7 @@ import { getLogger } from "@logtape/logtape";
 import { getRefreshToken } from "../../utils/providers/common/credentials";
 import { notifySlack, SLACK_COLOR } from "../../utils/slack-notify";
 import { TokenModel } from "../token/token.model";
+import { getSlackUserMap, mentionFor } from "./slack-user-map";
 
 const logger = getLogger(["qgrid", "token-death"]);
 
@@ -49,10 +50,15 @@ export async function deactivateAuthDeadToken(
   }
 
   logger.warn(`token deactivated (auth dead): ${token.name}(id=${token.id}) reason=${reasonCode}`);
+  // 만료 직후가 재로그인하기 가장 좋은 타이밍이다. 소유자를 멘션해 그 순간 당사자에게
+  // 꽂는다 — 다이제스트를 기다리면 다음 주기까지 토큰이 빠진 채로 남는다.
+  const mention = mentionFor(token.name, getSlackUserMap());
   void notifySlack({
     title: "세션 만료",
     subject: token.name,
-    context: `${token.provider} · ${reasonCode} · 재로그인이 필요합니다`,
+    context: [mention, token.provider, reasonCode, "재로그인이 필요합니다"]
+      .filter(Boolean)
+      .join(" · "),
     color: SLACK_COLOR.bad,
   });
   return true;
@@ -74,11 +80,13 @@ function notifyLastActiveTokenDying(token: DeadTokenRef, reasonCode: string): vo
   if (previous !== undefined && now - previous < LAST_ACTIVE_ALERT_COOLDOWN_MS) return;
   lastActiveAlertAt.set(token.provider, now);
 
+  const mention = mentionFor(token.name, getSlackUserMap());
   void notifySlack({
     title: "마지막 토큰 사망",
     subject: token.name,
     context:
-      `${token.provider} · ${reasonCode} · 풀이 비지 않도록 유지 중입니다. ` +
+      [mention, token.provider, reasonCode].filter(Boolean).join(" · ") +
+      ` · 풀이 비지 않도록 유지 중입니다. ` +
       `전 토큰이 동시에 실패했다면 client_id 취소나 OAuth 계약 변경을 의심하세요`,
     color: SLACK_COLOR.bad,
   });
@@ -87,10 +95,11 @@ function notifyLastActiveTokenDying(token: DeadTokenRef, reasonCode: string): vo
 /** 로그인이 완료돼 토큰이 저장됐을 때. 신규·재로그인을 가리지 않는다. */
 export function notifyTokenAdded(name: string, provider: string): void {
   logger.info(`token added: ${name} (${provider})`);
+  const mention = mentionFor(name, getSlackUserMap());
   void notifySlack({
     title: "토큰 추가",
     subject: name,
-    context: `${provider} · 요청 처리에 사용됩니다`,
+    context: [mention, provider, "요청 처리에 사용됩니다"].filter(Boolean).join(" · "),
     color: SLACK_COLOR.good,
   });
 }

package/bundle/src/sonamu.config.ts

@@ -8,9 +8,9 @@ import { drivers as cacheDrivers, store } from "sonamu/cache";
 
 import { monitLogSink } from "./application/monit/log-buffer";
 import {
-  startExpiredTokenDigest,
-  stopExpiredTokenDigest,
-} from "./application/qgrid/expired-token-digest";
+  startExpiredTokenReminder,
+  stopExpiredTokenReminder,
+} from "./application/qgrid/expired-token-reminder";
 import { QgridDispatcher } from "./application/qgrid/qgrid.dispatcher";
 import { QgridFrame } from "./application/qgrid/qgrid.frame";
 import { TokenSubscriber } from "./application/qgrid/token-subscriber";
@@ -205,7 +205,7 @@ export default defineConfig({
           log.warn(`anthropic dispatcher failed: ${(e as Error).message}`);
         }
 
-        startExpiredTokenDigest();
+        startExpiredTokenReminder();
 
         const anthropicCount = QgridDispatcher.anthropicDispatcher?.tokenCount ?? 0;
         const openaiReady = QgridDispatcher.openaiDispatcher?.readyWorkerCount ?? 0;
@@ -220,7 +220,7 @@ export default defineConfig({
       },
       onShutdown: async () => {
         const log = getLogger(["qgrid", "startup"]);
-        stopExpiredTokenDigest();
+        stopExpiredTokenReminder();
         if (QgridDispatcher.openaiDispatcher) {
           await QgridDispatcher.openaiDispatcher.stop();
         }