@cartanova/qgrid-cli 2.6.7 → 2.6.9

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

@@ -1,6 +1,20 @@
-import { describe, expect, it } from "vitest";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
-import { buildReminderContext } from "./expired-token-reminder";
+const { findInactiveMock, getSettingMock, notifySlackMock } = vi.hoisted(() => ({
+  findInactiveMock: vi.fn(),
+  getSettingMock: vi.fn(),
+  notifySlackMock: vi.fn(),
+}));
+
+import {
+  buildReminderContext,
+  type ExpiredTokenReminderDeps,
+  rescheduleExpiredTokenReminder,
+  sendExpiredTokenReminderNow,
+  startExpiredTokenReminder,
+  stopExpiredTokenReminder,
+} from "./expired-token-reminder";
+import { getSlackUserMap } from "./slack-user-map";
 
 const userMap = new Map([
   ["yds", "U09NAJUQSFQ"],
@@ -71,3 +85,134 @@ describe("buildReminderContext", () => {
     ]);
   });
 });
+
+describe("expired token reminder scheduling", () => {
+  let minutes = "10";
+  let rawUserMap = "yds:U-OLD";
+  let remindersEnabled = "true";
+  let deps: ExpiredTokenReminderDeps;
+
+  beforeEach(() => {
+    vi.useFakeTimers();
+    minutes = "10";
+    rawUserMap = "yds:U-OLD";
+    remindersEnabled = "true";
+    findInactiveMock.mockReset();
+    getSettingMock.mockReset();
+    notifySlackMock.mockReset();
+    findInactiveMock.mockResolvedValue([{ name: "anthropic/yds", provider: "anthropic" }]);
+    getSettingMock.mockImplementation((key: string) => {
+      if (key === "slack.expiryReminderMinutes") return minutes;
+      if (key === "slack.userMap") return rawUserMap;
+      if (key === "slack.remindersEnabled") return remindersEnabled;
+      return undefined;
+    });
+    notifySlackMock.mockResolvedValue(undefined);
+    deps = {
+      findInactive: findInactiveMock,
+      getSlackUserMap: () => getSlackUserMap(getSettingMock),
+      readSetting: getSettingMock,
+      sendSlack: notifySlackMock,
+    };
+  });
+
+  afterEach(() => {
+    stopExpiredTokenReminder();
+    vi.useRealTimers();
+  });
+
+  it("부팅 시 만료 토큰을 즉시 한 번 알린다", async () => {
+    startExpiredTokenReminder(deps);
+    await vi.advanceTimersByTimeAsync(0);
+
+    expect(notifySlackMock).toHaveBeenCalledTimes(1);
+  });
+
+  it("반복을 끄면 부팅해도 알리지 않는다", async () => {
+    remindersEnabled = "false";
+
+    startExpiredTokenReminder(deps);
+    await vi.advanceTimersByTimeAsync(0);
+    await vi.advanceTimersByTimeAsync(10 * 60_000);
+
+    expect(notifySlackMock).not.toHaveBeenCalled();
+  });
+
+  it("반복을 꺼도 주기 값은 남아 다시 켜면 그대로 쓴다", async () => {
+    remindersEnabled = "false";
+    rescheduleExpiredTokenReminder(deps);
+
+    remindersEnabled = "true";
+    rescheduleExpiredTokenReminder(deps);
+    await vi.advanceTimersByTimeAsync(10 * 60_000);
+
+    // 저장된 10분 주기가 그대로 살아 있다.
+    expect(notifySlackMock).toHaveBeenCalledTimes(1);
+  });
+
+  it("수동 트리거는 조용 시간을 통과하도록 urgent 로 보낸다", async () => {
+    // 사람이 직접 누른 것이라 밤이라고 삼키면 버튼이 고장 난 것으로 읽힌다.
+    const sent = await sendExpiredTokenReminderNow(deps);
+
+    expect(sent).toBe(1);
+    expect(notifySlackMock).toHaveBeenCalledWith(expect.objectContaining({ urgent: true }));
+  });
+
+  it("보낼 대상이 없으면 0을 돌려주고 아무것도 보내지 않는다", async () => {
+    findInactiveMock.mockResolvedValue([]);
+
+    const sent = await sendExpiredTokenReminderNow(deps);
+
+    expect(sent).toBe(0);
+    expect(notifySlackMock).not.toHaveBeenCalled();
+  });
+
+  it("start를 다시 호출해도 interval은 하나만 남는다", async () => {
+    startExpiredTokenReminder(deps);
+    startExpiredTokenReminder(deps);
+    await vi.advanceTimersByTimeAsync(0);
+    notifySlackMock.mockClear();
+
+    await vi.advanceTimersByTimeAsync(10 * 60_000);
+
+    expect(notifySlackMock).toHaveBeenCalledTimes(1);
+  });
+
+  it("설정 변경은 즉시 알리지 않고 새 주기로 재예약한다", async () => {
+    startExpiredTokenReminder(deps);
+    await vi.advanceTimersByTimeAsync(0);
+    notifySlackMock.mockClear();
+    minutes = "20";
+
+    rescheduleExpiredTokenReminder(deps);
+    await vi.advanceTimersByTimeAsync(19 * 60_000);
+    expect(notifySlackMock).not.toHaveBeenCalled();
+
+    await vi.advanceTimersByTimeAsync(60_000);
+    expect(notifySlackMock).toHaveBeenCalledTimes(1);
+  });
+
+  it.each(["0", "-1", "not-a-number"])("%s로 재설정하면 기존 타이머를 멈춘다", async (next) => {
+    startExpiredTokenReminder(deps);
+    await vi.advanceTimersByTimeAsync(0);
+    notifySlackMock.mockClear();
+    minutes = next;
+
+    rescheduleExpiredTokenReminder(deps);
+    await vi.advanceTimersByTimeAsync(20 * 60_000);
+
+    expect(notifySlackMock).not.toHaveBeenCalled();
+  });
+
+  it("각 실행 시점의 최신 Slack 사용자 매핑을 사용한다", async () => {
+    startExpiredTokenReminder(deps);
+    await vi.advanceTimersByTimeAsync(0);
+    expect(notifySlackMock.mock.calls[0]![0]).toMatchObject({ context: "<@U-OLD>\n재로그인이 필요합니다" });
+    notifySlackMock.mockClear();
+    rawUserMap = "yds:U-NEW";
+
+    await vi.advanceTimersByTimeAsync(10 * 60_000);
+
+    expect(notifySlackMock.mock.calls[0]![0]).toMatchObject({ context: "<@U-NEW>\n재로그인이 필요합니다" });
+  });
+});

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

@@ -13,6 +13,7 @@
 import { getLogger } from "@logtape/logtape";
 
 import { notifySlack, SLACK_COLOR } from "../../utils/slack-notify";
+import { getSetting } from "../setting/setting.store";
 import { TokenModel } from "../token/token.model";
 import { getSlackUserMap, mentionFor } from "./slack-user-map";
 
@@ -20,6 +21,20 @@ const logger = getLogger(["qgrid", "expired-reminder"]);
 
 const MINUTE_MS = 60_000;
 
+export type ExpiredTokenReminderDeps = {
+  findInactive: () => Promise<{ name: string | null; provider: string }[]>;
+  getSlackUserMap: () => Map<string, string>;
+  readSetting: typeof getSetting;
+  sendSlack: typeof notifySlack;
+};
+
+const defaultDeps: ExpiredTokenReminderDeps = {
+  findInactive: () => TokenModel.findInactive("A"),
+  getSlackUserMap,
+  readSetting: getSetting,
+  sendSlack: notifySlack,
+};
+
 /**
  * 1건이면 제목(subject)에 토큰명이 이미 있으므로 본문에서는 뺀다 — 같은 이름을 두 번 쓰면
  * 읽는 사람이 다른 정보인 줄 알고 한 번 더 본다. 여러 건이면 제목이 건수라 본문에 남긴다.
@@ -38,42 +53,77 @@ export function buildReminderContext(
   return [...lines, "재로그인이 필요합니다"].filter(Boolean).join("\n");
 }
 
-async function sendReminder(userMap: Map<string, string>): Promise<void> {
-  const inactive = await TokenModel.findInactive("A");
-  if (inactive.length === 0) return;
+async function sendReminder(deps: ExpiredTokenReminderDeps, urgent = false): Promise<number> {
+  const inactive = await deps.findInactive();
+  if (inactive.length === 0) return 0;
 
-  await notifySlack({
+  const userMap = deps.getSlackUserMap();
+
+  await deps.sendSlack({
     // 만료 순간 알림과 같은 제목을 쓴다. 같은 사건이므로 다른 이름을 붙이면 별개 문제로 읽힌다.
     title: "세션 만료",
     subject: inactive.length > 1 ? `${inactive.length}건` : (inactive[0]!.name ?? "unnamed"),
     context: buildReminderContext(inactive, userMap),
     color: SLACK_COLOR.bad,
+    urgent,
   });
+  return inactive.length;
 }
 
-let timer: ReturnType<typeof setInterval> | null = null;
-
 /**
- * `SLACK_EXPIRY_REMINDER_INTERVAL_MINUTES` 가 양수일 때만 켜진다. 미설정·0 이면 비활성.
+ * 화면의 "지금 보내기". 사람이 직접 누른 것이므로 조용 시간·마스터 스위치를 통과시킨다 —
+ * 눌렀는데 아무 일도 안 일어나면 버튼이 고장 난 것으로 읽힌다.
  *
- * 인스턴스가 여러 개면 각자 보낸다. 만료 순간 알림과 달리 상태 변화가 없어 DB 로 억제할 수
- * 없고, 하루 몇 건 수준이라 중복을 감수하는 편이 잠금 장치를 두는 것보다 낫다.
+ * 보낸 건수를 돌려줘 호출부가 "보낼 대상 없음"과 "보냄"을 구분해 보여준다.
  */
-export function startExpiredTokenReminder(): void {
-  const minutes = Number(process.env.SLACK_EXPIRY_REMINDER_INTERVAL_MINUTES ?? 0);
+export function sendExpiredTokenReminderNow(
+  deps: ExpiredTokenReminderDeps = defaultDeps,
+): Promise<number> {
+  return sendReminder(deps, true);
+}
+
+let timer: ReturnType<typeof setInterval> | null = null;
+
+function scheduleExpiredTokenReminder(runNow: boolean, deps: ExpiredTokenReminderDeps): void {
+  stopExpiredTokenReminder();
+
+  // 주기 값과 별개인 스위치다. 꺼도 주기는 남아 있어 다시 켤 때 고르던 값이 그대로다.
+  if (deps.readSetting("slack.remindersEnabled", "SLACK_REMINDERS_ENABLED") === "false") {
+    logger.info("expired token reminder disabled");
+    return;
+  }
+
+  const minutes = Number(
+    deps.readSetting("slack.expiryReminderMinutes", "SLACK_EXPIRY_REMINDER_INTERVAL_MINUTES") ?? 0,
+  );
   if (!Number.isFinite(minutes) || minutes <= 0) return;
 
-  const userMap = getSlackUserMap();
-  logger.info(`expired token reminder every ${minutes}m (${userMap.size} user mappings)`);
+  logger.info(
+    `expired token reminder every ${minutes}m (${deps.getSlackUserMap().size} user mappings)`,
+  );
 
   const run = () =>
-    sendReminder(userMap).catch((e) => logger.warn(`reminder failed: ${(e as Error).message}`));
+    sendReminder(deps).catch((e) => logger.warn(`reminder failed: ${(e as Error).message}`));
+
+  if (runNow) void run();
+  timer = setInterval(run, minutes * MINUTE_MS);
+}
 
+/**
+ * `SLACK_EXPIRY_REMINDER_INTERVAL_MINUTES` 가 양수일 때만 켜진다. 미설정·0 이면 비활성.
+ *
+ * 인스턴스가 여러 개면 각자 보낸다. 만료 순간 알림과 달리 상태 변화가 없어 DB 로 억제할 수
+ * 없고, 하루 몇 건 수준이라 중복을 감수하는 편이 잠금 장치를 두는 것보다 낫다.
+ */
+export function startExpiredTokenReminder(deps: ExpiredTokenReminderDeps = defaultDeps): void {
   // 기동 직후에도 한 번 보낸다. 재기동은 배포나 장애 복구 때 일어나는데, 그 시점에 이미
   // 만료된 토큰이 있으면 첫 주기가 돌 때까지 조용한 것이 이상하다.
-  void run();
+  scheduleExpiredTokenReminder(true, deps);
+}
 
-  timer = setInterval(run, minutes * MINUTE_MS);
+/** 설정 변경 시 기존 타이머만 새 주기로 교체한다. 저장 자체가 알림을 보내지는 않는다. */
+export function rescheduleExpiredTokenReminder(deps: ExpiredTokenReminderDeps = defaultDeps): void {
+  scheduleExpiredTokenReminder(false, deps);
 }
 
 export function stopExpiredTokenReminder(): void {

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

@@ -0,0 +1,23 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+import { getSlackUserMap } from "./slack-user-map";
+
+const getSettingMock = vi.fn();
+
+describe("getSlackUserMap", () => {
+  let raw = "yds:U-OLD";
+
+  beforeEach(() => {
+    raw = "yds:U-OLD";
+    getSettingMock.mockReset();
+    getSettingMock.mockImplementation(() => raw);
+  });
+
+  it("설정이 바뀌면 다음 조회부터 새 매핑을 사용한다", () => {
+    expect(getSlackUserMap(getSettingMock).get("yds")).toBe("U-OLD");
+
+    raw = "yds:U-NEW";
+
+    expect(getSlackUserMap(getSettingMock).get("yds")).toBe("U-NEW");
+  });
+});

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

@@ -9,6 +9,8 @@
  * 맞는 동작이다.
  */
 
+import { getSetting } from "../setting/setting.store";
+
 /** `토큰명:SlackUserId` 목록을 파싱한다. */
 export function parseSlackUserMap(raw: string | undefined): Map<string, string> {
   const map = new Map<string, string>();
@@ -34,18 +36,6 @@ export function mentionFor(tokenName: string | null, userMap: Map<string, string
   return userId ? `<@${userId}>` : "";
 }
 
-/**
- * 환경변수는 프로세스 수명 동안 고정이라 매번 파싱할 이유가 없다. 사망 알림은 요청 경로에서
- * 호출되므로 캐시해 둔다.
- */
-let cached: Map<string, string> | null = null;
-
-export function getSlackUserMap(): Map<string, string> {
-  cached ??= parseSlackUserMap(process.env.SLACK_USER_MAP);
-  return cached;
-}
-
-/** 테스트에서 env 를 바꿔 끼울 때 쓴다. */
-export function resetSlackUserMapCache(): void {
-  cached = null;
+export function getSlackUserMap(readSetting: typeof getSetting = getSetting): Map<string, string> {
+  return parseSlackUserMap(readSetting("slack.userMap", "SLACK_USER_MAP"));
 }

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

@@ -89,6 +89,8 @@ function notifyLastActiveTokenDying(token: DeadTokenRef, reasonCode: string): vo
       ` · 풀이 비지 않도록 유지 중입니다. ` +
       `전 토큰이 동시에 실패했다면 client_id 취소나 OAuth 계약 변경을 의심하세요`,
     color: SLACK_COLOR.bad,
+    // provider 전체가 죽었다는 신호다. 조용 시간에 묻히면 다음 근무일까지 서비스가 멈춘다.
+    urgent: true,
   });
 }
 

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

@@ -19,7 +19,13 @@ function createSSRQuery(
 
 import { RequestLogStepListParams } from "./request-log-step/request-log-step.types";
 import { RequestLogListParams } from "./request-log/request-log.types";
-import { TokenSubsetKey, RequestLogStepSubsetKey, RequestLogSubsetKey } from "./sonamu.generated";
+import { SettingListParams } from "./setting/setting.types";
+import {
+  TokenSubsetKey,
+  SettingSubsetKey,
+  RequestLogStepSubsetKey,
+  RequestLogSubsetKey,
+} from "./sonamu.generated";
 import { TokenListParams } from "./token/token.types";
 
 export namespace TokenService {
@@ -33,6 +39,20 @@ export namespace TokenService {
     createSSRQuery("TokenModel", "findMany", [subset, rawParams], ["Token", "getTokens"]);
 }
 
+export namespace SettingService {
+  export const getSetting = <T extends SettingSubsetKey>(subset: T, id: number): SSRQuery =>
+    createSSRQuery("SettingModel", "findById", [subset, id], ["Setting", "getSetting"]);
+
+  export const getSettings = <T extends SettingSubsetKey, LP extends SettingListParams>(
+    subset: T,
+    rawParams?: LP,
+  ): SSRQuery =>
+    createSSRQuery("SettingModel", "findMany", [subset, rawParams], ["Setting", "getSettings"]);
+
+  export const getSettingList = (): SSRQuery =>
+    createSSRQuery("SettingModel", "listSettings", [], ["Setting", "getSettingList"]);
+}
+
 export namespace RequestLogStepService {
   export const getRequestLogStep = <T extends RequestLogStepSubsetKey>(
     subset: T,

package/bundle/src/application/setting/setting.constant.test.ts

@@ -0,0 +1,109 @@
+import { describe, expect, it } from "vitest";
+
+import { findSettingDef, maskSecret, SETTING_DEFS, validateSettingValue } from "./setting.constant";
+
+describe("validateSettingValue", () => {
+  const intDef = findSettingDef("openai.maxWorkersPerToken")!;
+  const boolDef = findSettingDef("openai.autoscale")!;
+  const numDef = findSettingDef("openai.maxEstimatedRssGiB")!;
+
+  it("정수 범위를 벗어나면 거부한다", () => {
+    // 저장을 막지 않으면 런타임에서 조용히 기본값으로 떨어져 원인을 찾기 어렵다.
+    expect(validateSettingValue(intDef, "21")).toMatchObject({ ok: false });
+    expect(validateSettingValue(intDef, "0")).toMatchObject({ ok: false });
+    expect(validateSettingValue(intDef, "20")).toMatchObject({ ok: true, value: "20" });
+  });
+
+  it("정수 자리에 소수를 넣으면 거부한다", () => {
+    expect(validateSettingValue(intDef, "3.5")).toMatchObject({ ok: false });
+  });
+
+  it("숫자가 아닌 값을 거부한다", () => {
+    expect(validateSettingValue(intDef, "많이")).toMatchObject({ ok: false });
+  });
+
+  it("실수 설정은 소수를 허용한다", () => {
+    expect(validateSettingValue(numDef, "16.5")).toMatchObject({ ok: true, value: "16.5" });
+  });
+
+  it("boolean 은 true/false 만 받는다", () => {
+    expect(validateSettingValue(boolDef, "true")).toMatchObject({ ok: true });
+    expect(validateSettingValue(boolDef, "false")).toMatchObject({ ok: true });
+    expect(validateSettingValue(boolDef, "1")).toMatchObject({ ok: false });
+  });
+
+  it("앞뒤 공백은 저장 전에 떨어뜨린다", () => {
+    expect(validateSettingValue(intDef, "  7  ")).toMatchObject({ ok: true, value: "7" });
+  });
+});
+
+describe("preset 검증", () => {
+  const presetDef = findSettingDef("slack.expiryReminderMinutes")!;
+
+  it("목록에 있는 값만 받는다", () => {
+    expect(validateSettingValue(presetDef, "30")).toMatchObject({ ok: true, value: "30" });
+    expect(validateSettingValue(presetDef, "180")).toMatchObject({ ok: true });
+  });
+
+  it("목록 밖의 값은 거부한다", () => {
+    // 저장되면 화면에서 아무 버튼도 선택돼 보이지 않아 "왜 안 바뀌지"가 된다.
+    expect(validateSettingValue(presetDef, "45")).toMatchObject({ ok: false });
+    expect(validateSettingValue(presetDef, "0")).toMatchObject({ ok: false });
+    expect(validateSettingValue(presetDef, "많이")).toMatchObject({ ok: false });
+  });
+});
+
+describe("조용 시간 설정", () => {
+  // fallback("20"/"8")은 quiet-hours.ts 의 DEFAULT_QUIET_* 와 같아야 하지만 테스트로 묶지
+  // 않는다 — 두 모듈을 한 파일에서 import 하면 setting.store → token.model 이 딸려와,
+  // token.model 을 mock 하는 테스트가 같은 워커에 배치될 때 실제 모듈을 먼저 로드해 버린다.
+  it("0..23 을 벗어나면 거부한다", () => {
+    const fromDef = findSettingDef("slack.quietFromHour")!;
+    expect(validateSettingValue(fromDef, "24")).toMatchObject({ ok: false });
+    expect(validateSettingValue(fromDef, "-1")).toMatchObject({ ok: false });
+    expect(validateSettingValue(fromDef, "0")).toMatchObject({ ok: true });
+    expect(validateSettingValue(fromDef, "23")).toMatchObject({ ok: true });
+  });
+});
+
+describe("maskSecret", () => {
+  it("긴 값은 앞뒤만 남긴다", () => {
+    expect(maskSecret("xoxb-1234567890-abcdefghij")).toBe("xoxb-123...ghij");
+  });
+
+  it("짧은 값은 통째로 가린다", () => {
+    // 앞뒤를 남기면 짧은 값은 사실상 전부 노출된다.
+    expect(maskSecret("short")).toBe("***");
+  });
+});
+
+describe("SETTING_DEFS", () => {
+  it("키가 중복되지 않는다", () => {
+    const keys = SETTING_DEFS.map((d) => d.key);
+    expect(new Set(keys).size).toBe(keys.length);
+  });
+
+  it("env 키도 중복되지 않는다", () => {
+    // 겹치면 한 env 를 두 설정이 서로 덮어쓴다.
+    const envKeys = SETTING_DEFS.map((d) => d.envKey);
+    expect(new Set(envKeys).size).toBe(envKeys.length);
+  });
+
+  it("정의되지 않은 키는 찾지 못한다", () => {
+    expect(findSettingDef("nope.bad")).toBeUndefined();
+  });
+
+  it("64 GiB 호스트 기준 메모리 설정의 오입력 상한을 둔다", () => {
+    const rss = findSettingDef("openai.maxEstimatedRssGiB")!;
+    const available = findSettingDef("openai.minHostAvailableGiB")!;
+
+    expect(rss.max).toBe(32);
+    expect(available.max).toBe(64);
+    expect(validateSettingValue(rss, "32")).toMatchObject({ ok: true });
+    expect(validateSettingValue(rss, "32.5")).toMatchObject({ ok: false });
+    expect(validateSettingValue(available, "64")).toMatchObject({ ok: true });
+    expect(validateSettingValue(available, "64.5")).toMatchObject({ ok: false });
+    expect(rss.help).toContain("OOM");
+    expect(available.help).toContain("오토스케일");
+  });
+});