@cartanova/qgrid-cli 2.6.1 → 2.6.2

package/bundle/src/application/request-log/request-log.model.ts

@@ -195,21 +195,15 @@ class RequestLogModelClass extends BaseModelClass<
     return rows[0] ?? null;
   }
 
-  @api({ httpMethod: "GET", clients: ["axios", "tanstack-query"], resourceName: "RequestLogs" })
-  async findMany<T extends RequestLogSubsetKey, LP extends RequestLogListParams>(
-    subset: T,
-    rawParams?: LP,
-  ): Promise<ListResult<LP, RequestLogSubsetMapping[T]>> {
-    const params = {
-      num: 24,
-      page: 1,
-      search: "id" as const,
-      orderBy: "id-desc" as const,
-      ...rawParams,
-    } satisfies RequestLogListParams;
-
-    const { qb, onSubset: _ } = this.getSubsetQueries(subset);
-
+  /**
+   * 목록 필터의 단일 정의. findMany 와 totalCost 가 같은 조건을 보도록 공유한다 —
+   * 화면에서 필터를 걸면 행 수와 비용이 함께 좁혀져야 하는데, 두 쿼리가 각자 필터를
+   * 구현하면 한쪽에 축을 추가할 때 조용히 어긋난다.
+   */
+  private applyListFilters(
+    qb: ReturnType<RequestLogModelClass["getSubsetQueries"]>["qb"],
+    params: RequestLogListParams,
+  ): void {
     if (params.id) {
       qb.whereIn("request_logs.id", asArray(params.id));
     }
@@ -241,6 +235,24 @@ class RequestLogModelClass extends BaseModelClass<
         throw new BadRequestException(SD("error.unknownSearchField")(params.search));
       }
     }
+  }
+
+  @api({ httpMethod: "GET", clients: ["axios", "tanstack-query"], resourceName: "RequestLogs" })
+  async findMany<T extends RequestLogSubsetKey, LP extends RequestLogListParams>(
+    subset: T,
+    rawParams?: LP,
+  ): Promise<ListResult<LP, RequestLogSubsetMapping[T]>> {
+    const params = {
+      num: 24,
+      page: 1,
+      search: "id" as const,
+      orderBy: "id-desc" as const,
+      ...rawParams,
+    } satisfies RequestLogListParams;
+
+    const { qb, onSubset: _ } = this.getSubsetQueries(subset);
+
+    this.applyListFilters(qb, params);
 
     // orderBy
     if (params.orderBy) {
@@ -254,6 +266,7 @@ class RequestLogModelClass extends BaseModelClass<
 
     const enhancers = this.createEnhancers({
       A: (row) => normalizeLegacyAnthropicRow(row),
+      C: (row) => normalizeLegacyAnthropicRow(row),
     });
 
     return this.executeSubsetQuery({
@@ -606,33 +619,65 @@ class RequestLogModelClass extends BaseModelClass<
     return (row?.max_step ?? -1) + 1;
   }
 
-  // Sonamu findMany는 subset 전체 컬럼(text 포함)을 페치하므로 비용 계산에 필요한 컬럼만 조회한다.
-  async totalCost(params: { token_name?: string } = {}): Promise<number> {
-    // 기존 cost_usd 에는 과거 Anthropic cache 계산 버그로 음수가 저장된 row 가 있을 수 있다.
-    // 화면 집계는 저장값 sum 이 아니라 현재 계산식으로 usage 를 재계산해 과거 로그도 즉시 보정한다.
-    const rows = await this.getPuri("r")
-      .from("request_logs")
-      .where(params.token_name ? { token_name: params.token_name } : {})
+  /**
+   * 화면 표시용 총 비용. 목록과 같은 필터를 적용한다.
+   *
+   * 전체를 조건 없이 SUM 한 뒤, `cost_source` 가 없는 legacy row 의 차액만 보정한다.
+   * 조건 없는 SUM 이어야 `(project_name, cost_usd)` 커버링 인덱스가 Index Only Scan 을
+   * 탄다 — `cost_source IS NOT NULL` 을 걸면 그 컬럼이 인덱스에 없어 heap 을 다시 봐야
+   * 하므로 플래너가 인덱스를 버리고 seq scan 으로 돌아간다(실측 230ms → 814ms).
+   *
+   * legacy 보정을 남겨둔 이유: 백필로 기존 legacy 는 0 이 되었지만, 외부 로거가
+   * `AppendStepInput`/`FinishRunInput` 으로 costSource 없이 넣으면 다시 생길 수 있다.
+   * 그런 row 는 저장값 대신 현재 가격표 재계산값이 맞으므로 차액을 더한다.
+   *
+   * 필터 조건을 여기서 다시 구현하지 않고 `applyListFilters` 를 공유하는 것이 핵심이다 —
+   * 두 쿼리가 각자 필터를 가지면 화면에서 필터를 걸었을 때 행 수와 비용이 조용히 어긋난다.
+   */
+  async totalCost(rawParams: RequestLogListParams = { num: 0, page: 1 }): Promise<number> {
+    const params = {
+      num: 0,
+      page: 1,
+      search: "id" as const,
+      ...rawParams,
+    } satisfies RequestLogListParams;
+
+    const { qb: totalQb } = this.getSubsetQueries("C");
+    this.applyListFilters(totalQb, params);
+    // subset qb 는 컬럼 목록이 이미 SELECT 에 박혀 있어 집계를 얹으면 GROUP BY 에러가 난다.
+    // executeCountQuery 와 같은 방식으로 select 를 비우고 집계만 남긴다.
+    const stored = await totalQb
+      .clear("select")
+      // 음수 저장값(과거 버그)은 0 으로 눌러서 더한다 — JS 쪽 Math.max 와 같은 규칙.
+      .select({
+        total: Puri.rawNumber("COALESCE(SUM(GREATEST(request_logs.cost_usd, 0)), 0)"),
+      })
+      .first();
+
+    const { qb: legacyQb } = this.getSubsetQueries("C");
+    this.applyListFilters(legacyQb, params);
+    const legacyRows = await legacyQb
+      .whereRaw("request_logs.cost_source IS NULL OR request_logs.cost_usd IS NULL")
+      .clear("select")
       .select({
-        model_name: "model_name",
-        input_tokens: "input_tokens",
-        output_tokens: "output_tokens",
-        cache_read_tokens: "cache_read_tokens",
-        cache_creation_tokens: "cache_creation_tokens",
-        cache_creation_5m_tokens: "cache_creation_5m_tokens",
-        cache_creation_1h_tokens: "cache_creation_1h_tokens",
-        cost_usd: "cost_usd",
-        cost_source: "cost_source",
+        token_name: "request_logs.token_name",
+        model_name: "request_logs.model_name",
+        input_tokens: "request_logs.input_tokens",
+        output_tokens: "request_logs.output_tokens",
+        cache_read_tokens: "request_logs.cache_read_tokens",
+        cache_creation_tokens: "request_logs.cache_creation_tokens",
+        cache_creation_5m_tokens: "request_logs.cache_creation_5m_tokens",
+        cache_creation_1h_tokens: "request_logs.cache_creation_1h_tokens",
+        cost_usd: "request_logs.cost_usd",
       });
 
-    return rows.reduce((sum, row) => {
-      // cost_source 가 있으면 새 계약으로 확정 저장된 값이다. 프로모션/가격 변경 이후에도
-      // 당시 비용을 유지한다. NULL인 legacy row 만 현재 가격표로 보정한다.
-      if (row.cost_source && row.cost_usd !== null) {
-        return sum + Math.max(row.cost_usd, 0) / MICRO_USD;
-      }
+    const storedTotal = Number(stored?.total ?? 0) / MICRO_USD;
+
+    // legacy row 는 위 SUM 에 저장값으로 이미 포함되어 있다. 재계산값과의 차액만 더한다.
+    return legacyRows.reduce((sum, row) => {
+      const alreadySummed = Math.max(row.cost_usd ?? 0, 0) / MICRO_USD;
       const usage = normalizedUsageForCost(row);
-      if (!usage.model) return sum + Math.max(row.cost_usd ?? 0, 0) / MICRO_USD;
+      if (!usage.model) return sum;
       return (
         sum +
         calculateCostUsd(usage.model, {
@@ -642,9 +687,10 @@ class RequestLogModelClass extends BaseModelClass<
           cacheCreationInputTokens: usage.cacheCreationInputTokens,
           cacheCreationInputTokens5m: usage.cacheCreationInputTokens5m,
           cacheCreationInputTokens1h: usage.cacheCreationInputTokens1h,
-        })
+        }) -
+        alreadySummed
       );
-    }, 0);
+    }, storedTotal);
   }
 
   async distinctProjectNames(): Promise<string[]> {

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

@@ -434,7 +434,19 @@ Content-Type: application/json
 ###
 
 GET {{baseUrl}}/api/qgrid/totalCost
-	?tokenName=TOKENNAME
+	?params[num]=24
+	&params[page]=1
+	&params[search]=id
+	&params[keyword]=KEYWORD
+	&params[orderBy]=id-desc
+	&params[queryMode]=both
+	&params[id]=0
+	&params[sonamuFilter]=unknown-custom
+	&params[token_name]=
+	&params[project_name]=
+	&params[model_name]=
+	&params[project_name_is_null]=false
+	&params[project_name_is_not_null]=false
 Content-Type: application/json
 
 ###

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

@@ -76,12 +76,28 @@ export const requestLogSubsetQueries = {
       is_image_generation: "request_logs.is_image_generation",
     });
   },
+  C: (qbWrapper: PuriWrapper<DatabaseSchemaExtend>) => {
+    return qbWrapper.from("request_logs").select({
+      id: "request_logs.id",
+      token_name: "request_logs.token_name",
+      model_name: "request_logs.model_name",
+      input_tokens: "request_logs.input_tokens",
+      output_tokens: "request_logs.output_tokens",
+      cache_read_tokens: "request_logs.cache_read_tokens",
+      cache_creation_tokens: "request_logs.cache_creation_tokens",
+      cache_creation_5m_tokens: "request_logs.cache_creation_5m_tokens",
+      cache_creation_1h_tokens: "request_logs.cache_creation_1h_tokens",
+      cost_usd: "request_logs.cost_usd",
+      cost_source: "request_logs.cost_source",
+    });
+  },
 };
 
 // LoaderQuery: RequestLog
 export const requestLogLoaderQueries = {
   A: [],
   P: [],
+  C: [],
 } as const satisfies PuriLoaderQueries<RequestLogSubsetKey>;
 
 // SubsetQuery: RequestLogStep

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

@@ -353,11 +353,26 @@ export const RequestLogSubsetP = z.object({
   is_image_generation: z.boolean(),
 });
 export type RequestLogSubsetP = z.infer<typeof RequestLogSubsetP>;
+export const RequestLogSubsetC = z.object({
+  id: z.int(),
+  token_name: z.string().max(100).nullable(),
+  model_name: z.string().max(255).nullable(),
+  input_tokens: z.int(),
+  output_tokens: z.int(),
+  cache_read_tokens: z.int(),
+  cache_creation_tokens: z.int(),
+  cache_creation_5m_tokens: z.int().nullable(),
+  cache_creation_1h_tokens: z.int().nullable(),
+  cost_usd: z.int().nullable(),
+  cost_source: z.string().max(20).nullable(),
+});
+export type RequestLogSubsetC = z.infer<typeof RequestLogSubsetC>;
 export type RequestLogSubsetMapping = {
   A: RequestLogSubsetA;
   P: RequestLogSubsetP;
+  C: RequestLogSubsetC;
 };
-export const RequestLogSubsetKey = z.enum(["A", "P"]);
+export const RequestLogSubsetKey = z.enum(["A", "P", "C"]);
 export type RequestLogSubsetKey = z.infer<typeof RequestLogSubsetKey>;
 
 // Subsets: RequestLogStep

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

@@ -110,3 +110,42 @@ describe("TokenModel.updateFields", () => {
     expect(update).toHaveBeenCalledWith({ weight: 4 });
   });
 });
+
+describe("TokenModel.deactivateIfActive", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  function mockKnex(responses: unknown[]) {
+    const raw = vi.fn();
+    for (const response of responses) raw.mockResolvedValueOnce(response);
+    vi.spyOn(TokenModel as unknown as { getPuri: (mode: "w") => unknown }, "getPuri").mockReturnValue(
+      { knex: { raw } } as unknown as MockPuri,
+    );
+    return raw;
+  }
+
+  it("deactivates in one statement that carries the last-token guard", async () => {
+    const raw = mockKnex([{ rowCount: 1 }]);
+
+    await expect(TokenModel.deactivateIfActive(7)).resolves.toBe(true);
+    expect(raw).toHaveBeenCalledTimes(1);
+    const sql = raw.mock.calls[0]![0] as string;
+    expect(sql).toContain("UPDATE tokens SET active = false");
+    expect(sql).toContain("count(*)");
+  });
+
+  it("returns false without a diagnostic read when the token is already inactive", async () => {
+    const raw = mockKnex([{ rowCount: 0 }, { rows: [] }]);
+
+    await expect(TokenModel.deactivateIfActive(7)).resolves.toBe(false);
+    expect(raw).toHaveBeenCalledTimes(2);
+  });
+
+  it("refuses to deactivate the provider's last active token", async () => {
+    const raw = mockKnex([{ rowCount: 0 }, { rows: [{ provider: "anthropic" }] }]);
+
+    await expect(TokenModel.deactivateIfActive(7)).resolves.toBe(false);
+    expect(raw).toHaveBeenCalledTimes(2);
+  });
+});

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

@@ -1,3 +1,4 @@
+import { getLogger } from "@logtape/logtape";
 import {
   api,
   asArray,
@@ -13,6 +14,8 @@ import { type TokenSubsetKey, type TokenSubsetMapping } from "../sonamu.generate
 import { tokenLoaderQueries, tokenSubsetQueries } from "../sonamu.generated.sso";
 import { type TokenListParams, type TokenSaveParams } from "./token.types";
 
+const logger = getLogger(["qgrid", "token"]);
+
 const DEFAULT_QUOTA_THRESHOLD = 80;
 const DEFAULT_WEIGHT = 1;
 
@@ -173,6 +176,80 @@ class TokenModelClass extends BaseModelClass<
     return wdb.transaction((trx) => trx.table("tokens").where("id", id).update(fields));
   }
 
+  /**
+   * 세션 만료 토큰을 라우팅에서 제외한다. `active=true` 조건부 갱신이므로 공유 DB 를 쓰는
+   * 여러 인스턴스가 동시에 같은 만료를 감지해도 true 를 받는 프로세스는 하나뿐이다
+   * (호출부의 알림 발송 게이트).
+   *
+   * 단, 대상이 해당 provider 의 마지막 활성 토큰이면 갱신하지 않고 false 를 반환한다.
+   * client_id 취소나 OAuth 계약 변경처럼 전 토큰이 동시에 실패하는 상황에서 풀이
+   * 통째로 비는 것을 막는 안전판이다.
+   */
+  /**
+   * 같은 계정의 기존 토큰을 지우고 새로 저장한다(로그인·재로그인 공통 경로).
+   *
+   * @returns 처음 들어온 계정인지 — 호출부의 신규 등록 알림 게이트. 재로그인은
+   *   기존 토큰을 대체하는 것이라 알릴 사건이 아니다.
+   *
+   *   provider 응답에 계정 식별자가 없으면 dedup 자체가 불가능하므로 경고만 남기고
+   *   중복 제거 없이 저장한다(죽은 row 가 남는다). 이때는 기존 토큰 유무를 알 수 없어
+   *   신규로 보지 않는다 — 재로그인을 신규로 잘못 알리는 편보다 조용한 편이 낫다.
+   */
+  async replaceByAccount(
+    provider: string,
+    accountId: string | undefined,
+    saveParams: TokenSaveParams,
+  ): Promise<{ isNew: boolean }> {
+    let isNew = false;
+    if (accountId) {
+      const oldEntries = await this.findByAccountIdentifier("A", provider, accountId);
+      if (oldEntries.length > 0) {
+        await this.del(oldEntries.map((o) => o.id));
+      } else {
+        isNew = true;
+      }
+    } else {
+      logger.warn(
+        `${provider} login without account identifier: dedup skipped for ${saveParams.name ?? "unnamed"}`,
+      );
+    }
+
+    await this.save([saveParams]);
+    return { isNew };
+  }
+
+  async deactivateIfActive(id: number): Promise<boolean> {
+    const wdb = this.getPuri("w");
+
+    // 활성 여부와 "마지막 남은 토큰인가"를 한 statement 안에서 판정한다. 두 조건을
+    // 따로 읽고 나중에 갱신하면 그 사이에 다른 인스턴스가 같은 provider 의 토큰을
+    // 비활성화해 풀이 통째로 빌 수 있다.
+    const updated = await wdb.knex.raw<{ rowCount: number }>(
+      `UPDATE tokens SET active = false
+       WHERE id = ? AND active = true
+         AND (SELECT count(*) FROM tokens peer
+              WHERE peer.provider = tokens.provider AND peer.active) > 1`,
+      [id],
+    );
+    if ((updated.rowCount ?? 0) > 0) return true;
+
+    // 갱신되지 않은 이유는 둘 중 하나다: 이미 비활성이거나(정상 경쟁 결과), 마지막
+    // 활성 토큰이거나. 후자는 systemic 실패 신호라 남겨야 하므로 이때만 한 번 더 읽는다.
+    const survivor = (
+      await wdb.knex.raw<{ rows: { provider: string }[] }>(
+        "SELECT provider FROM tokens WHERE id = ? AND active = true",
+        [id],
+      )
+    ).rows[0];
+    if (survivor) {
+      logger.error(
+        `refusing to auto-deactivate token ${id}: last active ${survivor.provider} token — ` +
+          `systemic refresh failure suspected, keeping the pool non-empty`,
+      );
+    }
+    return false;
+  }
+
   @api({ httpMethod: "POST", clients: ["axios", "tanstack-mutation"] })
   async reorder(ids: number[]): Promise<{ done: boolean }> {
     const wdb = this.getPuri("w");

package/bundle/src/migrations/20260807133553_manual__backfill_request_log_cost.ts

@@ -0,0 +1,110 @@
+/**
+ * legacy request_logs 의 비용을 확정값으로 백필한다.
+ *
+ * 배경: `cost_source` 가 없는 row 는 조회할 때마다 앱이 현재 가격표로 재계산해 왔다
+ * (`normalizeLegacyAnthropicRow`). 입력이 고정이라 결과도 항상 같은데, 96만 행 테이블에서
+ * 23.6만 행을 매 요청 앱으로 끌어오는 비용만 남는다. 한 번 계산해 저장하면 총비용 집계가
+ * 단일 SQL SUM 으로 끝난다.
+ *
+ * 계산식은 앱의 `normalizedUsageForCost` + `calculateCostUsd` 를 그대로 옮긴 것이다.
+ * 두 로직이 갈라지면 백필된 값과 신규 저장값의 기준이 달라지므로, 가격표를 바꿀 때는
+ * 이 마이그레이션이 아니라 앱 코드만 바꾸면 된다(이미 확정된 값은 유지되는 것이 계약).
+ *
+ * 되돌리기: down 은 `cost_source='backfilled'` 인 row 의 표식만 제거해 재계산 대상으로
+ * 되돌린다. 원본 `cost_usd` 는 복원되지 않는다 — 되돌릴 수 없는 쓰기다. 덮이는 값은
+ * NULL 이었거나, 음수였거나, 구버전 가격표로 계산된 값이고, 조회 경로는 이들을 그대로
+ * 보여준 적이 없다(항상 현재 가격표로 재계산해 표시). 그래서 화면에 보이던 총액은
+ * 백필 전후로 동일하며, 실질 손실은 없다.
+ */
+import { type Knex } from "knex";
+
+// 마이그레이션 러너는 tsconfig 의 bundler 해석을 쓰지 않는 순수 ESM 로더라 확장자가 필요하다.
+import { calculateCostUsd } from "../utils/providers/common/model-cost.js";
+
+const MICRO_USD = 1_000_000;
+const CHUNK_SIZE = 5_000;
+
+type LegacyRow = {
+  id: number;
+  token_name: string | null;
+  model_name: string | null;
+  input_tokens: number;
+  output_tokens: number;
+  cache_read_tokens: number;
+  cache_creation_tokens: number;
+  cache_creation_5m_tokens: number | null;
+  cache_creation_1h_tokens: number | null;
+  cost_usd: number | null;
+};
+
+function isAnthropicRow(row: LegacyRow): boolean {
+  return (
+    row.token_name?.startsWith("anthropic/") === true ||
+    row.model_name?.startsWith("claude-") === true ||
+    row.model_name?.startsWith("anthropic/claude-") === true
+  );
+}
+
+function backfilledCostMicroUsd(row: LegacyRow): number {
+  if (!row.model_name) return Math.max(row.cost_usd ?? 0, 0);
+
+  // Anthropic 은 input/cache_read/cache_creation 을 상호 배타적으로 보고한다. 과거 저장 경로가
+  // 이를 합치지 않아 input_tokens 가 작게 남은 row 를 복원한다.
+  const splitInput =
+    isAnthropicRow(row) && row.input_tokens < row.cache_read_tokens + row.cache_creation_tokens;
+  const inputTokens = splitInput
+    ? row.input_tokens + row.cache_read_tokens + row.cache_creation_tokens
+    : row.input_tokens;
+
+  const model = row.model_name.includes("/") ? row.model_name.split("/").pop()! : row.model_name;
+  const usd = calculateCostUsd(model, {
+    inputTokens,
+    outputTokens: row.output_tokens,
+    cachedInputTokens: row.cache_read_tokens,
+    cacheCreationInputTokens: row.cache_creation_tokens,
+    ...(row.cache_creation_5m_tokens !== null
+      ? { cacheCreationInputTokens5m: row.cache_creation_5m_tokens }
+      : {}),
+    ...(row.cache_creation_1h_tokens !== null
+      ? { cacheCreationInputTokens1h: row.cache_creation_1h_tokens }
+      : {}),
+  });
+  return Math.max(Math.round(usd * MICRO_USD), 0);
+}
+
+export async function up(knex: Knex): Promise<void> {
+  let lastId = 0;
+  let processed = 0;
+
+  for (;;) {
+    const { rows } = await knex.raw<{ rows: LegacyRow[] }>(
+      `SELECT id, token_name, model_name, input_tokens, output_tokens,
+              cache_read_tokens, cache_creation_tokens,
+              cache_creation_5m_tokens, cache_creation_1h_tokens, cost_usd
+         FROM request_logs
+        WHERE (cost_source IS NULL OR cost_usd IS NULL) AND id > ?
+        ORDER BY id
+        LIMIT ?`,
+      [lastId, CHUNK_SIZE],
+    );
+    if (rows.length === 0) break;
+
+    // chunk 당 한 번의 UPDATE ... FROM (VALUES ...) 로 왕복을 줄인다.
+    const values = rows.map((row) => `(${row.id}, ${backfilledCostMicroUsd(row)})`).join(",");
+    await knex.raw(
+      `UPDATE request_logs AS t
+          SET cost_usd = v.cost_usd, cost_source = 'backfilled'
+         FROM (VALUES ${values}) AS v(id, cost_usd)
+        WHERE t.id = v.id`,
+    );
+
+    lastId = rows[rows.length - 1]!.id;
+    processed += rows.length;
+  }
+
+  console.log(`[backfill] request_logs cost backfilled: ${processed} rows`);
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.raw(`UPDATE request_logs SET cost_source = NULL WHERE cost_source = 'backfilled'`);
+}

package/bundle/src/migrations/20260807145144_alter_request_logs_alter1.ts

@@ -0,0 +1,13 @@
+import { type Knex } from "knex";
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.raw(
+    `CREATE INDEX request_logs_project_name_cost_usd_index ON request_logs USING btree(project_name ASC NULLS LAST, cost_usd ASC NULLS LAST);`,
+  );
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable("request_logs", (table) => {
+    table.dropIndex(["project_name", "cost_usd"], "request_logs_project_name_cost_usd_index");
+  });
+}

package/bundle/src/utils/providers/openai/openai-refresh.ts

@@ -8,6 +8,7 @@
  */
 import { getLogger } from "@logtape/logtape";
 
+import { deactivateAuthDeadToken } from "../../../application/qgrid/token-death";
 import { TokenModel } from "../../../application/token/token.model";
 import { type OpenAICredentials } from "../../../application/token/token.types";
 
@@ -15,6 +16,13 @@ const logger = getLogger(["qgrid", "openai-refresh"]);
 
 import { OPENAI_CLIENT_ID, OPENAI_TOKEN_URL } from "./openai-constants";
 
+// 재로그인 외 복구 불가한 refresh 실패 코드. 어느 것이든 토큰이 죽었다는 확정 신호다.
+const PERMANENT_FAILURE_CODES = new Set([
+  "refresh_token_expired",
+  "refresh_token_reused",
+  "refresh_token_invalidated",
+]);
+
 // per-token inflight promise dedup + minimum interval
 const inflightRefresh = new Map<number, Promise<RefreshResult>>();
 const lastRefreshTime = new Map<number, number>();
@@ -100,6 +108,15 @@ async function doRefresh(tokenId: number): Promise<RefreshResult> {
       `OpenAI refresh FAILED token=${token.name}(id=${tokenId}) status=${resp.status} ` +
         `code=${errorCode ?? "?"} body=${body}`,
     );
+    // 영구 실패는 errorCode 로만 판정한다 — status 를 함께 요구하면 provider 가
+    // 상태코드를 바꿀 때 판정이 조용히 멎는다.
+    if (errorCode && PERMANENT_FAILURE_CODES.has(errorCode)) {
+      await deactivateAuthDeadToken(
+        { id: tokenId, name: token.name, provider: "openai" },
+        creds.refreshToken,
+        `openai:${errorCode}`,
+      );
+    }
     throw new Error(`OpenAI refresh failed: ${resp.status} ${body}`);
   }
 

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

@@ -0,0 +1,97 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { notifySlack, SLACK_COLOR } from "./slack-notify";
+
+describe("notifySlack", () => {
+  const savedToken = process.env.SLACK_BOT_TOKEN;
+  const savedChannel = process.env.SLACK_CHANNEL_ID;
+
+  beforeEach(() => {
+    process.env.SLACK_BOT_TOKEN = "xoxb-test";
+    process.env.SLACK_CHANNEL_ID = "C123";
+  });
+
+  afterEach(() => {
+    if (savedToken === undefined) delete process.env.SLACK_BOT_TOKEN;
+    else process.env.SLACK_BOT_TOKEN = savedToken;
+    if (savedChannel === undefined) delete process.env.SLACK_CHANNEL_ID;
+    else process.env.SLACK_CHANNEL_ID = savedChannel;
+    vi.restoreAllMocks();
+  });
+
+  it("posts the message to the configured channel", async () => {
+    const fetchMock = vi
+      .spyOn(globalThis, "fetch")
+      .mockResolvedValue(new Response(JSON.stringify({ ok: true })));
+
+    await notifySlack({
+      title: "토큰 추가",
+      subject: "anthropic/test-token",
+      context: "anthropic · 요청 처리에 사용됩니다",
+      color: SLACK_COLOR.good,
+    });
+
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    const [url, init] = fetchMock.mock.calls[0]!;
+    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: [
+        {
+          color: SLACK_COLOR.good,
+          blocks: [
+            {
+              type: "section",
+              text: { type: "mrkdwn", text: "*토큰 추가*  `anthropic/test-token`" },
+            },
+            {
+              type: "context",
+              elements: [{ type: "mrkdwn", text: "anthropic · 요청 처리에 사용됩니다" }],
+            },
+          ],
+        },
+      ],
+    });
+    expect((init as RequestInit).signal).toBeDefined();
+  });
+
+  it("omits the context block and color when they are not given", async () => {
+    const fetchMock = vi
+      .spyOn(globalThis, "fetch")
+      .mockResolvedValue(new Response(JSON.stringify({ ok: true })));
+
+    await notifySlack({ title: "제목만" });
+
+    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("제목만");
+    expect(body.attachments[0].color).toBeUndefined();
+    expect(body.attachments[0].blocks).toHaveLength(1);
+  });
+
+  it("skips the request entirely when env is not configured", async () => {
+    delete process.env.SLACK_BOT_TOKEN;
+    const fetchMock = vi.spyOn(globalThis, "fetch");
+
+    await expect(notifySlack({ title: "hello" })).resolves.toBeUndefined();
+
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+
+  it("warns without throwing when Slack replies 200 with ok:false", async () => {
+    vi.spyOn(globalThis, "fetch").mockResolvedValue(
+      new Response(JSON.stringify({ ok: false, error: "not_in_channel" })),
+    );
+
+    await expect(notifySlack({ title: "hello" })).resolves.toBeUndefined();
+  });
+
+  it("swallows network and timeout failures", async () => {
+    vi.spyOn(globalThis, "fetch").mockRejectedValue(new Error("timed out"));
+
+    await expect(notifySlack({ title: "hello" })).resolves.toBeUndefined();
+  });
+});