@cartanova/qgrid-cli 2.6.8 → 2.6.10

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

@@ -37,20 +37,35 @@ function buildReminderContext(tokens, userMap) {
 		return mention ? `${mention} ${label}` : label;
 	}), "재로그인이 필요합니다"].filter(Boolean).join("\n");
 }
-async function sendReminder(deps) {
+async function sendReminder(deps, urgent = false) {
 	const inactive = await deps.findInactive();
-	if (inactive.length === 0) return;
+	if (inactive.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),
-		color: SLACK_COLOR.bad
+		color: SLACK_COLOR.bad,
+		urgent
 	});
+	return inactive.length;
+}
+/**
+* 화면의 "지금 보내기". 사람이 직접 누른 것이므로 조용 시간·마스터 스위치를 통과시킨다 —
+* 눌렀는데 아무 일도 안 일어나면 버튼이 고장 난 것으로 읽힌다.
+*
+* 보낸 건수를 돌려줘 호출부가 "보낼 대상 없음"과 "보냄"을 구분해 보여준다.
+*/
+function sendExpiredTokenReminderNow(deps = defaultDeps) {
+	return sendReminder(deps, true);
 }
 let timer = null;
 function scheduleExpiredTokenReminder(runNow, deps) {
 	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;
 	logger.info(`expired token reminder every ${minutes}m (${deps.getSlackUserMap().size} user mappings)`);
@@ -77,6 +92,6 @@ function stopExpiredTokenReminder() {
 	timer = null;
 }
 //#endregion
-export { buildReminderContext, rescheduleExpiredTokenReminder, startExpiredTokenReminder, stopExpiredTokenReminder };
+export { buildReminderContext, rescheduleExpiredTokenReminder, sendExpiredTokenReminderNow, startExpiredTokenReminder, stopExpiredTokenReminder };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"expired-token-reminder.js","names":[],"sources":["../../../src/application/qgrid/expired-token-reminder.ts"],"sourcesContent":["/**\n * 세션 만료 알림 반복.\n *\n * 만료 순간의 알림(`token-death.ts`)은 그때 채널을 보지 않으면 놓친다. 재로그인은 사람이\n * 해야 하는 일이라 놓치면 토큰이 계속 빠진 채로 남는다. 그래서 아직 재로그인되지 않은\n * 토큰을 같은 문구로 다시 알린다 — 사건이 하나이므로 알림도 한 종류다.\n *\n * 여러 토큰이 만료돼 있으면 한 메시지에 모은다. 토큰마다 메시지를 보내면 채널이 시끄러워\n * 정작 읽히지 않는다.\n *\n * 비활성 토큰이 없으면 보내지 않는다 — \"이상 없음\"을 주기적으로 알리면 채널이 무뎌진다.\n */\nimport { getLogger } from \"@logtape/logtape\";\n\nimport { notifySlack, SLACK_COLOR } from \"../../utils/slack-notify\";\nimport { getSetting } from \"../setting/setting.store\";\nimport { TokenModel } from \"../token/token.model\";\nimport { getSlackUserMap, mentionFor } from \"./slack-user-map\";\n\nconst logger = getLogger([\"qgrid\", \"expired-reminder\"]);\n\nconst MINUTE_MS = 60_000;\n\nexport type ExpiredTokenReminderDeps = {\n  findInactive: () => Promise<{ name: string | null; provider: string }[]>;\n  getSlackUserMap: () => Map<string, string>;\n  readSetting: typeof getSetting;\n  sendSlack: typeof notifySlack;\n};\n\nconst defaultDeps: ExpiredTokenReminderDeps = {\n  findInactive: () => TokenModel.findInactive(\"A\"),\n  getSlackUserMap,\n  readSetting: getSetting,\n  sendSlack: notifySlack,\n};\n\n/**\n * 1건이면 제목(subject)에 토큰명이 이미 있으므로 본문에서는 뺀다 — 같은 이름을 두 번 쓰면\n * 읽는 사람이 다른 정보인 줄 알고 한 번 더 본다. 여러 건이면 제목이 건수라 본문에 남긴다.\n */\nexport function buildReminderContext(\n  tokens: { name: string | null; provider: string }[],\n  userMap: Map<string, string>,\n): string {\n  const showLabel = tokens.length > 1;\n  const lines = tokens.map((token) => {\n    const mention = mentionFor(token.name, userMap);\n    const label = token.name ?? \"unnamed\";\n    if (!showLabel) return mention;\n    return mention ? `${mention} ${label}` : label;\n  });\n  return [...lines, \"재로그인이 필요합니다\"].filter(Boolean).join(\"\\n\");\n}\n\nasync function sendReminder(deps: ExpiredTokenReminderDeps): Promise<void> {\n  const inactive = await deps.findInactive();\n  if (inactive.length === 0) return;\n\n  const userMap = deps.getSlackUserMap();\n\n  await deps.sendSlack({\n    // 만료 순간 알림과 같은 제목을 쓴다. 같은 사건이므로 다른 이름을 붙이면 별개 문제로 읽힌다.\n    title: \"세션 만료\",\n    subject: inactive.length > 1 ? `${inactive.length}건` : (inactive[0]!.name ?? \"unnamed\"),\n    context: buildReminderContext(inactive, userMap),\n    color: SLACK_COLOR.bad,\n  });\n}\n\nlet timer: ReturnType<typeof setInterval> | null = null;\n\nfunction scheduleExpiredTokenReminder(runNow: boolean, deps: ExpiredTokenReminderDeps): void {\n  stopExpiredTokenReminder();\n\n  const minutes = Number(\n    deps.readSetting(\"slack.expiryReminderMinutes\", \"SLACK_EXPIRY_REMINDER_INTERVAL_MINUTES\") ?? 0,\n  );\n  if (!Number.isFinite(minutes) || minutes <= 0) return;\n\n  logger.info(\n    `expired token reminder every ${minutes}m (${deps.getSlackUserMap().size} user mappings)`,\n  );\n\n  const run = () =>\n    sendReminder(deps).catch((e) => logger.warn(`reminder failed: ${(e as Error).message}`));\n\n  if (runNow) void run();\n  timer = setInterval(run, minutes * MINUTE_MS);\n}\n\n/**\n * `SLACK_EXPIRY_REMINDER_INTERVAL_MINUTES` 가 양수일 때만 켜진다. 미설정·0 이면 비활성.\n *\n * 인스턴스가 여러 개면 각자 보낸다. 만료 순간 알림과 달리 상태 변화가 없어 DB 로 억제할 수\n * 없고, 하루 몇 건 수준이라 중복을 감수하는 편이 잠금 장치를 두는 것보다 낫다.\n */\nexport function startExpiredTokenReminder(deps: ExpiredTokenReminderDeps = defaultDeps): void {\n  // 기동 직후에도 한 번 보낸다. 재기동은 배포나 장애 복구 때 일어나는데, 그 시점에 이미\n  // 만료된 토큰이 있으면 첫 주기가 돌 때까지 조용한 것이 이상하다.\n  scheduleExpiredTokenReminder(true, deps);\n}\n\n/** 설정 변경 시 기존 타이머만 새 주기로 교체한다. 저장 자체가 알림을 보내지는 않는다. */\nexport function rescheduleExpiredTokenReminder(deps: ExpiredTokenReminderDeps = defaultDeps): void {\n  scheduleExpiredTokenReminder(false, deps);\n}\n\nexport function stopExpiredTokenReminder(): void {\n  if (!timer) return;\n  clearInterval(timer);\n  timer = null;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAmBA,MAAM,SAAS,UAAU,CAAC,SAAS,kBAAkB,CAAC;AAEtD,MAAM,YAAY;AASlB,MAAM,cAAwC;CAC5C,oBAAoB,WAAW,aAAa,GAAG;CAC/C;CACA,aAAa;CACb,WAAW;AACb;;;;;AAMA,SAAgB,qBACd,QACA,SACQ;CACR,MAAM,YAAY,OAAO,SAAS;CAOlC,OAAO,CAAC,GANM,OAAO,KAAK,UAAU;EAClC,MAAM,UAAU,WAAW,MAAM,MAAM,OAAO;EAC9C,MAAM,QAAQ,MAAM,QAAQ;EAC5B,IAAI,CAAC,WAAW,OAAO;EACvB,OAAO,UAAU,GAAG,QAAQ,GAAG,UAAU;CAC3C,CACW,GAAO,aAAa,CAAC,CAAC,OAAO,OAAO,CAAC,CAAC,KAAK,IAAI;AAC5D;AAEA,eAAe,aAAa,MAA+C;CACzE,MAAM,WAAW,MAAM,KAAK,aAAa;CACzC,IAAI,SAAS,WAAW,GAAG;CAE3B,MAAM,UAAU,KAAK,gBAAgB;CAErC,MAAM,KAAK,UAAU;EAEnB,OAAO;EACP,SAAS,SAAS,SAAS,IAAI,GAAG,SAAS,OAAO,KAAM,SAAS,EAAE,CAAE,QAAQ;EAC7E,SAAS,qBAAqB,UAAU,OAAO;EAC/C,OAAO,YAAY;CACrB,CAAC;AACH;AAEA,IAAI,QAA+C;AAEnD,SAAS,6BAA6B,QAAiB,MAAsC;CAC3F,yBAAyB;CAEzB,MAAM,UAAU,OACd,KAAK,YAAY,+BAA+B,wCAAwC,KAAK,CAC/F;CACA,IAAI,CAAC,OAAO,SAAS,OAAO,KAAK,WAAW,GAAG;CAE/C,OAAO,KACL,gCAAgC,QAAQ,KAAK,KAAK,gBAAgB,CAAC,CAAC,KAAK,gBAC3E;CAEA,MAAM,YACJ,aAAa,IAAI,CAAC,CAAC,OAAO,MAAM,OAAO,KAAK,oBAAqB,EAAY,SAAS,CAAC;CAEzF,IAAI,QAAQ,AAAK,IAAI;CACrB,QAAQ,YAAY,KAAK,UAAU,SAAS;AAC9C;;;;;;;AAQA,SAAgB,0BAA0B,OAAiC,aAAmB;CAG5F,6BAA6B,MAAM,IAAI;AACzC;;AAGA,SAAgB,+BAA+B,OAAiC,aAAmB;CACjG,6BAA6B,OAAO,IAAI;AAC1C;AAEA,SAAgB,2BAAiC;CAC/C,IAAI,CAAC,OAAO;CACZ,cAAc,KAAK;CACnB,QAAQ;AACV"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"expired-token-reminder.js","names":[],"sources":["../../../src/application/qgrid/expired-token-reminder.ts"],"sourcesContent":["/**\n * 세션 만료 알림 반복.\n *\n * 만료 순간의 알림(`token-death.ts`)은 그때 채널을 보지 않으면 놓친다. 재로그인은 사람이\n * 해야 하는 일이라 놓치면 토큰이 계속 빠진 채로 남는다. 그래서 아직 재로그인되지 않은\n * 토큰을 같은 문구로 다시 알린다 — 사건이 하나이므로 알림도 한 종류다.\n *\n * 여러 토큰이 만료돼 있으면 한 메시지에 모은다. 토큰마다 메시지를 보내면 채널이 시끄러워\n * 정작 읽히지 않는다.\n *\n * 비활성 토큰이 없으면 보내지 않는다 — \"이상 없음\"을 주기적으로 알리면 채널이 무뎌진다.\n */\nimport { getLogger } from \"@logtape/logtape\";\n\nimport { notifySlack, SLACK_COLOR } from \"../../utils/slack-notify\";\nimport { getSetting } from \"../setting/setting.store\";\nimport { TokenModel } from \"../token/token.model\";\nimport { getSlackUserMap, mentionFor } from \"./slack-user-map\";\n\nconst logger = getLogger([\"qgrid\", \"expired-reminder\"]);\n\nconst MINUTE_MS = 60_000;\n\nexport type ExpiredTokenReminderDeps = {\n  findInactive: () => Promise<{ name: string | null; provider: string }[]>;\n  getSlackUserMap: () => Map<string, string>;\n  readSetting: typeof getSetting;\n  sendSlack: typeof notifySlack;\n};\n\nconst defaultDeps: ExpiredTokenReminderDeps = {\n  findInactive: () => TokenModel.findInactive(\"A\"),\n  getSlackUserMap,\n  readSetting: getSetting,\n  sendSlack: notifySlack,\n};\n\n/**\n * 1건이면 제목(subject)에 토큰명이 이미 있으므로 본문에서는 뺀다 — 같은 이름을 두 번 쓰면\n * 읽는 사람이 다른 정보인 줄 알고 한 번 더 본다. 여러 건이면 제목이 건수라 본문에 남긴다.\n */\nexport function buildReminderContext(\n  tokens: { name: string | null; provider: string }[],\n  userMap: Map<string, string>,\n): string {\n  const showLabel = tokens.length > 1;\n  const lines = tokens.map((token) => {\n    const mention = mentionFor(token.name, userMap);\n    const label = token.name ?? \"unnamed\";\n    if (!showLabel) return mention;\n    return mention ? `${mention} ${label}` : label;\n  });\n  return [...lines, \"재로그인이 필요합니다\"].filter(Boolean).join(\"\\n\");\n}\n\nasync function sendReminder(deps: ExpiredTokenReminderDeps, urgent = false): Promise<number> {\n  const inactive = await deps.findInactive();\n  if (inactive.length === 0) return 0;\n\n  const userMap = deps.getSlackUserMap();\n\n  await deps.sendSlack({\n    // 만료 순간 알림과 같은 제목을 쓴다. 같은 사건이므로 다른 이름을 붙이면 별개 문제로 읽힌다.\n    title: \"세션 만료\",\n    subject: inactive.length > 1 ? `${inactive.length}건` : (inactive[0]!.name ?? \"unnamed\"),\n    context: buildReminderContext(inactive, userMap),\n    color: SLACK_COLOR.bad,\n    urgent,\n  });\n  return inactive.length;\n}\n\n/**\n * 화면의 \"지금 보내기\". 사람이 직접 누른 것이므로 조용 시간·마스터 스위치를 통과시킨다 —\n * 눌렀는데 아무 일도 안 일어나면 버튼이 고장 난 것으로 읽힌다.\n *\n * 보낸 건수를 돌려줘 호출부가 \"보낼 대상 없음\"과 \"보냄\"을 구분해 보여준다.\n */\nexport function sendExpiredTokenReminderNow(\n  deps: ExpiredTokenReminderDeps = defaultDeps,\n): Promise<number> {\n  return sendReminder(deps, true);\n}\n\nlet timer: ReturnType<typeof setInterval> | null = null;\n\nfunction scheduleExpiredTokenReminder(runNow: boolean, deps: ExpiredTokenReminderDeps): void {\n  stopExpiredTokenReminder();\n\n  // 주기 값과 별개인 스위치다. 꺼도 주기는 남아 있어 다시 켤 때 고르던 값이 그대로다.\n  if (deps.readSetting(\"slack.remindersEnabled\", \"SLACK_REMINDERS_ENABLED\") === \"false\") {\n    logger.info(\"expired token reminder disabled\");\n    return;\n  }\n\n  const minutes = Number(\n    deps.readSetting(\"slack.expiryReminderMinutes\", \"SLACK_EXPIRY_REMINDER_INTERVAL_MINUTES\") ?? 0,\n  );\n  if (!Number.isFinite(minutes) || minutes <= 0) return;\n\n  logger.info(\n    `expired token reminder every ${minutes}m (${deps.getSlackUserMap().size} user mappings)`,\n  );\n\n  const run = () =>\n    sendReminder(deps).catch((e) => logger.warn(`reminder failed: ${(e as Error).message}`));\n\n  if (runNow) void run();\n  timer = setInterval(run, minutes * MINUTE_MS);\n}\n\n/**\n * `SLACK_EXPIRY_REMINDER_INTERVAL_MINUTES` 가 양수일 때만 켜진다. 미설정·0 이면 비활성.\n *\n * 인스턴스가 여러 개면 각자 보낸다. 만료 순간 알림과 달리 상태 변화가 없어 DB 로 억제할 수\n * 없고, 하루 몇 건 수준이라 중복을 감수하는 편이 잠금 장치를 두는 것보다 낫다.\n */\nexport function startExpiredTokenReminder(deps: ExpiredTokenReminderDeps = defaultDeps): void {\n  // 기동 직후에도 한 번 보낸다. 재기동은 배포나 장애 복구 때 일어나는데, 그 시점에 이미\n  // 만료된 토큰이 있으면 첫 주기가 돌 때까지 조용한 것이 이상하다.\n  scheduleExpiredTokenReminder(true, deps);\n}\n\n/** 설정 변경 시 기존 타이머만 새 주기로 교체한다. 저장 자체가 알림을 보내지는 않는다. */\nexport function rescheduleExpiredTokenReminder(deps: ExpiredTokenReminderDeps = defaultDeps): void {\n  scheduleExpiredTokenReminder(false, deps);\n}\n\nexport function stopExpiredTokenReminder(): void {\n  if (!timer) return;\n  clearInterval(timer);\n  timer = null;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAmBA,MAAM,SAAS,UAAU,CAAC,SAAS,kBAAkB,CAAC;AAEtD,MAAM,YAAY;AASlB,MAAM,cAAwC;CAC5C,oBAAoB,WAAW,aAAa,GAAG;CAC/C;CACA,aAAa;CACb,WAAW;AACb;;;;;AAMA,SAAgB,qBACd,QACA,SACQ;CACR,MAAM,YAAY,OAAO,SAAS;CAOlC,OAAO,CAAC,GANM,OAAO,KAAK,UAAU;EAClC,MAAM,UAAU,WAAW,MAAM,MAAM,OAAO;EAC9C,MAAM,QAAQ,MAAM,QAAQ;EAC5B,IAAI,CAAC,WAAW,OAAO;EACvB,OAAO,UAAU,GAAG,QAAQ,GAAG,UAAU;CAC3C,CACW,GAAO,aAAa,CAAC,CAAC,OAAO,OAAO,CAAC,CAAC,KAAK,IAAI;AAC5D;AAEA,eAAe,aAAa,MAAgC,SAAS,OAAwB;CAC3F,MAAM,WAAW,MAAM,KAAK,aAAa;CACzC,IAAI,SAAS,WAAW,GAAG,OAAO;CAElC,MAAM,UAAU,KAAK,gBAAgB;CAErC,MAAM,KAAK,UAAU;EAEnB,OAAO;EACP,SAAS,SAAS,SAAS,IAAI,GAAG,SAAS,OAAO,KAAM,SAAS,EAAE,CAAE,QAAQ;EAC7E,SAAS,qBAAqB,UAAU,OAAO;EAC/C,OAAO,YAAY;EACnB;CACF,CAAC;CACD,OAAO,SAAS;AAClB;;;;;;;AAQA,SAAgB,4BACd,OAAiC,aAChB;CACjB,OAAO,aAAa,MAAM,IAAI;AAChC;AAEA,IAAI,QAA+C;AAEnD,SAAS,6BAA6B,QAAiB,MAAsC;CAC3F,yBAAyB;CAGzB,IAAI,KAAK,YAAY,0BAA0B,yBAAyB,MAAM,SAAS;EACrF,OAAO,KAAK,iCAAiC;EAC7C;CACF;CAEA,MAAM,UAAU,OACd,KAAK,YAAY,+BAA+B,wCAAwC,KAAK,CAC/F;CACA,IAAI,CAAC,OAAO,SAAS,OAAO,KAAK,WAAW,GAAG;CAE/C,OAAO,KACL,gCAAgC,QAAQ,KAAK,KAAK,gBAAgB,CAAC,CAAC,KAAK,gBAC3E;CAEA,MAAM,YACJ,aAAa,IAAI,CAAC,CAAC,OAAO,MAAM,OAAO,KAAK,oBAAqB,EAAY,SAAS,CAAC;CAEzF,IAAI,QAAQ,AAAK,IAAI;CACrB,QAAQ,YAAY,KAAK,UAAU,SAAS;AAC9C;;;;;;;AAQA,SAAgB,0BAA0B,OAAiC,aAAmB;CAG5F,6BAA6B,MAAM,IAAI;AACzC;;AAGA,SAAgB,+BAA+B,OAAiC,aAAmB;CACjG,6BAA6B,OAAO,IAAI;AAC1C;AAEA,SAAgB,2BAAiC;CAC/C,IAAI,CAAC,OAAO;CACZ,cAAc,KAAK;CACnB,QAAQ;AACV"}

package/bundle/dist/application/setting/setting.constant.js

@@ -0,0 +1,226 @@
+//#region src/application/setting/setting.constant.ts
+/** 64 GiB 운영 호스트에서 세 자리 오입력을 막는 설정 상한. 안전을 보장하는 값은 아니다. */
+const MAX_OPENAI_ESTIMATED_RSS_GIB = 32;
+const MAX_OPENAI_MIN_HOST_AVAILABLE_GIB = 64;
+const SETTING_DEFS = [
+	{
+		key: "openai.autoscale",
+		fallback: "true",
+		group: "openai",
+		envKey: "QGRID_OPENAI_AUTOSCALE",
+		label: "OpenAI 워커 오토스케일",
+		kind: "boolean",
+		applies: "restart",
+		help: "끄면 워커 수가 최소값으로 고정됩니다"
+	},
+	{
+		key: "openai.minWorkersPerToken",
+		fallback: "1",
+		group: "openai",
+		envKey: "QGRID_OPENAI_MIN_WORKERS_PER_TOKEN",
+		label: "토큰당 최소 워커",
+		kind: "integer",
+		applies: "restart",
+		min: 1,
+		max: 20
+	},
+	{
+		key: "openai.maxWorkersPerToken",
+		fallback: "3",
+		group: "openai",
+		envKey: "QGRID_OPENAI_MAX_WORKERS_PER_TOKEN",
+		label: "토큰당 최대 워커",
+		kind: "integer",
+		applies: "restart",
+		min: 1,
+		max: 20,
+		help: "오토스케일이 꺼져 있으면 무시됩니다"
+	},
+	{
+		key: "openai.maxEstimatedRssGiB",
+		fallback: "16",
+		group: "openai",
+		envKey: "QGRID_OPENAI_MAX_ESTIMATED_RSS_GIB",
+		label: "워커 메모리 상한 (GiB)",
+		kind: "number",
+		applies: "restart",
+		min: 1,
+		max: 32,
+		help: "이 추정치를 넘기면 워커를 더 늘리지 않습니다. 올릴수록 OOM 위험이 커지며 상한은 오입력 방지용입니다"
+	},
+	{
+		key: "openai.minHostAvailableGiB",
+		fallback: "20",
+		group: "openai",
+		envKey: "QGRID_OPENAI_MIN_HOST_AVAILABLE_GIB",
+		label: "호스트 여유 메모리 하한 (GiB)",
+		kind: "number",
+		applies: "restart",
+		min: 0,
+		max: 64,
+		help: "호스트 여유가 이 값 아래면 스케일업을 멈춥니다. 확장을 끄려면 오토스케일을 끄세요"
+	},
+	{
+		key: "slack.enabled",
+		fallback: "true",
+		group: "slack",
+		envKey: "SLACK_ENABLED",
+		label: "Slack 알림",
+		kind: "boolean",
+		applies: "immediate",
+		help: "연휴처럼 규칙으로 잡을 수 없는 기간에 끕니다. 서비스 정지급 장애 알림은 꺼도 전달됩니다"
+	},
+	{
+		key: "slack.remindersEnabled",
+		fallback: "true",
+		group: "slack",
+		envKey: "SLACK_REMINDERS_ENABLED",
+		label: "만료 알림 반복",
+		kind: "boolean",
+		applies: "immediate",
+		help: "끄면 반복만 멈추고 만료 순간의 알림은 그대로 갑니다"
+	},
+	{
+		key: "slack.expiryReminderMinutes",
+		fallback: "60",
+		group: "slack",
+		envKey: "SLACK_EXPIRY_REMINDER_INTERVAL_MINUTES",
+		label: "반복 주기",
+		kind: "preset",
+		applies: "immediate",
+		presets: [
+			10,
+			30,
+			60,
+			180
+		],
+		help: "재로그인이 필요한 토큰이 남아 있는 동안 이 주기로 다시 알립니다"
+	},
+	{
+		key: "slack.quietFromHour",
+		fallback: "20",
+		group: "slack",
+		envKey: "SLACK_QUIET_FROM_HOUR",
+		label: "조용 시간 시작",
+		kind: "integer",
+		applies: "immediate",
+		min: 0,
+		max: 23,
+		help: "이 시각부터 알리지 않습니다 (한국 시간)"
+	},
+	{
+		key: "slack.quietUntilHour",
+		fallback: "8",
+		group: "slack",
+		envKey: "SLACK_QUIET_UNTIL_HOUR",
+		label: "조용 시간 종료",
+		kind: "integer",
+		applies: "immediate",
+		min: 0,
+		max: 23,
+		help: "이 시각부터 다시 알립니다. 시작보다 빠르면 자정을 넘는 구간이 됩니다"
+	},
+	{
+		key: "slack.notifyOnWeekends",
+		fallback: "false",
+		group: "slack",
+		envKey: "SLACK_NOTIFY_ON_WEEKENDS",
+		label: "주말에도 알림",
+		kind: "boolean",
+		applies: "immediate",
+		help: "켜면 주말에도 위의 조용 시간 규칙만 적용됩니다"
+	},
+	{
+		key: "slack.channelId",
+		fallback: "",
+		group: "slackConnection",
+		envKey: "SLACK_CHANNEL_ID",
+		label: "Slack 채널 ID",
+		kind: "string",
+		applies: "immediate",
+		help: "사용자 ID(U...)를 넣으면 그 사람 DM 으로 갑니다"
+	},
+	{
+		key: "slack.userMap",
+		fallback: "",
+		group: "slackConnection",
+		envKey: "SLACK_USER_MAP",
+		label: "Slack 사용자 매핑",
+		kind: "string",
+		applies: "immediate",
+		help: "토큰명:SlackUserId 를 쉼표로. 공용 계정은 넣지 않습니다"
+	},
+	{
+		key: "slack.botToken",
+		fallback: "",
+		group: "slackConnection",
+		envKey: "SLACK_BOT_TOKEN",
+		label: "Slack 봇 토큰",
+		kind: "secret",
+		applies: "immediate"
+	}
+];
+function findSettingDef(key) {
+	return SETTING_DEFS.find((d) => d.key === key);
+}
+/** 저장 전 검증. 잘못된 값이 들어가면 런타임에서 조용히 기본값으로 떨어져 원인을 찾기 어렵다. */
+function validateSettingValue(def, raw) {
+	const trimmed = raw.trim();
+	if (def.kind === "boolean") {
+		if (!["true", "false"].includes(trimmed)) return {
+			ok: false,
+			error: "true 또는 false"
+		};
+		return {
+			ok: true,
+			value: trimmed
+		};
+	}
+	if (def.kind === "preset") {
+		const parsed = Number(trimmed);
+		if (!def.presets?.includes(parsed)) return {
+			ok: false,
+			error: `${def.presets?.join(", ") ?? ""} 중 하나여야 합니다`
+		};
+		return {
+			ok: true,
+			value: String(parsed)
+		};
+	}
+	if (def.kind === "integer" || def.kind === "number") {
+		const parsed = Number(trimmed);
+		if (!Number.isFinite(parsed)) return {
+			ok: false,
+			error: "숫자를 입력하세요"
+		};
+		if (def.kind === "integer" && !Number.isInteger(parsed)) return {
+			ok: false,
+			error: "정수를 입력하세요"
+		};
+		if (def.min !== void 0 && parsed < def.min) return {
+			ok: false,
+			error: `${def.min} 이상이어야 합니다`
+		};
+		if (def.max !== void 0 && parsed > def.max) return {
+			ok: false,
+			error: `${def.max} 이하여야 합니다`
+		};
+		return {
+			ok: true,
+			value: String(parsed)
+		};
+	}
+	return {
+		ok: true,
+		value: trimmed
+	};
+}
+/** 화면에 그대로 내려보내면 안 되는 값. 앞뒤만 남긴다. */
+function maskSecret(value) {
+	if (value.length <= 12) return "***";
+	return `${value.slice(0, 8)}...${value.slice(-4)}`;
+}
+//#endregion
+export { MAX_OPENAI_ESTIMATED_RSS_GIB, MAX_OPENAI_MIN_HOST_AVAILABLE_GIB, SETTING_DEFS, findSettingDef, maskSecret, validateSettingValue };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"setting.constant.js","names":[],"sources":["../../../src/application/setting/setting.constant.ts"],"sourcesContent":["/**\n * 관리 가능한 런타임 설정 목록.\n *\n * 키·env 이름·타입·검증을 한 곳에 모아 API 와 UI 가 같은 정의를 본다. 여기 없는 env 는\n * 화면에서 바꿀 수 없다 — DB 접속 정보나 포트처럼 서버가 뜨기 전에 필요한 값들이다.\n *\n * `settings` 테이블은 `(key, value)` 문자열 쌍만 담는 그릇이라(`setting.entity.json`),\n * \"이 키가 정수인지·범위가 얼마인지·화면에 뭐라고 쓸지\"를 담을 곳이 따로 필요하다.\n * 그 메타데이터가 여기 있다 — DB 스키마가 아니라 앱이 아는 상수 목록이다.\n */\n\nexport type SettingKind = \"boolean\" | \"integer\" | \"number\" | \"string\" | \"secret\" | \"preset\";\n\n/**\n * 화면에서 묶어 보여줄 단위. 평평하게 나열하면 어디를 봐야 할지 알 수 없다.\n *\n * Slack 은 \"언제 보낼까\"(slack)와 \"어디로 보낼까\"(slackConnection)를 나눈다 — 앞은 운영\n * 중 자주 만지고 뒤는 한 번 맞추면 끝이라 수명이 다르다.\n */\nexport type SettingGroup = \"openai\" | \"slack\" | \"slackConnection\";\n\nexport type SettingDef = {\n  key: string;\n  group: SettingGroup;\n  envKey: string;\n  label: string;\n  kind: SettingKind;\n  /** 적용 시점. 워커 설정은 dispatcher 생성자에서 한 번만 읽혀 재시작이 필요하다. */\n  applies: \"immediate\" | \"restart\";\n  min?: number;\n  max?: number;\n  /** `preset` 종류에서 고를 수 있는 값. 이 목록 밖의 값은 저장되지 않는다. */\n  presets?: number[];\n  /**\n   * 저장값도 env 도 없을 때 실제로 적용되는 값. 화면을 비워두면 \"설정 안 됨\"으로 읽히지만\n   * 실제로는 이 값이 돌고 있다 — 소비처의 기본값과 반드시 같아야 한다.\n   */\n  fallback: string;\n  help?: string;\n};\n\n/** 64 GiB 운영 호스트에서 세 자리 오입력을 막는 설정 상한. 안전을 보장하는 값은 아니다. */\nexport const MAX_OPENAI_ESTIMATED_RSS_GIB = 32;\nexport const MAX_OPENAI_MIN_HOST_AVAILABLE_GIB = 64;\n\nexport const SETTING_DEFS: SettingDef[] = [\n  {\n    key: \"openai.autoscale\",\n    fallback: \"true\",\n    group: \"openai\",\n    envKey: \"QGRID_OPENAI_AUTOSCALE\",\n    label: \"OpenAI 워커 오토스케일\",\n    kind: \"boolean\",\n    applies: \"restart\",\n    help: \"끄면 워커 수가 최소값으로 고정됩니다\",\n  },\n  {\n    key: \"openai.minWorkersPerToken\",\n    fallback: \"1\",\n    group: \"openai\",\n    envKey: \"QGRID_OPENAI_MIN_WORKERS_PER_TOKEN\",\n    label: \"토큰당 최소 워커\",\n    kind: \"integer\",\n    applies: \"restart\",\n    min: 1,\n    max: 20,\n  },\n  {\n    key: \"openai.maxWorkersPerToken\",\n    fallback: \"3\",\n    group: \"openai\",\n    envKey: \"QGRID_OPENAI_MAX_WORKERS_PER_TOKEN\",\n    label: \"토큰당 최대 워커\",\n    kind: \"integer\",\n    applies: \"restart\",\n    min: 1,\n    max: 20,\n    help: \"오토스케일이 꺼져 있으면 무시됩니다\",\n  },\n  {\n    key: \"openai.maxEstimatedRssGiB\",\n    fallback: \"16\",\n    group: \"openai\",\n    envKey: \"QGRID_OPENAI_MAX_ESTIMATED_RSS_GIB\",\n    label: \"워커 메모리 상한 (GiB)\",\n    kind: \"number\",\n    applies: \"restart\",\n    min: 1,\n    max: MAX_OPENAI_ESTIMATED_RSS_GIB,\n    help: \"이 추정치를 넘기면 워커를 더 늘리지 않습니다. 올릴수록 OOM 위험이 커지며 상한은 오입력 방지용입니다\",\n  },\n  {\n    key: \"openai.minHostAvailableGiB\",\n    fallback: \"20\",\n    group: \"openai\",\n    envKey: \"QGRID_OPENAI_MIN_HOST_AVAILABLE_GIB\",\n    label: \"호스트 여유 메모리 하한 (GiB)\",\n    kind: \"number\",\n    applies: \"restart\",\n    min: 0,\n    max: MAX_OPENAI_MIN_HOST_AVAILABLE_GIB,\n    help: \"호스트 여유가 이 값 아래면 스케일업을 멈춥니다. 확장을 끄려면 오토스케일을 끄세요\",\n  },\n  {\n    key: \"slack.enabled\",\n    fallback: \"true\",\n    group: \"slack\",\n    envKey: \"SLACK_ENABLED\",\n    label: \"Slack 알림\",\n    kind: \"boolean\",\n    applies: \"immediate\",\n    help: \"연휴처럼 규칙으로 잡을 수 없는 기간에 끕니다. 서비스 정지급 장애 알림은 꺼도 전달됩니다\",\n  },\n  {\n    key: \"slack.remindersEnabled\",\n    fallback: \"true\",\n    group: \"slack\",\n    envKey: \"SLACK_REMINDERS_ENABLED\",\n    label: \"만료 알림 반복\",\n    kind: \"boolean\",\n    applies: \"immediate\",\n    help: \"끄면 반복만 멈추고 만료 순간의 알림은 그대로 갑니다\",\n  },\n  {\n    key: \"slack.expiryReminderMinutes\",\n    fallback: \"60\",\n    group: \"slack\",\n    envKey: \"SLACK_EXPIRY_REMINDER_INTERVAL_MINUTES\",\n    label: \"반복 주기\",\n    kind: \"preset\",\n    applies: \"immediate\",\n    // 자유 입력 대신 고정 선택지를 쓴다 — \"얼마나 자주 재촉할까\"라서 1분 단위 정밀도가\n    // 의미 없고, 잘못 넣으면 채널이 시끄러워진다. 끄는 것은 remindersEnabled 가 맡는다.\n    presets: [10, 30, 60, 180],\n    help: \"재로그인이 필요한 토큰이 남아 있는 동안 이 주기로 다시 알립니다\",\n  },\n  {\n    key: \"slack.quietFromHour\",\n    fallback: \"20\",\n    group: \"slack\",\n    envKey: \"SLACK_QUIET_FROM_HOUR\",\n    label: \"조용 시간 시작\",\n    kind: \"integer\",\n    applies: \"immediate\",\n    min: 0,\n    max: 23,\n    help: \"이 시각부터 알리지 않습니다 (한국 시간)\",\n  },\n  {\n    key: \"slack.quietUntilHour\",\n    fallback: \"8\",\n    group: \"slack\",\n    envKey: \"SLACK_QUIET_UNTIL_HOUR\",\n    label: \"조용 시간 종료\",\n    kind: \"integer\",\n    applies: \"immediate\",\n    min: 0,\n    max: 23,\n    help: \"이 시각부터 다시 알립니다. 시작보다 빠르면 자정을 넘는 구간이 됩니다\",\n  },\n  {\n    key: \"slack.notifyOnWeekends\",\n    fallback: \"false\",\n    group: \"slack\",\n    envKey: \"SLACK_NOTIFY_ON_WEEKENDS\",\n    label: \"주말에도 알림\",\n    kind: \"boolean\",\n    applies: \"immediate\",\n    help: \"켜면 주말에도 위의 조용 시간 규칙만 적용됩니다\",\n  },\n  {\n    key: \"slack.channelId\",\n    fallback: \"\",\n    group: \"slackConnection\",\n    envKey: \"SLACK_CHANNEL_ID\",\n    label: \"Slack 채널 ID\",\n    kind: \"string\",\n    applies: \"immediate\",\n    help: \"사용자 ID(U...)를 넣으면 그 사람 DM 으로 갑니다\",\n  },\n  {\n    key: \"slack.userMap\",\n    fallback: \"\",\n    group: \"slackConnection\",\n    envKey: \"SLACK_USER_MAP\",\n    label: \"Slack 사용자 매핑\",\n    kind: \"string\",\n    applies: \"immediate\",\n    help: \"토큰명:SlackUserId 를 쉼표로. 공용 계정은 넣지 않습니다\",\n  },\n  {\n    key: \"slack.botToken\",\n    fallback: \"\",\n    group: \"slackConnection\",\n    envKey: \"SLACK_BOT_TOKEN\",\n    label: \"Slack 봇 토큰\",\n    kind: \"secret\",\n    applies: \"immediate\",\n  },\n];\n\nexport function findSettingDef(key: string): SettingDef | undefined {\n  return SETTING_DEFS.find((d) => d.key === key);\n}\n\n/** 저장 전 검증. 잘못된 값이 들어가면 런타임에서 조용히 기본값으로 떨어져 원인을 찾기 어렵다. */\nexport function validateSettingValue(\n  def: SettingDef,\n  raw: string,\n): { ok: true; value: string } | { ok: false; error: string } {\n  const trimmed = raw.trim();\n\n  if (def.kind === \"boolean\") {\n    if (![\"true\", \"false\"].includes(trimmed)) return { ok: false, error: \"true 또는 false\" };\n    return { ok: true, value: trimmed };\n  }\n\n  if (def.kind === \"preset\") {\n    // 화면은 버튼만 주지만 API 는 아무 값이나 받을 수 있다. 목록 밖의 값이 들어오면\n    // 화면에서 아무 버튼도 선택돼 보이지 않아 \"왜 안 바뀌지\"가 된다.\n    const parsed = Number(trimmed);\n    if (!def.presets?.includes(parsed)) {\n      return { ok: false, error: `${def.presets?.join(\", \") ?? \"\"} 중 하나여야 합니다` };\n    }\n    return { ok: true, value: String(parsed) };\n  }\n\n  if (def.kind === \"integer\" || def.kind === \"number\") {\n    const parsed = Number(trimmed);\n    if (!Number.isFinite(parsed)) return { ok: false, error: \"숫자를 입력하세요\" };\n    if (def.kind === \"integer\" && !Number.isInteger(parsed)) {\n      return { ok: false, error: \"정수를 입력하세요\" };\n    }\n    if (def.min !== undefined && parsed < def.min) {\n      return { ok: false, error: `${def.min} 이상이어야 합니다` };\n    }\n    if (def.max !== undefined && parsed > def.max) {\n      return { ok: false, error: `${def.max} 이하여야 합니다` };\n    }\n    return { ok: true, value: String(parsed) };\n  }\n\n  return { ok: true, value: trimmed };\n}\n\n/** 화면에 그대로 내려보내면 안 되는 값. 앞뒤만 남긴다. */\nexport function maskSecret(value: string): string {\n  if (value.length <= 12) return \"***\";\n  return `${value.slice(0, 8)}...${value.slice(-4)}`;\n}\n"],"mappings":";;AA0CA,MAAa,+BAA+B;AAC5C,MAAa,oCAAoC;AAEjD,MAAa,eAA6B;CACxC;EACE,KAAK;EACL,UAAU;EACV,OAAO;EACP,QAAQ;EACR,OAAO;EACP,MAAM;EACN,SAAS;EACT,MAAM;CACR;CACA;EACE,KAAK;EACL,UAAU;EACV,OAAO;EACP,QAAQ;EACR,OAAO;EACP,MAAM;EACN,SAAS;EACT,KAAK;EACL,KAAK;CACP;CACA;EACE,KAAK;EACL,UAAU;EACV,OAAO;EACP,QAAQ;EACR,OAAO;EACP,MAAM;EACN,SAAS;EACT,KAAK;EACL,KAAK;EACL,MAAM;CACR;CACA;EACE,KAAK;EACL,UAAU;EACV,OAAO;EACP,QAAQ;EACR,OAAO;EACP,MAAM;EACN,SAAS;EACT,KAAK;EACL,KAAA;EACA,MAAM;CACR;CACA;EACE,KAAK;EACL,UAAU;EACV,OAAO;EACP,QAAQ;EACR,OAAO;EACP,MAAM;EACN,SAAS;EACT,KAAK;EACL,KAAA;EACA,MAAM;CACR;CACA;EACE,KAAK;EACL,UAAU;EACV,OAAO;EACP,QAAQ;EACR,OAAO;EACP,MAAM;EACN,SAAS;EACT,MAAM;CACR;CACA;EACE,KAAK;EACL,UAAU;EACV,OAAO;EACP,QAAQ;EACR,OAAO;EACP,MAAM;EACN,SAAS;EACT,MAAM;CACR;CACA;EACE,KAAK;EACL,UAAU;EACV,OAAO;EACP,QAAQ;EACR,OAAO;EACP,MAAM;EACN,SAAS;EAGT,SAAS;GAAC;GAAI;GAAI;GAAI;EAAG;EACzB,MAAM;CACR;CACA;EACE,KAAK;EACL,UAAU;EACV,OAAO;EACP,QAAQ;EACR,OAAO;EACP,MAAM;EACN,SAAS;EACT,KAAK;EACL,KAAK;EACL,MAAM;CACR;CACA;EACE,KAAK;EACL,UAAU;EACV,OAAO;EACP,QAAQ;EACR,OAAO;EACP,MAAM;EACN,SAAS;EACT,KAAK;EACL,KAAK;EACL,MAAM;CACR;CACA;EACE,KAAK;EACL,UAAU;EACV,OAAO;EACP,QAAQ;EACR,OAAO;EACP,MAAM;EACN,SAAS;EACT,MAAM;CACR;CACA;EACE,KAAK;EACL,UAAU;EACV,OAAO;EACP,QAAQ;EACR,OAAO;EACP,MAAM;EACN,SAAS;EACT,MAAM;CACR;CACA;EACE,KAAK;EACL,UAAU;EACV,OAAO;EACP,QAAQ;EACR,OAAO;EACP,MAAM;EACN,SAAS;EACT,MAAM;CACR;CACA;EACE,KAAK;EACL,UAAU;EACV,OAAO;EACP,QAAQ;EACR,OAAO;EACP,MAAM;EACN,SAAS;CACX;AACF;AAEA,SAAgB,eAAe,KAAqC;CAClE,OAAO,aAAa,MAAM,MAAM,EAAE,QAAQ,GAAG;AAC/C;;AAGA,SAAgB,qBACd,KACA,KAC4D;CAC5D,MAAM,UAAU,IAAI,KAAK;CAEzB,IAAI,IAAI,SAAS,WAAW;EAC1B,IAAI,CAAC,CAAC,QAAQ,OAAO,CAAC,CAAC,SAAS,OAAO,GAAG,OAAO;GAAE,IAAI;GAAO,OAAO;EAAgB;EACrF,OAAO;GAAE,IAAI;GAAM,OAAO;EAAQ;CACpC;CAEA,IAAI,IAAI,SAAS,UAAU;EAGzB,MAAM,SAAS,OAAO,OAAO;EAC7B,IAAI,CAAC,IAAI,SAAS,SAAS,MAAM,GAC/B,OAAO;GAAE,IAAI;GAAO,OAAO,GAAG,IAAI,SAAS,KAAK,IAAI,KAAK,GAAG;EAAa;EAE3E,OAAO;GAAE,IAAI;GAAM,OAAO,OAAO,MAAM;EAAE;CAC3C;CAEA,IAAI,IAAI,SAAS,aAAa,IAAI,SAAS,UAAU;EACnD,MAAM,SAAS,OAAO,OAAO;EAC7B,IAAI,CAAC,OAAO,SAAS,MAAM,GAAG,OAAO;GAAE,IAAI;GAAO,OAAO;EAAY;EACrE,IAAI,IAAI,SAAS,aAAa,CAAC,OAAO,UAAU,MAAM,GACpD,OAAO;GAAE,IAAI;GAAO,OAAO;EAAY;EAEzC,IAAI,IAAI,QAAQ,UAAa,SAAS,IAAI,KACxC,OAAO;GAAE,IAAI;GAAO,OAAO,GAAG,IAAI,IAAI;EAAY;EAEpD,IAAI,IAAI,QAAQ,UAAa,SAAS,IAAI,KACxC,OAAO;GAAE,IAAI;GAAO,OAAO,GAAG,IAAI,IAAI;EAAW;EAEnD,OAAO;GAAE,IAAI;GAAM,OAAO,OAAO,MAAM;EAAE;CAC3C;CAEA,OAAO;EAAE,IAAI;EAAM,OAAO;CAAQ;AACpC;;AAGA,SAAgB,WAAW,OAAuB;CAChD,IAAI,MAAM,UAAU,IAAI,OAAO;CAC/B,OAAO,GAAG,MAAM,MAAM,GAAG,CAAC,EAAE,KAAK,MAAM,MAAM,EAAE;AACjD"}

package/bundle/dist/application/setting/setting.model.js

@@ -1,4 +1,4 @@
-import { SETTING_DEFS, findSettingDef, maskSecret, validateSettingValue } from "./setting.schema.js";
+import { SETTING_DEFS, findSettingDef, maskSecret, validateSettingValue } from "./setting.constant.js";
 import { SD } from "../../i18n/sd.generated.js";
 import { settingLoaderQueries, settingSubsetQueries } from "../sonamu.generated.sso.js";
 import __decorateMetadata from "../../_virtual/_@oxc-project_runtime@0.140.0/helpers/esm/decorateMetadata.js";
@@ -121,6 +121,7 @@ var SettingModelClass = class extends BaseModelClass {
 					source,
 					min: def.min ?? null,
 					max: def.max ?? null,
+					presets: def.presets ?? [],
 					help: def.help ?? null
 				};
 			}),
@@ -180,6 +181,14 @@ var SettingModelClass = class extends BaseModelClass {
 		await resetSetting(key);
 		return { applies: def.applies };
 	}
+	/**
+	* 만료 알림을 지금 한 번 보낸다. 주기를 기다리지 않고 설정이 제대로 붙었는지 확인하거나,
+	* 재로그인을 재촉할 때 쓴다. 보낸 건수를 돌려줘 "보낼 대상 없음"과 구분한다.
+	*/
+	async triggerExpiryReminder() {
+		const { sendExpiredTokenReminderNow } = await import("../qgrid/expired-token-reminder.js");
+		return { sent: await sendExpiredTokenReminderNow() };
+	}
 };
 __decorate([
 	api({
@@ -229,8 +238,17 @@ __decorate([
 	__decorateMetadata("design:paramtypes", [String]),
 	__decorateMetadata("design:returntype", Promise)
 ], SettingModelClass.prototype, "resetSetting", null);
+__decorate([
+	api({
+		httpMethod: "POST",
+		clients: ["axios", "tanstack-mutation"]
+	}),
+	__decorateMetadata("design:type", Function),
+	__decorateMetadata("design:paramtypes", []),
+	__decorateMetadata("design:returntype", Promise)
+], SettingModelClass.prototype, "triggerExpiryReminder", null);
 const SettingModel = new SettingModelClass();
 //#endregion
 export { SettingModel };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"setting.model.js","names":["saveStoredSetting","resetStoredSetting"],"sources":["../../../src/application/setting/setting.model.ts"],"sourcesContent":["import {\n  BaseModelClass,\n  type ListResult,\n  asArray,\n  NotFoundException,\n  BadRequestException,\n  api,\n  exhaustive,\n} from \"sonamu\";\n\nimport { SD } from \"../../i18n/sd.generated\";\nimport { type SettingSubsetKey, type SettingSubsetMapping } from \"../sonamu.generated\";\nimport { settingSubsetQueries, settingLoaderQueries } from \"../sonamu.generated.sso\";\nimport { findSettingDef, maskSecret, SETTING_DEFS, validateSettingValue } from \"./setting.schema\";\nimport {\n  getSetting,\n  isStored,\n  resetSetting as resetStoredSetting,\n  saveSetting as saveStoredSetting,\n} from \"./setting.store\";\nimport {\n  type RuntimeInfoItem,\n  type SettingApplies,\n  type SettingItem,\n  type SettingListParams,\n  type SettingSaveParams,\n  type SettingsResponse,\n} from \"./setting.types\";\n\n/*\n  Setting Model\n*/\nclass SettingModelClass extends BaseModelClass<\n  SettingSubsetKey,\n  SettingSubsetMapping,\n  typeof settingSubsetQueries,\n  typeof settingLoaderQueries\n> {\n  constructor() {\n    super(\"Setting\", settingSubsetQueries, settingLoaderQueries);\n  }\n\n  @api({ httpMethod: \"GET\", clients: [\"axios\", \"tanstack-query\"], resourceName: \"Setting\" })\n  async findById<T extends SettingSubsetKey>(\n    subset: T,\n    id: number,\n  ): Promise<SettingSubsetMapping[T]> {\n    const { rows } = await this.findMany(subset, {\n      id,\n      num: 1,\n      page: 1,\n    });\n    if (!rows[0]) {\n      throw new NotFoundException(SD(\"error.entityNotFound\")(\"Setting\", id));\n    }\n\n    return rows[0];\n  }\n\n  async findOne<T extends SettingSubsetKey>(\n    subset: T,\n    listParams: SettingListParams,\n  ): Promise<SettingSubsetMapping[T] | null> {\n    const { rows } = await this.findMany(subset, {\n      ...listParams,\n      num: 1,\n      page: 1,\n    });\n\n    return rows[0] ?? null;\n  }\n\n  @api({ httpMethod: \"GET\", clients: [\"axios\", \"tanstack-query\"], resourceName: \"Settings\" })\n  async findMany<T extends SettingSubsetKey, LP extends SettingListParams>(\n    subset: T,\n    rawParams?: LP,\n  ): Promise<ListResult<LP, SettingSubsetMapping[T]>> {\n    // params with defaults\n    const params = {\n      num: 24,\n      page: 1,\n      search: \"key\" as const,\n      orderBy: \"key-asc\" as const,\n      ...rawParams,\n    } satisfies SettingListParams;\n\n    // build queries\n    const { qb, onSubset: _ } = this.getSubsetQueries(subset);\n\n    // id\n    if (params.id) {\n      qb.whereIn(\"settings.id\", asArray(params.id));\n    }\n\n    // key — toFilter prop 이지만 스캐폴딩이 만들어주지 않아 직접 건다.\n    if (params.key) {\n      qb.where(\"settings.key\", params.key);\n    }\n\n    // search-keyword\n    if (params.search && params.keyword && params.keyword.length > 0) {\n      if (params.search === \"key\") {\n        qb.where(\"settings.key\", \"like\", `%${params.keyword}%`);\n      } else {\n        throw new BadRequestException(SD(\"error.unknownSearchField\")(params.search));\n      }\n    }\n\n    // orderBy\n    if (params.orderBy) {\n      // default orderBy\n      if (params.orderBy === \"key-asc\") {\n        qb.orderBy(\"settings.key\", \"asc\");\n      } else {\n        exhaustive(params.orderBy);\n      }\n    }\n\n    const enhancers = this.createEnhancers({\n      A: (row) => ({\n        ...row,\n        // 서브셋별로 virtual 필드 계산로직 추가\n      }),\n    });\n\n    return this.executeSubsetQuery({\n      subset,\n      qb,\n      params,\n      enhancers,\n      debug: false,\n    });\n  }\n\n  async save(spa: SettingSaveParams[]): Promise<number[]> {\n    const wdb = this.getPuri(\"w\");\n\n    // register\n    spa.forEach((sp) => {\n      wdb.ubRegister(\"settings\", sp);\n    });\n\n    // transaction\n    return wdb.transaction(async (trx) => {\n      const ids = await trx.ubUpsert(\"settings\");\n\n      return ids;\n    });\n  }\n\n  async del(ids: number[]): Promise<number> {\n    const wdb = this.getPuri(\"w\");\n\n    // transaction\n    await wdb.transaction(async (trx) => {\n      return trx.table(\"settings\").whereIn(\"settings.id\", ids).delete();\n    });\n\n    return ids.length;\n  }\n\n  /** 저장된 설정 전체를 key→value 로. 부팅 시 한 번 읽어 메모리에 올린다. */\n  async findAllAsMap(): Promise<Map<string, string>> {\n    const { rows } = await this.findMany(\"A\", { num: 0, page: 1 });\n    return new Map(rows.map((r) => [r.key, r.value]));\n  }\n\n  /**\n   * key 로 upsert 한다. `save` 는 id 기준이라 key 중복을 걸러내지 못해, 기존 행을 먼저 찾아\n   * id 를 실어 보낸다.\n   */\n  async setByKey(key: string, value: string): Promise<void> {\n    const existing = await this.findOne(\"A\", { key, num: 1, page: 1 });\n    await this.save([\n      {\n        ...(existing ? { id: existing.id } : {}),\n        key,\n        value,\n        updated_at: new Date(),\n      },\n    ]);\n  }\n\n  /** 저장값을 지워 env 기본값으로 되돌린다. */\n  async clearByKey(key: string): Promise<void> {\n    const existing = await this.findOne(\"A\", { key, num: 1, page: 1 });\n    if (existing) await this.del([existing.id]);\n  }\n\n  /**\n   * 편집 가능한 설정과 읽기 전용 런타임 정보. 편집 대상은 `SETTING_DEFS` 에 정의된 것뿐이다 —\n   * DB 접속 정보나 포트는 서버가 뜨기 전에 필요해 화면에서 바꿀 수 없다.\n   */\n  @api({ httpMethod: \"GET\", clients: [\"axios\", \"tanstack-query\"], resourceName: \"SettingList\" })\n  async listSettings(): Promise<SettingsResponse> {\n    const settings: SettingItem[] = SETTING_DEFS.map((def) => {\n      // 저장값도 env 도 없으면 코드 기본값이 실제로 적용 중이다. 빈칸으로 두면 화면과\n      // 런타임이 어긋나 보인다.\n      const stored = isStored(def.key);\n      const raw = getSetting(def.key, def.envKey);\n      const effective = raw ?? def.fallback;\n      const source = stored ? \"db\" : raw !== undefined ? \"env\" : \"default\";\n\n      return {\n        key: def.key,\n        group: def.group,\n        label: def.label,\n        kind: def.kind,\n        applies: def.applies,\n        // 눈 토글을 위해 secret 도 원본을 내려보낸다. 이 엔드포인트는 배포 경계에서 인증해야\n        // 하며, dev0 는 Caddy 인증을 통과한 운영자만 접근할 수 있다.\n        value: effective,\n        source,\n        min: def.min ?? null,\n        max: def.max ?? null,\n        help: def.help ?? null,\n      };\n    });\n\n    return { settings, runtime: this.runtimeInfo() };\n  }\n\n  private runtimeInfo(): RuntimeInfoItem[] {\n    const env = process.env;\n    const password = env.QGRID_DB_PASSWORD ?? env.SONAMU_DB_PASSWORD ?? \"\";\n    return [\n      { label: \"NODE_ENV\", value: env.NODE_ENV ?? \"-\" },\n      { label: \"HOST\", value: env.HOST ?? \"localhost\" },\n      { label: \"PORT\", value: env.PORT ?? \"44900\" },\n      { label: \"DB Host\", value: env.QGRID_DB_HOST ?? env.SONAMU_DB_HOST ?? \"-\" },\n      { label: \"DB Port\", value: env.QGRID_DB_PORT ?? env.SONAMU_DB_PORT ?? \"-\" },\n      { label: \"DB Name\", value: env.QGRID_DB_NAME ?? env.SONAMU_DB_NAME ?? \"-\" },\n      { label: \"DB User\", value: env.QGRID_DB_USER ?? env.SONAMU_DB_USER ?? \"-\" },\n      { label: \"DB Password\", value: password ? maskSecret(password) : \"-\" },\n    ];\n  }\n\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async updateSetting(key: string, value: string): Promise<{ applies: SettingApplies }> {\n    const def = findSettingDef(key);\n    if (!def) throw new BadRequestException(SD(\"setting.unknownKey\")(key));\n\n    const validation = validateSettingValue(def, value);\n    if (!validation.ok) {\n      throw new BadRequestException(SD(\"setting.invalidValue\")(validation.error));\n    }\n\n    await saveStoredSetting(key, validation.value);\n    return { applies: def.applies };\n  }\n\n  /** 저장값을 지워 env 기본값으로 되돌린다. */\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async resetSetting(key: string): Promise<{ applies: SettingApplies }> {\n    const def = findSettingDef(key);\n    if (!def) throw new BadRequestException(SD(\"setting.unknownKey\")(key));\n\n    await resetStoredSetting(key);\n    return { applies: def.applies };\n  }\n}\n\nexport const SettingModel = new SettingModelClass();\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"setting.model.js","names":["saveStoredSetting","resetStoredSetting"],"sources":["../../../src/application/setting/setting.model.ts"],"sourcesContent":["import {\n  BaseModelClass,\n  type ListResult,\n  asArray,\n  NotFoundException,\n  BadRequestException,\n  api,\n  exhaustive,\n} from \"sonamu\";\n\nimport { SD } from \"../../i18n/sd.generated\";\nimport { type SettingSubsetKey, type SettingSubsetMapping } from \"../sonamu.generated\";\nimport { settingSubsetQueries, settingLoaderQueries } from \"../sonamu.generated.sso\";\nimport { findSettingDef, maskSecret, SETTING_DEFS, validateSettingValue } from \"./setting.constant\";\nimport {\n  getSetting,\n  isStored,\n  resetSetting as resetStoredSetting,\n  saveSetting as saveStoredSetting,\n} from \"./setting.store\";\nimport {\n  type RuntimeInfoItem,\n  type SettingApplies,\n  type SettingItem,\n  type SettingListParams,\n  type SettingSaveParams,\n  type SettingsResponse,\n} from \"./setting.types\";\n\n/*\n  Setting Model\n*/\nclass SettingModelClass extends BaseModelClass<\n  SettingSubsetKey,\n  SettingSubsetMapping,\n  typeof settingSubsetQueries,\n  typeof settingLoaderQueries\n> {\n  constructor() {\n    super(\"Setting\", settingSubsetQueries, settingLoaderQueries);\n  }\n\n  @api({ httpMethod: \"GET\", clients: [\"axios\", \"tanstack-query\"], resourceName: \"Setting\" })\n  async findById<T extends SettingSubsetKey>(\n    subset: T,\n    id: number,\n  ): Promise<SettingSubsetMapping[T]> {\n    const { rows } = await this.findMany(subset, {\n      id,\n      num: 1,\n      page: 1,\n    });\n    if (!rows[0]) {\n      throw new NotFoundException(SD(\"error.entityNotFound\")(\"Setting\", id));\n    }\n\n    return rows[0];\n  }\n\n  async findOne<T extends SettingSubsetKey>(\n    subset: T,\n    listParams: SettingListParams,\n  ): Promise<SettingSubsetMapping[T] | null> {\n    const { rows } = await this.findMany(subset, {\n      ...listParams,\n      num: 1,\n      page: 1,\n    });\n\n    return rows[0] ?? null;\n  }\n\n  @api({ httpMethod: \"GET\", clients: [\"axios\", \"tanstack-query\"], resourceName: \"Settings\" })\n  async findMany<T extends SettingSubsetKey, LP extends SettingListParams>(\n    subset: T,\n    rawParams?: LP,\n  ): Promise<ListResult<LP, SettingSubsetMapping[T]>> {\n    // params with defaults\n    const params = {\n      num: 24,\n      page: 1,\n      search: \"key\" as const,\n      orderBy: \"key-asc\" as const,\n      ...rawParams,\n    } satisfies SettingListParams;\n\n    // build queries\n    const { qb, onSubset: _ } = this.getSubsetQueries(subset);\n\n    // id\n    if (params.id) {\n      qb.whereIn(\"settings.id\", asArray(params.id));\n    }\n\n    // key — toFilter prop 이지만 스캐폴딩이 만들어주지 않아 직접 건다.\n    if (params.key) {\n      qb.where(\"settings.key\", params.key);\n    }\n\n    // search-keyword\n    if (params.search && params.keyword && params.keyword.length > 0) {\n      if (params.search === \"key\") {\n        qb.where(\"settings.key\", \"like\", `%${params.keyword}%`);\n      } else {\n        throw new BadRequestException(SD(\"error.unknownSearchField\")(params.search));\n      }\n    }\n\n    // orderBy\n    if (params.orderBy) {\n      // default orderBy\n      if (params.orderBy === \"key-asc\") {\n        qb.orderBy(\"settings.key\", \"asc\");\n      } else {\n        exhaustive(params.orderBy);\n      }\n    }\n\n    const enhancers = this.createEnhancers({\n      A: (row) => ({\n        ...row,\n        // 서브셋별로 virtual 필드 계산로직 추가\n      }),\n    });\n\n    return this.executeSubsetQuery({\n      subset,\n      qb,\n      params,\n      enhancers,\n      debug: false,\n    });\n  }\n\n  async save(spa: SettingSaveParams[]): Promise<number[]> {\n    const wdb = this.getPuri(\"w\");\n\n    // register\n    spa.forEach((sp) => {\n      wdb.ubRegister(\"settings\", sp);\n    });\n\n    // transaction\n    return wdb.transaction(async (trx) => {\n      const ids = await trx.ubUpsert(\"settings\");\n\n      return ids;\n    });\n  }\n\n  async del(ids: number[]): Promise<number> {\n    const wdb = this.getPuri(\"w\");\n\n    // transaction\n    await wdb.transaction(async (trx) => {\n      return trx.table(\"settings\").whereIn(\"settings.id\", ids).delete();\n    });\n\n    return ids.length;\n  }\n\n  /** 저장된 설정 전체를 key→value 로. 부팅 시 한 번 읽어 메모리에 올린다. */\n  async findAllAsMap(): Promise<Map<string, string>> {\n    const { rows } = await this.findMany(\"A\", { num: 0, page: 1 });\n    return new Map(rows.map((r) => [r.key, r.value]));\n  }\n\n  /**\n   * key 로 upsert 한다. `save` 는 id 기준이라 key 중복을 걸러내지 못해, 기존 행을 먼저 찾아\n   * id 를 실어 보낸다.\n   */\n  async setByKey(key: string, value: string): Promise<void> {\n    const existing = await this.findOne(\"A\", { key, num: 1, page: 1 });\n    await this.save([\n      {\n        ...(existing ? { id: existing.id } : {}),\n        key,\n        value,\n        updated_at: new Date(),\n      },\n    ]);\n  }\n\n  /** 저장값을 지워 env 기본값으로 되돌린다. */\n  async clearByKey(key: string): Promise<void> {\n    const existing = await this.findOne(\"A\", { key, num: 1, page: 1 });\n    if (existing) await this.del([existing.id]);\n  }\n\n  /**\n   * 편집 가능한 설정과 읽기 전용 런타임 정보. 편집 대상은 `SETTING_DEFS` 에 정의된 것뿐이다 —\n   * DB 접속 정보나 포트는 서버가 뜨기 전에 필요해 화면에서 바꿀 수 없다.\n   */\n  @api({ httpMethod: \"GET\", clients: [\"axios\", \"tanstack-query\"], resourceName: \"SettingList\" })\n  async listSettings(): Promise<SettingsResponse> {\n    const settings: SettingItem[] = SETTING_DEFS.map((def) => {\n      // 저장값도 env 도 없으면 코드 기본값이 실제로 적용 중이다. 빈칸으로 두면 화면과\n      // 런타임이 어긋나 보인다.\n      const stored = isStored(def.key);\n      const raw = getSetting(def.key, def.envKey);\n      const effective = raw ?? def.fallback;\n      const source = stored ? \"db\" : raw !== undefined ? \"env\" : \"default\";\n\n      return {\n        key: def.key,\n        group: def.group,\n        label: def.label,\n        kind: def.kind,\n        applies: def.applies,\n        // 눈 토글을 위해 secret 도 원본을 내려보낸다. 이 엔드포인트는 배포 경계에서 인증해야\n        // 하며, dev0 는 Caddy 인증을 통과한 운영자만 접근할 수 있다.\n        value: effective,\n        source,\n        min: def.min ?? null,\n        max: def.max ?? null,\n        presets: def.presets ?? [],\n        help: def.help ?? null,\n      };\n    });\n\n    return { settings, runtime: this.runtimeInfo() };\n  }\n\n  private runtimeInfo(): RuntimeInfoItem[] {\n    const env = process.env;\n    const password = env.QGRID_DB_PASSWORD ?? env.SONAMU_DB_PASSWORD ?? \"\";\n    return [\n      { label: \"NODE_ENV\", value: env.NODE_ENV ?? \"-\" },\n      { label: \"HOST\", value: env.HOST ?? \"localhost\" },\n      { label: \"PORT\", value: env.PORT ?? \"44900\" },\n      { label: \"DB Host\", value: env.QGRID_DB_HOST ?? env.SONAMU_DB_HOST ?? \"-\" },\n      { label: \"DB Port\", value: env.QGRID_DB_PORT ?? env.SONAMU_DB_PORT ?? \"-\" },\n      { label: \"DB Name\", value: env.QGRID_DB_NAME ?? env.SONAMU_DB_NAME ?? \"-\" },\n      { label: \"DB User\", value: env.QGRID_DB_USER ?? env.SONAMU_DB_USER ?? \"-\" },\n      { label: \"DB Password\", value: password ? maskSecret(password) : \"-\" },\n    ];\n  }\n\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async updateSetting(key: string, value: string): Promise<{ applies: SettingApplies }> {\n    const def = findSettingDef(key);\n    if (!def) throw new BadRequestException(SD(\"setting.unknownKey\")(key));\n\n    const validation = validateSettingValue(def, value);\n    if (!validation.ok) {\n      throw new BadRequestException(SD(\"setting.invalidValue\")(validation.error));\n    }\n\n    await saveStoredSetting(key, validation.value);\n    return { applies: def.applies };\n  }\n\n  /** 저장값을 지워 env 기본값으로 되돌린다. */\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async resetSetting(key: string): Promise<{ applies: SettingApplies }> {\n    const def = findSettingDef(key);\n    if (!def) throw new BadRequestException(SD(\"setting.unknownKey\")(key));\n\n    await resetStoredSetting(key);\n    return { applies: def.applies };\n  }\n\n  /**\n   * 만료 알림을 지금 한 번 보낸다. 주기를 기다리지 않고 설정이 제대로 붙었는지 확인하거나,\n   * 재로그인을 재촉할 때 쓴다. 보낸 건수를 돌려줘 \"보낼 대상 없음\"과 구분한다.\n   */\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async triggerExpiryReminder(): Promise<{ sent: number }> {\n    // 동적 import 로 알림 모듈을 호출 시점에만 끌어온다. 정적으로 걸면\n    // setting.model → expired-token-reminder → token.model 경로가 생겨,\n    // token.model 을 mock 하는 테스트가 실제 모듈을 먼저 로드하게 된다.\n    const { sendExpiredTokenReminderNow } = await import(\"../qgrid/expired-token-reminder\");\n    return { sent: await sendExpiredTokenReminderNow() };\n  }\n}\n\nexport const SettingModel = new SettingModelClass();\n"],"mappings":"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"}

package/bundle/dist/application/setting/setting.types.js

@@ -11,7 +11,8 @@ const SettingKind = z.enum([
 	"integer",
 	"number",
 	"string",
-	"secret"
+	"secret",
+	"preset"
 ]);
 const SettingApplies = z.enum(["immediate", "restart"]);
 const SettingSource = z.enum([
@@ -31,6 +32,8 @@ const SettingItem = z.object({
 	source: SettingSource,
 	min: z.number().nullable(),
 	max: z.number().nullable(),
+	/** `preset` 종류에서 고를 수 있는 값. 다른 종류는 빈 배열. */
+	presets: z.number().array(),
 	help: z.string().nullable()
 });
 /** 화면에서 바꿀 수 없는 기동 시점 값들 — 어떤 환경에 붙어 있는지 확인용. */
@@ -45,4 +48,4 @@ const SettingsResponse = z.object({
 //#endregion
 export { RuntimeInfoItem, SettingApplies, SettingItem, SettingKind, SettingListParams, SettingSaveParams, SettingSource, SettingsResponse };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/bundle/dist/sonamu.config.js

@@ -136,7 +136,7 @@ var sonamu_config_default = defineConfig({
 				const log = getLogger(["qgrid", "startup"]);
 				await loadSettings();
 				setSettingChangeHandler((key) => {
-					if (key === "slack.expiryReminderMinutes") rescheduleExpiredTokenReminder();
+					if (key === "slack.expiryReminderMinutes" || key === "slack.remindersEnabled") rescheduleExpiredTokenReminder();
 				});
 				let triggerReady = true;
 				try {
@@ -193,4 +193,4 @@ var sonamu_config_default = defineConfig({
 //#endregion
 export { sonamu_config_default as default };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"sonamu.config.js","names":["cacheDrivers"],"sources":["../src/sonamu.config.ts"],"sourcesContent":["import path from \"path\";\n\nimport { getConsoleSink } from \"@logtape/logtape\";\nimport { getLogger } from \"@logtape/logtape\";\nimport { getPrettyFormatter } from \"@logtape/pretty\";\nimport { CachePresets, defineConfig } from \"sonamu\";\nimport { drivers as cacheDrivers, store } from \"sonamu/cache\";\n\nimport { monitLogSink } from \"./application/monit/log-buffer\";\nimport {\n  rescheduleExpiredTokenReminder,\n  startExpiredTokenReminder,\n  stopExpiredTokenReminder,\n} from \"./application/qgrid/expired-token-reminder\";\nimport { QgridDispatcher } from \"./application/qgrid/qgrid.dispatcher\";\nimport { QgridFrame } from \"./application/qgrid/qgrid.frame\";\nimport { TokenSubscriber } from \"./application/qgrid/token-subscriber\";\nimport { ensureTokensTrigger } from \"./application/qgrid/token-trigger-setup\";\nimport { loadSettings, setSettingChangeHandler } from \"./application/setting/setting.store\";\nimport { handleServerError } from \"./server-error-handler\";\nimport { AnthropicDispatcher } from \"./utils/providers/anthropic/anthropic-dispatcher\";\nimport { OpenAIDispatcher } from \"./utils/providers/openai/openai-dispatcher\";\n\nconst host = process.env.HOST ?? \"localhost\";\nconst port = Number(process.env.PORT ?? 44900);\n\nconst connConfig = {\n  host: process.env.SONAMU_DB_HOST ?? \"localhost\",\n  port: Number(process.env.SONAMU_DB_PORT ?? 5432),\n  user: process.env.SONAMU_DB_USER ?? \"postgres\",\n  password: process.env.SONAMU_DB_PASSWORD ?? \"postgres\",\n  database: process.env.SONAMU_DB_NAME ?? \"qgrid\",\n};\n\nexport default defineConfig({\n  projectName: process.env.PROJECT_NAME ?? \"Qgrid\",\n  database: {\n    defaultOptions: {\n      connection: {\n        ...connConfig,\n        keepAlive: true,\n        keepAliveInitialDelayMillis: 10000,\n      },\n    },\n  },\n  api: {\n    dir: \"api\",\n    timezone: \"Asia/Seoul\",\n    route: {\n      prefix: \"/api\",\n    },\n  },\n  i18n: {\n    defaultLocale: \"ko\",\n    supportedLocales: [\"ko\", \"en\"],\n  },\n  sync: {\n    targets: [\"web\"],\n  },\n  test: {\n    parallel: true,\n    maxWorkers: 4,\n    devRunner: { enabled: true },\n  },\n  logging: {\n    sinks: {\n      console: getConsoleSink({\n        formatter: getPrettyFormatter({\n          timestamp: \"time\",\n          categoryWidth: 20,\n          categoryTruncate: \"middle\",\n        }),\n      }),\n      // Monit 탭용 in-memory ring buffer. 포맷은 sink 별 — 콘솔 출력은 그대로다.\n      monit: monitLogSink,\n    },\n    loggers: [\n      // qgrid 로그 (요청 분배, oauth/usage API)\n      { category: [\"qgrid\"], sinks: [\"console\", \"monit\"], lowestLevel: \"info\" },\n      // sonamu 로그는 warning 이상만\n      { category: [\"sonamu\"], sinks: [\"console\", \"monit\"], lowestLevel: \"warning\" },\n      // fastify 로그 차단\n      { category: [\"fastify\"], sinks: [], lowestLevel: \"fatal\" },\n    ],\n  },\n  server: {\n    listen: { port, host },\n    fastify: {\n      bodyLimit: 10 * 1024 * 1024,\n    },\n    plugins: {\n      formbody: true,\n      qs: true,\n      sse: true,\n      multipart: { limits: { fileSize: 1024 * 1024 * 30 } },\n      static: {\n        root: path.join(import.meta.dirname, \"/../\", \"public\"),\n        prefix: \"/api/public\",\n      },\n      custom: (server) => {\n        // OAuth 콜백 — Anthropic이 /callback으로 리다이렉트\n        server.get(\"/callback\", async (request, reply) => {\n          const { code, state } = request.query as { code?: string; state?: string };\n          if (!code || !state) {\n            return reply.redirect(\"/?oauth=error&reason=missing_params\");\n          }\n          try {\n            return QgridFrame.handleOAuthCallback(code, state, reply);\n          } catch (e) {\n            return reply.redirect(\n              `/?oauth=error&reason=${encodeURIComponent((e as Error).message)}`,\n            );\n          }\n        });\n\n        // OpenAI OAuth 는 codex app-server 가 자체 callback 서버를 올림\n        // handleOpenAICallback 불필요 — oauthCompleteOpenAI API 로 완료 확인\n      },\n    },\n    apiConfig: {\n      contextProvider: (defaultContext, request) => {\n        return {\n          ...defaultContext,\n          ip: request.ip,\n          body: request.body,\n        };\n      },\n      guardHandler: () => {},\n      cacheControlHandler: (req) => {\n        switch (req.type) {\n          case \"assets\":\n            // Hash 포함된 파일: 영구 캐시\n            if (req.path.match(/-[a-f0-9]+\\./)) {\n              return CachePresets.immutable;\n            }\n            return CachePresets.longLived;\n\n          case \"api\":\n            // GET 요청만 캐싱 고려\n            if (req.method === \"GET\") {\n              // 특정 경로는 짧은 캐시\n              if (req.path.startsWith(\"/api/static-data\")) {\n                return CachePresets.shortLived;\n              }\n              if (req.path.startsWith(\"/api/terms\")) {\n                return CachePresets.mediumLived;\n              }\n            }\n            // 기본: 캐시 없음\n            return CachePresets.noCache;\n\n          case \"ssr\":\n            // SSR 페이지: 10초 캐시\n            return CachePresets.ssr;\n\n          case \"csr\":\n            // CSR fallback (index.html): 1분 캐시\n            return CachePresets.shortLived;\n        }\n        return CachePresets.noCache;\n      },\n    },\n    cache: {\n      default: \"main\",\n      stores: {\n        main: store().useL1Layer(cacheDrivers.memory({ maxSize: \"50mb\" })),\n      },\n      ttl: \"5m\",\n      prefix: \"\",\n    },\n    lifecycle: {\n      onStart: async () => {\n        const log = getLogger([\"qgrid\", \"startup\"]);\n\n        // dispatcher 가 생성자에서 워커 설정을 읽으므로 그 전에 올려야 한다.\n        await loadSettings();\n        // 런타임 설정 소비자를 상위 계층에서 연결해 setting 모듈이 qgrid 를 역참조하지 않게 한다.\n        setSettingChangeHandler((key) => {\n          if (key === \"slack.expiryReminderMinutes\") rescheduleExpiredTokenReminder();\n        });\n\n        let triggerReady = true;\n        try {\n          await ensureTokensTrigger(connConfig);\n        } catch (e) {\n          triggerReady = false;\n          log.warn(`trigger setup failed: ${(e as Error).message}`);\n        }\n\n        const subscriber = new TokenSubscriber(connConfig, QgridDispatcher);\n        QgridDispatcher.subscriber = subscriber;\n\n        const started = await subscriber.start();\n\n        // 기동 상태를 남긴다 — HTTP 는 이미 열려 있어서, 준비 전 요청이 \"잠시 후 되는지\"\n        // \"재시도해도 안 되는지\"를 구분해 응답해야 한다(503 vs 500).\n        try {\n          const openaiDispatcher = new OpenAIDispatcher();\n          await openaiDispatcher.start();\n          QgridDispatcher.openaiDispatcher = openaiDispatcher;\n          QgridDispatcher.startupState.openai = \"ready\";\n        } catch (e) {\n          QgridDispatcher.startupState.openai = \"failed\";\n          log.warn(`openai dispatcher failed: ${(e as Error).message}`);\n        }\n\n        try {\n          const anthropicDispatcher = new AnthropicDispatcher();\n          await anthropicDispatcher.start();\n          QgridDispatcher.anthropicDispatcher = anthropicDispatcher;\n          QgridDispatcher.startupState.anthropic = \"ready\";\n        } catch (e) {\n          QgridDispatcher.startupState.anthropic = \"failed\";\n          log.warn(`anthropic dispatcher failed: ${(e as Error).message}`);\n        }\n\n        startExpiredTokenReminder();\n\n        const anthropicCount = QgridDispatcher.anthropicDispatcher?.tokenCount ?? 0;\n        const openaiReady = QgridDispatcher.openaiDispatcher?.readyWorkerCount ?? 0;\n        const openaiTotal = QgridDispatcher.openaiDispatcher?.workerCount ?? 0;\n\n        log.info(`listening on http://${host}:${port}`);\n        log.info(`anthropic: ${anthropicCount} tokens ready`);\n        log.info(`openai: ${openaiReady}/${openaiTotal} tokens ready`);\n        log.info(\n          `subscriber: ${started ? \"LISTEN active\" : \"degraded\"}${triggerReady ? \"\" : \", trigger failed\"}`,\n        );\n      },\n      onShutdown: async () => {\n        const log = getLogger([\"qgrid\", \"startup\"]);\n        stopExpiredTokenReminder();\n        setSettingChangeHandler(null);\n        if (QgridDispatcher.openaiDispatcher) {\n          await QgridDispatcher.openaiDispatcher.stop();\n        }\n        if (QgridDispatcher.anthropicDispatcher) {\n          await QgridDispatcher.anthropicDispatcher.stop();\n        }\n        if (QgridDispatcher.subscriber) {\n          await QgridDispatcher.subscriber.stop();\n        }\n        log.info(\"graceful shutdown\");\n      },\n      onError: (error, _request, reply) => {\n        handleServerError(error, reply);\n      },\n    },\n  },\n});\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"sonamu.config.js","names":["cacheDrivers"],"sources":["../src/sonamu.config.ts"],"sourcesContent":["import path from \"path\";\n\nimport { getConsoleSink } from \"@logtape/logtape\";\nimport { getLogger } from \"@logtape/logtape\";\nimport { getPrettyFormatter } from \"@logtape/pretty\";\nimport { CachePresets, defineConfig } from \"sonamu\";\nimport { drivers as cacheDrivers, store } from \"sonamu/cache\";\n\nimport { monitLogSink } from \"./application/monit/log-buffer\";\nimport {\n  rescheduleExpiredTokenReminder,\n  startExpiredTokenReminder,\n  stopExpiredTokenReminder,\n} from \"./application/qgrid/expired-token-reminder\";\nimport { QgridDispatcher } from \"./application/qgrid/qgrid.dispatcher\";\nimport { QgridFrame } from \"./application/qgrid/qgrid.frame\";\nimport { TokenSubscriber } from \"./application/qgrid/token-subscriber\";\nimport { ensureTokensTrigger } from \"./application/qgrid/token-trigger-setup\";\nimport { loadSettings, setSettingChangeHandler } from \"./application/setting/setting.store\";\nimport { handleServerError } from \"./server-error-handler\";\nimport { AnthropicDispatcher } from \"./utils/providers/anthropic/anthropic-dispatcher\";\nimport { OpenAIDispatcher } from \"./utils/providers/openai/openai-dispatcher\";\n\nconst host = process.env.HOST ?? \"localhost\";\nconst port = Number(process.env.PORT ?? 44900);\n\nconst connConfig = {\n  host: process.env.SONAMU_DB_HOST ?? \"localhost\",\n  port: Number(process.env.SONAMU_DB_PORT ?? 5432),\n  user: process.env.SONAMU_DB_USER ?? \"postgres\",\n  password: process.env.SONAMU_DB_PASSWORD ?? \"postgres\",\n  database: process.env.SONAMU_DB_NAME ?? \"qgrid\",\n};\n\nexport default defineConfig({\n  projectName: process.env.PROJECT_NAME ?? \"Qgrid\",\n  database: {\n    defaultOptions: {\n      connection: {\n        ...connConfig,\n        keepAlive: true,\n        keepAliveInitialDelayMillis: 10000,\n      },\n    },\n  },\n  api: {\n    dir: \"api\",\n    timezone: \"Asia/Seoul\",\n    route: {\n      prefix: \"/api\",\n    },\n  },\n  i18n: {\n    defaultLocale: \"ko\",\n    supportedLocales: [\"ko\", \"en\"],\n  },\n  sync: {\n    targets: [\"web\"],\n  },\n  test: {\n    parallel: true,\n    maxWorkers: 4,\n    devRunner: { enabled: true },\n  },\n  logging: {\n    sinks: {\n      console: getConsoleSink({\n        formatter: getPrettyFormatter({\n          timestamp: \"time\",\n          categoryWidth: 20,\n          categoryTruncate: \"middle\",\n        }),\n      }),\n      // Monit 탭용 in-memory ring buffer. 포맷은 sink 별 — 콘솔 출력은 그대로다.\n      monit: monitLogSink,\n    },\n    loggers: [\n      // qgrid 로그 (요청 분배, oauth/usage API)\n      { category: [\"qgrid\"], sinks: [\"console\", \"monit\"], lowestLevel: \"info\" },\n      // sonamu 로그는 warning 이상만\n      { category: [\"sonamu\"], sinks: [\"console\", \"monit\"], lowestLevel: \"warning\" },\n      // fastify 로그 차단\n      { category: [\"fastify\"], sinks: [], lowestLevel: \"fatal\" },\n    ],\n  },\n  server: {\n    listen: { port, host },\n    fastify: {\n      bodyLimit: 10 * 1024 * 1024,\n    },\n    plugins: {\n      formbody: true,\n      qs: true,\n      sse: true,\n      multipart: { limits: { fileSize: 1024 * 1024 * 30 } },\n      static: {\n        root: path.join(import.meta.dirname, \"/../\", \"public\"),\n        prefix: \"/api/public\",\n      },\n      custom: (server) => {\n        // OAuth 콜백 — Anthropic이 /callback으로 리다이렉트\n        server.get(\"/callback\", async (request, reply) => {\n          const { code, state } = request.query as { code?: string; state?: string };\n          if (!code || !state) {\n            return reply.redirect(\"/?oauth=error&reason=missing_params\");\n          }\n          try {\n            return QgridFrame.handleOAuthCallback(code, state, reply);\n          } catch (e) {\n            return reply.redirect(\n              `/?oauth=error&reason=${encodeURIComponent((e as Error).message)}`,\n            );\n          }\n        });\n\n        // OpenAI OAuth 는 codex app-server 가 자체 callback 서버를 올림\n        // handleOpenAICallback 불필요 — oauthCompleteOpenAI API 로 완료 확인\n      },\n    },\n    apiConfig: {\n      contextProvider: (defaultContext, request) => {\n        return {\n          ...defaultContext,\n          ip: request.ip,\n          body: request.body,\n        };\n      },\n      guardHandler: () => {},\n      cacheControlHandler: (req) => {\n        switch (req.type) {\n          case \"assets\":\n            // Hash 포함된 파일: 영구 캐시\n            if (req.path.match(/-[a-f0-9]+\\./)) {\n              return CachePresets.immutable;\n            }\n            return CachePresets.longLived;\n\n          case \"api\":\n            // GET 요청만 캐싱 고려\n            if (req.method === \"GET\") {\n              // 특정 경로는 짧은 캐시\n              if (req.path.startsWith(\"/api/static-data\")) {\n                return CachePresets.shortLived;\n              }\n              if (req.path.startsWith(\"/api/terms\")) {\n                return CachePresets.mediumLived;\n              }\n            }\n            // 기본: 캐시 없음\n            return CachePresets.noCache;\n\n          case \"ssr\":\n            // SSR 페이지: 10초 캐시\n            return CachePresets.ssr;\n\n          case \"csr\":\n            // CSR fallback (index.html): 1분 캐시\n            return CachePresets.shortLived;\n        }\n        return CachePresets.noCache;\n      },\n    },\n    cache: {\n      default: \"main\",\n      stores: {\n        main: store().useL1Layer(cacheDrivers.memory({ maxSize: \"50mb\" })),\n      },\n      ttl: \"5m\",\n      prefix: \"\",\n    },\n    lifecycle: {\n      onStart: async () => {\n        const log = getLogger([\"qgrid\", \"startup\"]);\n\n        // dispatcher 가 생성자에서 워커 설정을 읽으므로 그 전에 올려야 한다.\n        await loadSettings();\n        // 런타임 설정 소비자를 상위 계층에서 연결해 setting 모듈이 qgrid 를 역참조하지 않게 한다.\n        setSettingChangeHandler((key) => {\n          if (key === \"slack.expiryReminderMinutes\" || key === \"slack.remindersEnabled\") {\n            rescheduleExpiredTokenReminder();\n          }\n        });\n\n        let triggerReady = true;\n        try {\n          await ensureTokensTrigger(connConfig);\n        } catch (e) {\n          triggerReady = false;\n          log.warn(`trigger setup failed: ${(e as Error).message}`);\n        }\n\n        const subscriber = new TokenSubscriber(connConfig, QgridDispatcher);\n        QgridDispatcher.subscriber = subscriber;\n\n        const started = await subscriber.start();\n\n        // 기동 상태를 남긴다 — HTTP 는 이미 열려 있어서, 준비 전 요청이 \"잠시 후 되는지\"\n        // \"재시도해도 안 되는지\"를 구분해 응답해야 한다(503 vs 500).\n        try {\n          const openaiDispatcher = new OpenAIDispatcher();\n          await openaiDispatcher.start();\n          QgridDispatcher.openaiDispatcher = openaiDispatcher;\n          QgridDispatcher.startupState.openai = \"ready\";\n        } catch (e) {\n          QgridDispatcher.startupState.openai = \"failed\";\n          log.warn(`openai dispatcher failed: ${(e as Error).message}`);\n        }\n\n        try {\n          const anthropicDispatcher = new AnthropicDispatcher();\n          await anthropicDispatcher.start();\n          QgridDispatcher.anthropicDispatcher = anthropicDispatcher;\n          QgridDispatcher.startupState.anthropic = \"ready\";\n        } catch (e) {\n          QgridDispatcher.startupState.anthropic = \"failed\";\n          log.warn(`anthropic dispatcher failed: ${(e as Error).message}`);\n        }\n\n        startExpiredTokenReminder();\n\n        const anthropicCount = QgridDispatcher.anthropicDispatcher?.tokenCount ?? 0;\n        const openaiReady = QgridDispatcher.openaiDispatcher?.readyWorkerCount ?? 0;\n        const openaiTotal = QgridDispatcher.openaiDispatcher?.workerCount ?? 0;\n\n        log.info(`listening on http://${host}:${port}`);\n        log.info(`anthropic: ${anthropicCount} tokens ready`);\n        log.info(`openai: ${openaiReady}/${openaiTotal} tokens ready`);\n        log.info(\n          `subscriber: ${started ? \"LISTEN active\" : \"degraded\"}${triggerReady ? \"\" : \", trigger failed\"}`,\n        );\n      },\n      onShutdown: async () => {\n        const log = getLogger([\"qgrid\", \"startup\"]);\n        stopExpiredTokenReminder();\n        setSettingChangeHandler(null);\n        if (QgridDispatcher.openaiDispatcher) {\n          await QgridDispatcher.openaiDispatcher.stop();\n        }\n        if (QgridDispatcher.anthropicDispatcher) {\n          await QgridDispatcher.anthropicDispatcher.stop();\n        }\n        if (QgridDispatcher.subscriber) {\n          await QgridDispatcher.subscriber.stop();\n        }\n        log.info(\"graceful shutdown\");\n      },\n      onError: (error, _request, reply) => {\n        handleServerError(error, reply);\n      },\n    },\n  },\n});\n"],"mappings":"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"}