@cartanova/qgrid-cli 2.7.9 → 2.9.0

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/qgrid.types.ts

@@ -114,7 +114,7 @@ export const QueryInput = z.looseObject({
   serviceTier: ServiceTier.optional(),
   history: z.string().optional(),
   projectName: z.string().optional(),
-  // 내부·대시보드 호출용 지정 주소. 공개 AI SDK provider options 에는 노출하지 않는다.
+  // raw/dashboard와 공개 AI SDK providerOptions.qgrid.tokenName이 공유하는 지정 주소.
   tokenName: z.string().optional(),
   // SDK-derived opaque affinity. It is intentionally distinct from the caller's sessionKey.
   cacheAffinityKey: z

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(),

package/bundle/src/application/token/token.entity.json

@@ -14,6 +14,12 @@
     },
     { "name": "name", "desc": "토큰 이름", "type": "string" },
     { "name": "active", "type": "boolean", "desc": "활성 여부", "dbDefault": "true" },
+    {
+      "name": "reauth_required",
+      "type": "boolean",
+      "desc": "인증 만료로 재로그인이 필요한지 여부",
+      "dbDefault": "false"
+    },
     { "name": "ord", "type": "integer", "desc": "정렬 순서", "dbDefault": "0" },
     {
       "name": "quota_threshold",
@@ -50,6 +56,7 @@
       "credentials",
       "name",
       "active",
+      "reauth_required",
       "ord",
       "quota_threshold",
       "weight",