@cartanova/qgrid-cli 2.8.0 → 2.9.1

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

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

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

@@ -1,7 +1,7 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
-const { findInactiveMock, getSettingMock, notifySlackMock } = vi.hoisted(() => ({
-  findInactiveMock: vi.fn(),
+const { findReauthRequiredMock, getSettingMock, notifySlackMock } = vi.hoisted(() => ({
+  findReauthRequiredMock: vi.fn(),
   getSettingMock: vi.fn(),
   notifySlackMock: vi.fn(),
 }));
@@ -97,10 +97,12 @@ describe("expired token reminder scheduling", () => {
     minutes = "10";
     rawUserMap = "yds:U-OLD";
     remindersEnabled = "true";
-    findInactiveMock.mockReset();
+    findReauthRequiredMock.mockReset();
     getSettingMock.mockReset();
     notifySlackMock.mockReset();
-    findInactiveMock.mockResolvedValue([{ name: "anthropic/yds", provider: "anthropic" }]);
+    findReauthRequiredMock.mockResolvedValue([
+      { name: "anthropic/yds", provider: "anthropic" },
+    ]);
     getSettingMock.mockImplementation((key: string) => {
       if (key === "slack.expiryReminderMinutes") return minutes;
       if (key === "slack.userMap") return rawUserMap;
@@ -109,7 +111,7 @@ describe("expired token reminder scheduling", () => {
     });
     notifySlackMock.mockResolvedValue(undefined);
     deps = {
-      findInactive: findInactiveMock,
+      findReauthRequired: findReauthRequiredMock,
       getSlackUserMap: () => getSlackUserMap(getSettingMock),
       readSetting: getSettingMock,
       sendSlack: notifySlackMock,
@@ -159,7 +161,7 @@ describe("expired token reminder scheduling", () => {
   });
 
   it("보낼 대상이 없으면 0을 돌려주고 아무것도 보내지 않는다", async () => {
-    findInactiveMock.mockResolvedValue([]);
+    findReauthRequiredMock.mockResolvedValue([]);
 
     const sent = await sendExpiredTokenReminderNow(deps);
 

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

@@ -8,7 +8,8 @@
  * 여러 토큰이 만료돼 있으면 한 메시지에 모은다. 토큰마다 메시지를 보내면 채널이 시끄러워
  * 정작 읽히지 않는다.
  *
- * 비활성 토큰이 없으면 보내지 않는다 — "이상 없음"을 주기적으로 알리면 채널이 무뎌진다.
+ * 재로그인이 필요한 토큰이 없으면 보내지 않는다 — "이상 없음"을 주기적으로 알리면
+ * 채널이 무뎌진다.
  */
 import { getLogger } from "@logtape/logtape";
 
@@ -22,14 +23,14 @@ const logger = getLogger(["qgrid", "expired-reminder"]);
 const MINUTE_MS = 60_000;
 
 export type ExpiredTokenReminderDeps = {
-  findInactive: () => Promise<{ name: string | null; provider: string }[]>;
+  findReauthRequired: () => Promise<{ name: string | null; provider: string }[]>;
   getSlackUserMap: () => Map<string, string>;
   readSetting: typeof getSetting;
   sendSlack: typeof notifySlack;
 };
 
 const defaultDeps: ExpiredTokenReminderDeps = {
-  findInactive: () => TokenModel.findInactive("A"),
+  findReauthRequired: () => TokenModel.findReauthRequired("A"),
   getSlackUserMap,
   readSetting: getSetting,
   sendSlack: notifySlack,
@@ -54,20 +55,20 @@ export function buildReminderContext(
 }
 
 async function sendReminder(deps: ExpiredTokenReminderDeps, urgent = false): Promise<number> {
-  const inactive = await deps.findInactive();
-  if (inactive.length === 0) return 0;
+  const expired = await deps.findReauthRequired();
+  if (expired.length === 0) return 0;
 
   const userMap = deps.getSlackUserMap();
 
   await deps.sendSlack({
     // 만료 순간 알림과 같은 제목을 쓴다. 같은 사건이므로 다른 이름을 붙이면 별개 문제로 읽힌다.
     title: "세션 만료",
-    subject: inactive.length > 1 ? `${inactive.length}건` : (inactive[0]!.name ?? "unnamed"),
-    context: buildReminderContext(inactive, userMap),
+    subject: expired.length > 1 ? `${expired.length}건` : (expired[0]!.name ?? "unnamed"),
+    context: buildReminderContext(expired, userMap),
     color: SLACK_COLOR.bad,
     urgent,
   });
-  return inactive.length;
+  return expired.length;
 }
 
 /**

package/bundle/src/application/qgrid/qgrid.frame.test.ts

@@ -10,6 +10,7 @@ const {
   findOneMock,
   findManyMock,
   findActiveByProviderAndNameMock,
+  toggleActiveMock,
   saveMock,
   updateFieldsMock,
   requestLogSaveMock,
@@ -33,6 +34,7 @@ const {
     findOneMock: vi.fn(),
     findManyMock: vi.fn(),
     findActiveByProviderAndNameMock: vi.fn(),
+    toggleActiveMock: vi.fn(),
     saveMock: vi.fn(),
     updateFieldsMock: vi.fn(),
     requestLogSaveMock: vi.fn(),
@@ -65,6 +67,7 @@ vi.mock("../token/token.model", () => ({
     findOne: findOneMock,
     findMany: findManyMock,
     findActiveByProviderAndName: findActiveByProviderAndNameMock,
+    toggleActive: toggleActiveMock,
     save: saveMock,
     updateFields: updateFieldsMock,
   },
@@ -111,12 +114,31 @@ const tokenEntry = {
   },
   name: "tok-A",
   active: true,
+  reauth_required: false,
   ord: 0,
   quota_threshold: null,
   weight: 1,
   keepalive_enabled: false,
 };
 
+describe("QgridFrame.toggleToken", () => {
+  beforeEach(() => {
+    toggleActiveMock.mockReset();
+  });
+
+  it("does not reactivate a token whose login has expired", async () => {
+    toggleActiveMock.mockResolvedValue({ active: false, reauthRequired: true });
+
+    await expect(QgridFrame.toggleToken(1)).rejects.toThrow("Re-login required");
+  });
+
+  it("reactivates a manually disabled token without requiring login", async () => {
+    toggleActiveMock.mockResolvedValue({ active: true, reauthRequired: false });
+
+    await expect(QgridFrame.toggleToken(1)).resolves.toEqual({ active: true });
+  });
+});
+
 function deeplyNestedInputSchema(depth: number): unknown {
   return JSON.parse(`${"[".repeat(depth)}0${"]".repeat(depth)}`) as unknown;
 }

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

@@ -575,20 +575,12 @@ class QgridFrameClass extends BaseFrameClass {
    */
   @api({ httpMethod: "POST", clients: ["axios", "tanstack-mutation"] })
   async toggleToken(id: number): Promise<{ active: boolean }> {
-    const entry = await TokenModel.findOne("A", { id });
-    if (!entry) return { active: false };
-
-    const newActive = !entry.active;
-    await TokenModel.save([
-      {
-        id,
-        provider: entry.provider,
-        credentials: entry.credentials,
-        active: newActive,
-        name: entry.name,
-      },
-    ]);
-    return { active: newActive };
+    const result = await TokenModel.toggleActive(id);
+    if (!result) return { active: false };
+    if (result.reauthRequired) {
+      throw new BadRequestException("Re-login required" as LocalizedString);
+    }
+    return { active: result.active };
   }
 
   @api({ httpMethod: "POST", clients: ["axios", "tanstack-mutation"] })
@@ -812,7 +804,7 @@ class QgridFrameClass extends BaseFrameClass {
       refreshed = await refreshAccessToken(rt);
     } catch (e) {
       if (e instanceof RefreshFailedError && e.isAuthDead) {
-        await deactivateAuthDeadToken(token, rt, `anthropic:${e.status}`);
+        await deactivateAuthDeadToken(token, `anthropic:${e.status}`);
       }
       throw e;
     }
@@ -829,6 +821,7 @@ class QgridFrameClass extends BaseFrameClass {
         provider: token.provider,
         credentials: updated,
         name: token.name,
+        reauth_required: false,
       },
     ]);
     return refreshed.accessToken;

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

@@ -3,14 +3,13 @@ import { afterEach, describe, expect, it, vi } from "vitest";
 import { SLACK_COLOR } from "../../utils/slack-notify";
 import { deactivateAuthDeadToken, notifyTokenAdded } from "./token-death";
 
-const { findOneMock, deactivateMock, notifySlackMock } = vi.hoisted(() => ({
-  findOneMock: vi.fn(),
+const { deactivateMock, notifySlackMock } = vi.hoisted(() => ({
   deactivateMock: vi.fn(),
   notifySlackMock: vi.fn(),
 }));
 
 vi.mock("../token/token.model", () => ({
-  TokenModel: { findOne: findOneMock, deactivateIfActive: deactivateMock },
+  TokenModel: { markReauthRequired: deactivateMock },
 }));
 
 // SLACK_COLOR 는 상수라 가릴 이유가 없다 — 전송 함수만 스텁한다.
@@ -19,32 +18,34 @@ vi.mock("../../utils/slack-notify", async (importOriginal) => ({
   notifySlack: notifySlackMock,
 }));
 
-const token = { id: 7, name: "anthropic/test-token", provider: "anthropic" };
-
-function storedRefreshToken(refreshToken: string) {
-  return {
-    id: 7,
-    provider: "anthropic",
-    credentials: { accessToken: "at", refreshToken, expiresAt: 0, accountUuid: "acc-1" },
-  };
-}
+const token = {
+  id: 7,
+  name: "anthropic/test-token",
+  provider: "anthropic",
+  credentials: {
+    accessToken: "at",
+    refreshToken: "rt-current",
+    expiresAt: 0,
+    accountUuid: "acc-1",
+  },
+};
 
 describe("deactivateAuthDeadToken", () => {
   afterEach(() => {
-    findOneMock.mockReset();
     deactivateMock.mockReset();
     notifySlackMock.mockReset();
   });
 
   it("deactivates and notifies when the failed attempt used the current refresh token", async () => {
-    findOneMock.mockResolvedValue(storedRefreshToken("rt-current"));
-    deactivateMock.mockResolvedValue({ deactivated: true, keptAsLastActive: false });
+    deactivateMock.mockResolvedValue({
+      marked: true,
+      keptAsLastActive: false,
+      staleCredentials: false,
+    });
 
-    await expect(
-      deactivateAuthDeadToken(token, "rt-current", "anthropic:400"),
-    ).resolves.toBe(true);
+    await expect(deactivateAuthDeadToken(token, "anthropic:400")).resolves.toBe(true);
 
-    expect(deactivateMock).toHaveBeenCalledWith(7);
+    expect(deactivateMock).toHaveBeenCalledWith(7, token.credentials);
     expect(notifySlackMock).toHaveBeenCalledTimes(1);
     const notification = notifySlackMock.mock.calls[0]![0] as {
       subject: string;
@@ -56,34 +57,39 @@ describe("deactivateAuthDeadToken", () => {
     expect(notification.color).toBe(SLACK_COLOR.bad);
   });
 
-  it("skips deactivation when the refresh token rotated since the failed attempt", async () => {
-    findOneMock.mockResolvedValue(storedRefreshToken("rt-rotated"));
+  it("skips deactivation when credentials rotated since the failed attempt", async () => {
+    deactivateMock.mockResolvedValue({
+      marked: false,
+      keptAsLastActive: false,
+      staleCredentials: true,
+    });
 
-    await expect(deactivateAuthDeadToken(token, "rt-stale", "anthropic:400")).resolves.toBe(false);
+    await expect(deactivateAuthDeadToken(token, "anthropic:400")).resolves.toBe(false);
 
-    expect(deactivateMock).not.toHaveBeenCalled();
+    expect(deactivateMock).toHaveBeenCalledWith(7, token.credentials);
     expect(notifySlackMock).not.toHaveBeenCalled();
   });
 
   it("does not notify when another process won the deactivation race", async () => {
-    findOneMock.mockResolvedValue(storedRefreshToken("rt-current"));
-    deactivateMock.mockResolvedValue({ deactivated: false, keptAsLastActive: false });
+    deactivateMock.mockResolvedValue({
+      marked: false,
+      keptAsLastActive: false,
+      staleCredentials: false,
+    });
 
-    await expect(deactivateAuthDeadToken(token, "rt-current", "anthropic:400")).resolves.toBe(
-      false,
-    );
+    await expect(deactivateAuthDeadToken(token, "anthropic:400")).resolves.toBe(false);
 
     expect(notifySlackMock).not.toHaveBeenCalled();
   });
 
   it("alerts instead of deactivating when the dying token is the last active one", async () => {
-    // 알림 쿨다운이 모듈 수준 상태라 다른 테스트의 발송 기록에 가려질 수 있다.
-    vi.resetModules();
-    const { deactivateAuthDeadToken: freshDeactivate } = await import("./token-death");
-    findOneMock.mockResolvedValue(storedRefreshToken("rt-current"));
-    deactivateMock.mockResolvedValue({ deactivated: false, keptAsLastActive: true });
+    deactivateMock.mockResolvedValue({
+      marked: true,
+      keptAsLastActive: true,
+      staleCredentials: false,
+    });
 
-    await expect(freshDeactivate(token, "rt-current", "anthropic:400")).resolves.toBe(false);
+    await expect(deactivateAuthDeadToken(token, "anthropic:400")).resolves.toBe(false);
 
     expect(notifySlackMock).toHaveBeenCalledTimes(1);
     const notification = notifySlackMock.mock.calls[0]![0] as { title: string; context: string };
@@ -91,36 +97,34 @@ describe("deactivateAuthDeadToken", () => {
     expect(notification.context).toContain("anthropic:400");
   });
 
-  it("suppresses repeat last-active alerts for the same provider within the cooldown", async () => {
-    // 이 경로는 토큰을 비활성화하지 않아 상태 변화가 없다 — 억제가 없으면 요청마다 알림이 간다.
-    // 쿨다운은 모듈 수준 상태라 앞 테스트의 발송 기록이 남는다. 새로 불러 격리한다.
-    vi.resetModules();
-    const { deactivateAuthDeadToken: freshDeactivate } = await import("./token-death");
-    findOneMock.mockResolvedValue(storedRefreshToken("rt-current"));
-    deactivateMock.mockResolvedValue({ deactivated: false, keptAsLastActive: true });
-
-    await freshDeactivate(token, "rt-current", "anthropic:400");
-    await freshDeactivate(token, "rt-current", "anthropic:400");
-    await freshDeactivate(token, "rt-current", "anthropic:401");
+  it("does not repeat a last-active alert after another process records auth death", async () => {
+    deactivateMock
+      .mockResolvedValueOnce({
+        marked: true,
+        keptAsLastActive: true,
+        staleCredentials: false,
+      })
+      .mockResolvedValue({
+        marked: false,
+        keptAsLastActive: false,
+        staleCredentials: false,
+      });
+
+    await deactivateAuthDeadToken(token, "anthropic:400");
+    await deactivateAuthDeadToken(token, "anthropic:400");
+    await deactivateAuthDeadToken(token, "anthropic:401");
 
     expect(notifySlackMock).toHaveBeenCalledTimes(1);
   });
 
-  it("does nothing when the token no longer exists", async () => {
-    findOneMock.mockResolvedValue(undefined);
-
-    await expect(deactivateAuthDeadToken(token, "rt-current", "anthropic:400")).resolves.toBe(
-      false,
-    );
-
-    expect(deactivateMock).not.toHaveBeenCalled();
-  });
-
   it("never puts the raw provider error body in the notification", async () => {
-    findOneMock.mockResolvedValue(storedRefreshToken("rt-current"));
-    deactivateMock.mockResolvedValue({ deactivated: true, keptAsLastActive: false });
+    deactivateMock.mockResolvedValue({
+      marked: true,
+      keptAsLastActive: false,
+      staleCredentials: false,
+    });
 
-    await deactivateAuthDeadToken(token, "rt-current", "anthropic:400");
+    await deactivateAuthDeadToken(token, "anthropic:400");
 
     // 필드가 늘어도 새는 곳이 생기지 않도록 페이로드 전체를 훑는다.
     const payload = JSON.stringify(notifySlackMock.mock.calls[0]![0]);

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

@@ -1,55 +1,46 @@
 /**
  * 세션 만료(auth-dead) 토큰의 라우팅 제외 지점.
  *
- * refresh 가 재로그인 외 복구 불가한 실패를 반환한 순간에만 호출된다. 비활성화는
- * `active=true` 조건부 갱신 1회이고, 그 갱신을 이긴 프로세스만 Slack 알림을 보낸다 —
- * 공유 DB 를 쓰는 인스턴스가 몇이든 사건당 알림은 1건이다.
+ * refresh 가 재로그인 외 복구 불가한 실패를 반환한 순간에만 호출된다. 시도에 사용한
+ * credentials 가 DB 와 같을 때만 reauth_required 를 기록하고, 그 기록을 이긴 프로세스만
+ * Slack 알림을 보낸다 — 공유 DB 를 쓰는 인스턴스가 몇이든 사건당 알림은 1건이다.
  */
 import { getLogger } from "@logtape/logtape";
 
-import { getRefreshToken } from "../../utils/providers/common/credentials";
 import { notifySlack, SLACK_COLOR } from "../../utils/slack-notify";
+import { type TokenSubsetA } from "../sonamu.generated";
 import { TokenModel } from "../token/token.model";
 import { getSlackUserMap, mentionFor } from "./slack-user-map";
 
 const logger = getLogger(["qgrid", "token-death"]);
 
-type DeadTokenRef = {
-  id: number;
-  name: string;
-  provider: string;
-};
+type DeadTokenRef = Pick<TokenSubsetA, "id" | "name" | "provider" | "credentials">;
 
 /**
- * @param usedRefreshToken 실패한 요청이 실제로 사용한 refresh token.
- *   refresh token 은 회전 저장되므로, 이미 회전된 옛 토큰으로 늦게 도착한 재시도가
- *   400 을 받는 것은 정상 레이스다. DB 의 현재 값과 다르면 사망으로 보지 않는다.
  * @param reasonCode `provider:code` 형태의 내부 코드. provider 응답 본문에는 계정 이메일이나
  *   토큰 조각이 섞일 수 있어 raw 메시지를 그대로 알림에 싣지 않는다.
  */
 export async function deactivateAuthDeadToken(
   token: DeadTokenRef,
-  usedRefreshToken: string,
   reasonCode: string,
 ): Promise<boolean> {
-  const current = await TokenModel.findOne("A", { id: token.id });
-  if (!current) return false;
-
-  const currentRefreshToken = getRefreshToken(current.credentials);
-  if (currentRefreshToken && currentRefreshToken !== usedRefreshToken) {
+  const { marked, keptAsLastActive, staleCredentials } = await TokenModel.markReauthRequired(
+    token.id,
+    token.credentials,
+  );
+  if (staleCredentials) {
     logger.info(
-      `skipping auth-death for ${token.name}(id=${token.id}): refresh token rotated since this attempt`,
+      `skipping auth-death for ${token.name}(id=${token.id}): credentials rotated since this attempt`,
     );
     return false;
   }
-
-  const { deactivated, keptAsLastActive } = await TokenModel.deactivateIfActive(token.id);
-  if (!deactivated) {
-    if (keptAsLastActive) notifyLastActiveTokenDying(token, reasonCode);
+  if (!marked) return false;
+  if (keptAsLastActive) {
+    notifyLastActiveTokenDying(token, reasonCode);
     return false;
   }
 
-  logger.warn(`token deactivated (auth dead): ${token.name}(id=${token.id}) reason=${reasonCode}`);
+  logger.warn(`token requires re-login: ${token.name}(id=${token.id}) reason=${reasonCode}`);
   // 만료 직후가 재로그인하기 가장 좋은 타이밍이다. 소유자를 멘션해 그 순간 당사자에게
   // 꽂는다 — 다이제스트를 기다리면 다음 주기까지 토큰이 빠진 채로 남는다.
   const mention = mentionFor(token.name, getSlackUserMap());
@@ -64,22 +55,7 @@ export async function deactivateAuthDeadToken(
   return true;
 }
 
-/**
- * 마지막 활성 토큰이 죽었을 때의 알림 쿨다운.
- *
- * 이 경우 토큰은 비활성화되지 않고 살아남으므로, 뒤따르는 요청마다 같은 실패를 반복해
- * 알림이 폭주한다. 비활성화 성공 경로가 조건부 UPDATE 로 중복을 막는 것과 달리 여기엔
- * 상태 변화가 없어 DB 로 억제할 수 없다 — provider 단위로 시간 창을 둔다.
- */
-const LAST_ACTIVE_ALERT_COOLDOWN_MS = 30 * 60 * 1000;
-const lastActiveAlertAt = new Map<string, number>();
-
 function notifyLastActiveTokenDying(token: DeadTokenRef, reasonCode: string): void {
-  const now = Date.now();
-  const previous = lastActiveAlertAt.get(token.provider);
-  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: "마지막 토큰 사망",

package/bundle/src/application/qgrid/token-trigger-setup.test.ts

@@ -12,4 +12,10 @@ describe("tokens trigger setup", () => {
       "OLD.keepalive_enabled IS DISTINCT FROM NEW.keepalive_enabled",
     );
   });
+
+  it("notifies subscribers when a token starts requiring re-login", () => {
+    expect(TOKENS_TRIGGER_SETUP_SQL).toContain(
+      "OLD.reauth_required IS DISTINCT FROM NEW.reauth_required",
+    );
+  });
 });

package/bundle/src/application/qgrid/token-trigger-setup.ts

@@ -37,6 +37,7 @@ export const TOKENS_TRIGGER_SETUP_SQL = `
   FOR EACH ROW
   WHEN (
     OLD.active IS DISTINCT FROM NEW.active OR
+    OLD.reauth_required IS DISTINCT FROM NEW.reauth_required OR
     OLD.credentials IS DISTINCT FROM NEW.credentials OR
     OLD.provider IS DISTINCT FROM NEW.provider OR
     OLD.name IS DISTINCT FROM NEW.name OR

package/bundle/src/application/sonamu.generated.http

@@ -22,33 +22,6 @@ Content-Type: application/json
 
 ###
 
-POST {{baseUrl}}/api/token/save
-Content-Type: application/json
-
-{
-  "spa": [
-    {
-      "id": 0,
-      "created_at": "2000-01-01",
-      "provider": "PROVIDER",
-      "credentials": {
-        "accessToken": "ACCESSTOKEN",
-        "refreshToken": "REFRESHTOKEN",
-        "expiresAt": 0,
-        "accountUuid": "ACCOUNTUUID"
-      },
-      "name": "NAME",
-      "active": false,
-      "ord": 0,
-      "quota_threshold": null,
-      "weight": 1,
-      "keepalive_enabled": false
-    }
-  ]
-}
-
-###
-
 POST {{baseUrl}}/api/token/reorder
 Content-Type: application/json
 

package/bundle/src/application/sonamu.generated.sso.ts

@@ -210,6 +210,7 @@ export const tokenSubsetQueries = {
       credentials: "tokens.credentials",
       name: "tokens.name",
       active: "tokens.active",
+      reauth_required: "tokens.reauth_required",
       ord: "tokens.ord",
       quota_threshold: "tokens.quota_threshold",
       weight: "tokens.weight",

package/bundle/src/application/sonamu.generated.ts

@@ -296,6 +296,7 @@ export const TokenBaseSchema = z.object({
   credentials: TokenCredentials,
   name: z.string(),
   active: z.boolean(),
+  reauth_required: z.boolean(),
   ord: z.int(),
   quota_threshold: z.int().nullable(),
   weight: z.int(),
@@ -305,6 +306,7 @@ export type TokenBaseSchema = z.infer<typeof TokenBaseSchema> & {
   readonly __hasDefault__: readonly [
     "created_at",
     "active",
+    "reauth_required",
     "ord",
     "quota_threshold",
     "weight",
@@ -557,6 +559,7 @@ export const TokenSubsetA = z.object({
   credentials: TokenCredentials,
   name: z.string(),
   active: z.boolean(),
+  reauth_required: z.boolean(),
   ord: z.int(),
   quota_threshold: z.int().nullable(),
   weight: z.int(),