@cartanova/qgrid-cli 2.6.4 → 2.6.5

package/README.ko.md

@@ -92,6 +92,8 @@ CLI는 실행 시 npm의 최신 버전을 확인하고 patch를 포함해 설치
 | `QGRID_DB_NAME` | `qgrid` |
 | `SLACK_BOT_TOKEN` | — (미설정 시 토큰 만료 알림 비활성) |
 | `SLACK_CHANNEL_ID` | — |
+| `SLACK_EXPIRY_DIGEST_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_DIGEST_INTERVAL_MINUTES` | — (unset disables inactive-token reminders) |
+| `SLACK_USER_MAP` | — (`tokenName:SlackUserId` pairs) |
 
 Server behavior variables:
 

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

@@ -0,0 +1,78 @@
+import { SLACK_COLOR, notifySlack } from "../../utils/slack-notify.js";
+import { TokenModel } from "../token/token.model.js";
+import { getLogger } from "@logtape/logtape";
+//#region src/application/qgrid/expired-token-digest.ts
+/**
+* 비활성 토큰 주기 알림.
+*
+* 사망 순간의 단발 알림(`token-death.ts`)은 그 시점에 채널을 보지 않으면 놓친다. 재로그인은
+* 사람이 해야 하는 일이라 놓치면 토큰이 계속 빠진 채로 남는다. 그래서 남아 있는 비활성
+* 토큰을 주기적으로 다시 알리고, 소유자를 멘션해 개인에게 꽂는다.
+*
+* 비활성 토큰이 없으면 보내지 않는다 — "이상 없음"을 주기적으로 알리면 채널이 무뎌진다.
+*/
+const logger = getLogger(["qgrid", "expired-digest"]);
+const MINUTE_MS = 6e4;
+/**
+* `토큰명:SlackUserId` 목록. 공용 계정(bysuco, dev-common 등)은 넣지 않는다 — 매핑이 없으면
+* 멘션 없이 이름만 나가고, 그게 맞는 동작이다.
+*
+* Slack 표시 이름과 토큰명이 자주 어긋나(haze→haze.lee, byeongjun→potados) 자동 매칭은
+* 조용히 실패한다. 멘션이 빠지면 알림의 목적 자체가 사라지므로 명시 매핑만 쓴다.
+*/
+function parseUserMap(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);
+}
+function buildDigestContext(tokens, userMap) {
+	return tokens.map((token) => {
+		const userId = userMap.get(ownerOf(token.name));
+		const label = token.name ?? "unnamed";
+		return userId ? `<@${userId}> ${token.provider}` : `${label} (${token.provider})`;
+	}).join("\n");
+}
+async function sendDigest(userMap) {
+	const inactive = await TokenModel.findInactive("A");
+	if (inactive.length === 0) return;
+	await notifySlack({
+		title: `재로그인 필요 ${inactive.length}건`,
+		context: buildDigestContext(inactive, userMap),
+		color: SLACK_COLOR.bad
+	});
+}
+let timer = null;
+/**
+* `SLACK_EXPIRY_DIGEST_INTERVAL_MINUTES` 가 양수일 때만 켜진다. 미설정·0 이면 비활성.
+*
+* 인스턴스가 여러 개면 각자 보낸다. 사망 알림과 달리 상태 변화가 없어 DB 로 억제할 수 없고,
+* 다이제스트는 하루 몇 건 수준이라 중복을 감수하는 편이 잠금 장치를 두는 것보다 낫다.
+*/
+function startExpiredTokenDigest() {
+	const minutes = Number(process.env.SLACK_EXPIRY_DIGEST_INTERVAL_MINUTES ?? 0);
+	if (!Number.isFinite(minutes) || minutes <= 0) return;
+	const userMap = parseUserMap(process.env.SLACK_USER_MAP);
+	logger.info(`expired token digest every ${minutes}m (${userMap.size} user mappings)`);
+	timer = setInterval(() => {
+		sendDigest(userMap).catch((e) => logger.warn(`digest failed: ${e.message}`));
+	}, minutes * MINUTE_MS);
+}
+function stopExpiredTokenDigest() {
+	if (!timer) return;
+	clearInterval(timer);
+	timer = null;
+}
+//#endregion
+export { buildDigestContext, startExpiredTokenDigest, stopExpiredTokenDigest };
+
+//# 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/token-death.js

@@ -1,6 +1,6 @@
 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 { getLogger } from "@logtape/logtape";
 //#region src/application/qgrid/token-death.ts
 /**

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 { startExpiredTokenDigest, stopExpiredTokenDigest } from "./application/qgrid/expired-token-digest.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}`);
 				}
+				startExpiredTokenDigest();
 				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"]);
+				stopExpiredTokenDigest();
 				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":";;;;;;;;;;;;;;AAiBA,MAAM,OAAO,QAAQ,IAAI,QAAQ;AACjC,MAAM,OAAO,OAAO,QAAQ,IAAI,QAAQ,KAAK;AAE7C,MAAM,aAAa;CACjB,MAAM,QAAQ,IAAI,kBAAkB;CACpC,MAAM,OAAO,QAAQ,IAAI,kBAAkB,IAAI;CAC/C,MAAM,QAAQ,IAAI,kBAAkB;CACpC,UAAU,QAAQ,IAAI,sBAAsB;CAC5C,UAAU,QAAQ,IAAI,kBAAkB;AAC1C;AAEA,IAAA,wBAAe,aAAa;CAC1B,aAAa,QAAQ,IAAI,gBAAgB;CACzC,UAAU,EACR,gBAAgB,EACd,YAAY;EACV,GAAG;EACH,WAAW;EACX,6BAA6B;CAC/B,EACF,EACF;CACA,KAAK;EACH,KAAK;EACL,UAAU;EACV,OAAO,EACL,QAAQ,OACV;CACF;CACA,MAAM;EACJ,eAAe;EACf,kBAAkB,CAAC,MAAM,IAAI;CAC/B;CACA,MAAM,EACJ,SAAS,CAAC,KAAK,EACjB;CACA,MAAM;EACJ,UAAU;EACV,YAAY;EACZ,WAAW,EAAE,SAAS,KAAK;CAC7B;CACA,SAAS;EACP,OAAO;GACL,SAAS,eAAe,EACtB,WAAW,mBAAmB;IAC5B,WAAW;IACX,eAAe;IACf,kBAAkB;GACpB,CAAC,EACH,CAAC;GAED,OAAO;EACT;EACA,SAAS;GAEP;IAAE,UAAU,CAAC,OAAO;IAAG,OAAO,CAAC,WAAW,OAAO;IAAG,aAAa;GAAO;GAExE;IAAE,UAAU,CAAC,QAAQ;IAAG,OAAO,CAAC,WAAW,OAAO;IAAG,aAAa;GAAU;GAE5E;IAAE,UAAU,CAAC,SAAS;IAAG,OAAO,CAAC;IAAG,aAAa;GAAQ;EAC3D;CACF;CACA,QAAQ;EACN,QAAQ;GAAE;GAAM;EAAK;EACrB,SAAS,EACP,WAAW,KAAK,OAAO,KACzB;EACA,SAAS;GACP,UAAU;GACV,IAAI;GACJ,KAAK;GACL,WAAW,EAAE,QAAQ,EAAE,UAAU,OAAO,OAAO,GAAG,EAAE;GACpD,QAAQ;IACN,MAAM,KAAK,KAAK,OAAO,KAAK,SAAS,QAAQ,QAAQ;IACrD,QAAQ;GACV;GACA,SAAS,WAAW;IAElB,OAAO,IAAI,aAAa,OAAO,SAAS,UAAU;KAChD,MAAM,EAAE,MAAM,UAAU,QAAQ;KAChC,IAAI,CAAC,QAAQ,CAAC,OACZ,OAAO,MAAM,SAAS,qCAAqC;KAE7D,IAAI;MACF,OAAO,WAAW,oBAAoB,MAAM,OAAO,KAAK;KAC1D,SAAS,GAAG;MACV,OAAO,MAAM,SACX,wBAAwB,mBAAoB,EAAY,OAAO,GACjE;KACF;IACF,CAAC;GAIH;EACF;EACA,WAAW;GACT,kBAAkB,gBAAgB,YAAY;IAC5C,OAAO;KACL,GAAG;KACH,IAAI,QAAQ;KACZ,MAAM,QAAQ;IAChB;GACF;GACA,oBAAoB,CAAC;GACrB,sBAAsB,QAAQ;IAC5B,QAAQ,IAAI,MAAZ;KACE,KAAK;MAEH,IAAI,IAAI,KAAK,MAAM,cAAc,GAC/B,OAAO,aAAa;MAEtB,OAAO,aAAa;KAEtB,KAAK;MAEH,IAAI,IAAI,WAAW,OAAO;OAExB,IAAI,IAAI,KAAK,WAAW,kBAAkB,GACxC,OAAO,aAAa;OAEtB,IAAI,IAAI,KAAK,WAAW,YAAY,GAClC,OAAO,aAAa;MAExB;MAEA,OAAO,aAAa;KAEtB,KAAK,OAEH,OAAO,aAAa;KAEtB,KAAK,OAEH,OAAO,aAAa;IACxB;IACA,OAAO,aAAa;GACtB;EACF;EACA,OAAO;GACL,SAAS;GACT,QAAQ,EACN,MAAM,MAAM,CAAC,CAAC,WAAWA,QAAa,OAAO,EAAE,SAAS,OAAO,CAAC,CAAC,EACnE;GACA,KAAK;GACL,QAAQ;EACV;EACA,WAAW;GACT,SAAS,YAAY;IACnB,MAAM,MAAM,UAAU,CAAC,SAAS,SAAS,CAAC;IAE1C,IAAI,eAAe;IACnB,IAAI;KACF,MAAM,oBAAoB,UAAU;IACtC,SAAS,GAAG;KACV,eAAe;KACf,IAAI,KAAK,yBAA0B,EAAY,SAAS;IAC1D;IAEA,MAAM,aAAa,IAAI,gBAAgB,YAAY,eAAe;IAClE,gBAAgB,aAAa;IAE7B,MAAM,UAAU,MAAM,WAAW,MAAM;IAIvC,IAAI;KACF,MAAM,mBAAmB,IAAI,iBAAiB;KAC9C,MAAM,iBAAiB,MAAM;KAC7B,gBAAgB,mBAAmB;KACnC,gBAAgB,aAAa,SAAS;IACxC,SAAS,GAAG;KACV,gBAAgB,aAAa,SAAS;KACtC,IAAI,KAAK,6BAA8B,EAAY,SAAS;IAC9D;IAEA,IAAI;KACF,MAAM,sBAAsB,IAAI,oBAAoB;KACpD,MAAM,oBAAoB,MAAM;KAChC,gBAAgB,sBAAsB;KACtC,gBAAgB,aAAa,YAAY;IAC3C,SAAS,GAAG;KACV,gBAAgB,aAAa,YAAY;KACzC,IAAI,KAAK,gCAAiC,EAAY,SAAS;IACjE;IAEA,MAAM,iBAAiB,gBAAgB,qBAAqB,cAAc;IAC1E,MAAM,cAAc,gBAAgB,kBAAkB,oBAAoB;IAC1E,MAAM,cAAc,gBAAgB,kBAAkB,eAAe;IAErE,IAAI,KAAK,uBAAuB,KAAK,GAAG,MAAM;IAC9C,IAAI,KAAK,cAAc,eAAe,cAAc;IACpD,IAAI,KAAK,WAAW,YAAY,GAAG,YAAY,cAAc;IAC7D,IAAI,KACF,eAAe,UAAU,kBAAkB,aAAa,eAAe,KAAK,oBAC9E;GACF;GACA,YAAY,YAAY;IACtB,MAAM,MAAM,UAAU,CAAC,SAAS,SAAS,CAAC;IAC1C,IAAI,gBAAgB,kBAClB,MAAM,gBAAgB,iBAAiB,KAAK;IAE9C,IAAI,gBAAgB,qBAClB,MAAM,gBAAgB,oBAAoB,KAAK;IAEjD,IAAI,gBAAgB,YAClB,MAAM,gBAAgB,WAAW,KAAK;IAExC,IAAI,KAAK,mBAAmB;GAC9B;GACA,UAAU,OAAO,UAAU,UAAU;IACnC,kBAAkB,OAAO,KAAK;GAChC;EACF;CACF;AACF,CAAC"}
+//# 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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"}

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-digest.test.ts

@@ -0,0 +1,49 @@
+import { describe, expect, it } from "vitest";
+
+import { buildDigestContext } from "./expired-token-digest";
+
+const userMap = new Map([
+  ["yds", "U09NAJUQSFQ"],
+  ["haze", "U09N96NHZB7"],
+]);
+
+describe("buildDigestContext", () => {
+  it("매핑된 토큰은 멘션으로 개인에게 꽂는다", () => {
+    const text = buildDigestContext([{ name: "anthropic/yds", provider: "anthropic" }], userMap);
+
+    expect(text).toBe("<@U09NAJUQSFQ> anthropic");
+  });
+
+  it("공용 계정처럼 매핑이 없으면 멘션 없이 이름만 남긴다", () => {
+    const text = buildDigestContext(
+      [{ name: "anthropic/dev-common", provider: "anthropic" }],
+      userMap,
+    );
+
+    expect(text).toBe("anthropic/dev-common (anthropic)");
+  });
+
+  it("같은 사람의 provider 별 토큰을 각각 줄로 나열한다", () => {
+    const text = buildDigestContext(
+      [
+        { name: "anthropic/yds", provider: "anthropic" },
+        { name: "openai/yds", provider: "openai" },
+      ],
+      userMap,
+    );
+
+    expect(text.split("\n")).toEqual(["<@U09NAJUQSFQ> anthropic", "<@U09NAJUQSFQ> openai"]);
+  });
+
+  it("provider prefix 없이 저장된 이름도 매핑한다", () => {
+    const text = buildDigestContext([{ name: "haze", provider: "anthropic" }], userMap);
+
+    expect(text).toBe("<@U09N96NHZB7> anthropic");
+  });
+
+  it("이름이 없는 토큰도 줄을 잃지 않는다", () => {
+    const text = buildDigestContext([{ name: null, provider: "openai" }], userMap);
+
+    expect(text).toBe("unnamed (openai)");
+  });
+});

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

@@ -0,0 +1,93 @@
+/**
+ * 비활성 토큰 주기 알림.
+ *
+ * 사망 순간의 단발 알림(`token-death.ts`)은 그 시점에 채널을 보지 않으면 놓친다. 재로그인은
+ * 사람이 해야 하는 일이라 놓치면 토큰이 계속 빠진 채로 남는다. 그래서 남아 있는 비활성
+ * 토큰을 주기적으로 다시 알리고, 소유자를 멘션해 개인에게 꽂는다.
+ *
+ * 비활성 토큰이 없으면 보내지 않는다 — "이상 없음"을 주기적으로 알리면 채널이 무뎌진다.
+ */
+import { getLogger } from "@logtape/logtape";
+
+import { notifySlack, SLACK_COLOR } from "../../utils/slack-notify";
+import { TokenModel } from "../token/token.model";
+
+const logger = getLogger(["qgrid", "expired-digest"]);
+
+const MINUTE_MS = 60_000;
+
+/**
+ * `토큰명:SlackUserId` 목록. 공용 계정(bysuco, dev-common 등)은 넣지 않는다 — 매핑이 없으면
+ * 멘션 없이 이름만 나가고, 그게 맞는 동작이다.
+ *
+ * Slack 표시 이름과 토큰명이 자주 어긋나(haze→haze.lee, byeongjun→potados) 자동 매칭은
+ * 조용히 실패한다. 멘션이 빠지면 알림의 목적 자체가 사라지므로 명시 매핑만 쓴다.
+ */
+function parseUserMap(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 없이 저장된 이름도 그대로 받는다. */
+function ownerOf(tokenName: string | null): string {
+  if (!tokenName) return "";
+  const slash = tokenName.indexOf("/");
+  return slash === -1 ? tokenName : tokenName.slice(slash + 1);
+}
+
+export function buildDigestContext(
+  tokens: { name: string | null; provider: string }[],
+  userMap: Map<string, string>,
+): string {
+  return tokens
+    .map((token) => {
+      const userId = userMap.get(ownerOf(token.name));
+      const label = token.name ?? "unnamed";
+      // 멘션이 있으면 이름 대신 멘션을 쓴다 — 둘 다 쓰면 같은 말이 두 번 나온다.
+      return userId ? `<@${userId}> ${token.provider}` : `${label} (${token.provider})`;
+    })
+    .join("\n");
+}
+
+async function sendDigest(userMap: Map<string, string>): Promise<void> {
+  const inactive = await TokenModel.findInactive("A");
+  if (inactive.length === 0) return;
+
+  await notifySlack({
+    title: `재로그인 필요 ${inactive.length}건`,
+    context: buildDigestContext(inactive, userMap),
+    color: SLACK_COLOR.bad,
+  });
+}
+
+let timer: ReturnType<typeof setInterval> | null = null;
+
+/**
+ * `SLACK_EXPIRY_DIGEST_INTERVAL_MINUTES` 가 양수일 때만 켜진다. 미설정·0 이면 비활성.
+ *
+ * 인스턴스가 여러 개면 각자 보낸다. 사망 알림과 달리 상태 변화가 없어 DB 로 억제할 수 없고,
+ * 다이제스트는 하루 몇 건 수준이라 중복을 감수하는 편이 잠금 장치를 두는 것보다 낫다.
+ */
+export function startExpiredTokenDigest(): void {
+  const minutes = Number(process.env.SLACK_EXPIRY_DIGEST_INTERVAL_MINUTES ?? 0);
+  if (!Number.isFinite(minutes) || minutes <= 0) return;
+
+  const userMap = parseUserMap(process.env.SLACK_USER_MAP);
+  logger.info(`expired token digest every ${minutes}m (${userMap.size} user mappings)`);
+
+  timer = setInterval(() => {
+    sendDigest(userMap).catch((e) => logger.warn(`digest failed: ${(e as Error).message}`));
+  }, minutes * MINUTE_MS);
+}
+
+export function stopExpiredTokenDigest(): void {
+  if (!timer) return;
+  clearInterval(timer);
+  timer = null;
+}

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

@@ -146,6 +146,25 @@ class TokenModelClass extends BaseModelClass<
     return result.rows;
   }
 
+  /**
+   * 라우팅에서 빠진 토큰들. 세션 만료로 자동 비활성화된 것과 수동으로 끈 것이 섞여 있다 —
+   * 둘 다 "재로그인하면 살아나는" 상태라 알림 대상으로는 같게 본다.
+   */
+  async findInactive<T extends TokenSubsetKey>(subset: T): Promise<TokenSubsetMapping[T][]> {
+    const { qb } = this.getSubsetQueries(subset);
+    qb.where("tokens.active", false);
+    qb.orderBy("tokens.name", "asc");
+    const enhancers = this.createEnhancers({ A: (row) => ({ ...row }) });
+    const result = await this.executeSubsetQuery({
+      subset,
+      qb,
+      params: { num: 100, page: 1 },
+      enhancers,
+      debug: false,
+    });
+    return result.rows;
+  }
+
   async findActive<T extends TokenSubsetKey>(subset: T): Promise<TokenSubsetMapping[T][]> {
     const { qb } = this.getSubsetQueries(subset);
     qb.where("tokens.active", true);

package/bundle/src/sonamu.config.ts

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

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

@@ -36,10 +36,10 @@ describe("notifySlack", () => {
     expect(url).toBe("https://slack.com/api/chat.postMessage");
     expect(JSON.parse((init as RequestInit).body as string)).toEqual({
       channel: "C123",
-      // blocks 만 보내면 푸시 알림이 빈칸으로 뜨므로 대체 텍스트가 함께 나가야 한다.
-      text: "토큰 추가 — anthropic/test-token",
       attachments: [
         {
+          // 최상위 text 가 아니라 attachment fallback 이어야 본문 제목과 겹치지 않는다.
+          fallback: "토큰 추가 — anthropic/test-token",
           color: SLACK_COLOR.good,
           blocks: [
             {
@@ -66,8 +66,10 @@ describe("notifySlack", () => {
 
     const body = JSON.parse(
       (fetchMock.mock.calls[0]![1] as RequestInit).body as string,
-    ) as { text: string; attachments: [{ color?: string; blocks: unknown[] }] };
-    expect(body.text).toBe("제목만");
+    ) as { text?: string; attachments: [{ fallback: string; color?: string; blocks: unknown[] }] };
+    // 최상위 text 를 보내지 않아야 blocks 렌더 화면에서 제목이 중복되지 않는다.
+    expect(body.text).toBeUndefined();
+    expect(body.attachments[0].fallback).toBe("제목만");
     expect(body.attachments[0].color).toBeUndefined();
     expect(body.attachments[0].blocks).toHaveLength(1);
   });