@cartanova/qgrid-cli 2.6.7 → 2.6.9

package/bundle/dist/application/monit/monit.frame.js

@@ -1,8 +1,8 @@
 import { monitLogBuffer } from "./log-buffer.js";
-import { resolveOpenAIWorkerPoolConfig } from "../../utils/providers/openai/openai-worker-pool-config.js";
-import { QgridDispatcher } from "../qgrid/qgrid.dispatcher.js";
 import __decorateMetadata from "../../_virtual/_@oxc-project_runtime@0.140.0/helpers/esm/decorateMetadata.js";
 import __decorate from "../../_virtual/_@oxc-project_runtime@0.140.0/helpers/esm/decorate.js";
+import { resolveOpenAIWorkerPoolConfig } from "../../utils/providers/openai/openai-worker-pool-config.js";
+import { QgridDispatcher } from "../qgrid/qgrid.dispatcher.js";
 import { BaseFrameClass, DB, api } from "sonamu";
 //#region src/application/monit/monit.frame.ts
 /**

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

@@ -1,3 +1,4 @@
+import { getSetting } from "../setting/setting.store.js";
 import { SLACK_COLOR, notifySlack } from "../../utils/slack-notify.js";
 import { TokenModel } from "../token/token.model.js";
 import { getSlackUserMap, mentionFor } from "./slack-user-map.js";
@@ -17,6 +18,12 @@ import { getLogger } from "@logtape/logtape";
 */
 const logger = getLogger(["qgrid", "expired-reminder"]);
 const MINUTE_MS = 6e4;
+const defaultDeps = {
+	findInactive: () => TokenModel.findInactive("A"),
+	getSlackUserMap,
+	readSetting: getSetting,
+	sendSlack: notifySlack
+};
 /**
 * 1건이면 제목(subject)에 토큰명이 이미 있으므로 본문에서는 뺀다 — 같은 이름을 두 번 쓰면
 * 읽는 사람이 다른 정보인 줄 알고 한 번 더 본다. 여러 건이면 제목이 건수라 본문에 남긴다.
@@ -30,31 +37,54 @@ function buildReminderContext(tokens, userMap) {
 		return mention ? `${mention} ${label}` : label;
 	}), "재로그인이 필요합니다"].filter(Boolean).join("\n");
 }
-async function sendReminder(userMap) {
-	const inactive = await TokenModel.findInactive("A");
-	if (inactive.length === 0) return;
-	await notifySlack({
+async function sendReminder(deps, urgent = false) {
+	const inactive = await deps.findInactive();
+	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)`);
+	const run = () => sendReminder(deps).catch((e) => logger.warn(`reminder failed: ${e.message}`));
+	if (runNow) run();
+	timer = setInterval(run, minutes * MINUTE_MS);
+}
 /**
 * `SLACK_EXPIRY_REMINDER_INTERVAL_MINUTES` 가 양수일 때만 켜진다. 미설정·0 이면 비활성.
 *
 * 인스턴스가 여러 개면 각자 보낸다. 만료 순간 알림과 달리 상태 변화가 없어 DB 로 억제할 수
 * 없고, 하루 몇 건 수준이라 중복을 감수하는 편이 잠금 장치를 두는 것보다 낫다.
 */
-function startExpiredTokenReminder() {
-	const minutes = Number(process.env.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)`);
-	const run = () => sendReminder(userMap).catch((e) => logger.warn(`reminder failed: ${e.message}`));
-	run();
-	timer = setInterval(run, minutes * MINUTE_MS);
+function startExpiredTokenReminder(deps = defaultDeps) {
+	scheduleExpiredTokenReminder(true, deps);
+}
+/** 설정 변경 시 기존 타이머만 새 주기로 교체한다. 저장 자체가 알림을 보내지는 않는다. */
+function rescheduleExpiredTokenReminder(deps = defaultDeps) {
+	scheduleExpiredTokenReminder(false, deps);
 }
 function stopExpiredTokenReminder() {
 	if (!timer) return;
@@ -62,6 +92,6 @@ function stopExpiredTokenReminder() {
 	timer = null;
 }
 //#endregion
-export { buildReminderContext, startExpiredTokenReminder, stopExpiredTokenReminder };
+export { buildReminderContext, rescheduleExpiredTokenReminder, sendExpiredTokenReminderNow, startExpiredTokenReminder, stopExpiredTokenReminder };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# 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/qgrid/oauth.js

@@ -1,5 +1,5 @@
-import { createHash, randomBytes } from "node:crypto";
 import { getLogger } from "@logtape/logtape";
+import { createHash, randomBytes } from "node:crypto";
 //#region src/application/qgrid/oauth.ts
 /**
 * OAuth 유틸 — Claude Code 소스의 OAuth 플로우 그대로 재현

package/bundle/dist/application/qgrid/qgrid.frame.js

@@ -1,10 +1,10 @@
+import __decorateMetadata from "../../_virtual/_@oxc-project_runtime@0.140.0/helpers/esm/decorateMetadata.js";
+import __decorate from "../../_virtual/_@oxc-project_runtime@0.140.0/helpers/esm/decorate.js";
 import { getAccessToken, getExpiresAt, getRefreshToken } from "../../utils/providers/common/credentials.js";
 import { CallerSchemaValidationError } from "../../utils/providers/common/schema-validation.js";
 import { StreamEvents } from "./qgrid.types.js";
 import { ToolSchemaCompositionError } from "./tool-emulation-schema.js";
 import { QgridDispatcher, buildAndValidateStrictOutputSchema } from "./qgrid.dispatcher.js";
-import __decorateMetadata from "../../_virtual/_@oxc-project_runtime@0.140.0/helpers/esm/decorateMetadata.js";
-import __decorate from "../../_virtual/_@oxc-project_runtime@0.140.0/helpers/esm/decorate.js";
 import { TokenModel } from "../token/token.model.js";
 import { CONSOLE_CALLBACK_URL, RefreshFailedError, buildAuthUrl, exchangeCodeForTokens, fetchUsage, generatePKCE, refreshAccessToken } from "./oauth.js";
 import { MICRO_USD, RequestLogModel } from "../request-log/request-log.model.js";
@@ -12,8 +12,8 @@ import { afterQuery, beforeQuery, finishRunAborted, finishRunWithError } from ".
 import { TokenCredentials } from "../token/token.types.js";
 import { deactivateAuthDeadToken, notifyTokenAdded } from "./token-death.js";
 import { BadRequestException, BaseFrameClass, Sonamu, api, stream } from "sonamu";
-import crypto from "node:crypto";
 import { getLogger } from "@logtape/logtape";
+import crypto from "node:crypto";
 import { getCacheManagerRef } from "sonamu/cache";
 //#region src/application/qgrid/qgrid.frame.ts
 const pendingStreams = /* @__PURE__ */ new Map();

package/bundle/dist/application/qgrid/slack-user-map.js

@@ -1,3 +1,4 @@
+import { getSetting } from "../setting/setting.store.js";
 //#region src/application/qgrid/slack-user-map.ts
 /**
 * 토큰 소유자 → Slack 사용자 멘션.
@@ -30,20 +31,10 @@ function mentionFor(tokenName, userMap) {
 	const userId = userMap.get(ownerOf(tokenName));
 	return userId ? `<@${userId}>` : "";
 }
-/**
-* 환경변수는 프로세스 수명 동안 고정이라 매번 파싱할 이유가 없다. 사망 알림은 요청 경로에서
-* 호출되므로 캐시해 둔다.
-*/
-let cached = null;
-function getSlackUserMap() {
-	cached ??= parseSlackUserMap(process.env.SLACK_USER_MAP);
-	return cached;
-}
-/** 테스트에서 env 를 바꿔 끼울 때 쓴다. */
-function resetSlackUserMapCache() {
-	cached = null;
+function getSlackUserMap(readSetting = getSetting) {
+	return parseSlackUserMap(readSetting("slack.userMap", "SLACK_USER_MAP"));
 }
 //#endregion
-export { getSlackUserMap, mentionFor, ownerOf, parseSlackUserMap, resetSlackUserMapCache };
+export { getSlackUserMap, mentionFor, ownerOf, parseSlackUserMap };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2xhY2stdXNlci1tYXAuanMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2FwcGxpY2F0aW9uL3FncmlkL3NsYWNrLXVzZXItbWFwLnRzIl0sInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICog7Yag7YGwIOyGjOycoOyekCDihpIgU2xhY2sg7IKs7Jqp7J6QIOupmOyFmC5cbiAqXG4gKiBTbGFjayDtkZzsi5wg7J2066aE6rO8IO2GoO2BsOuqheydtCDsnpDso7wg7Ja06riL64KYKGhhemXihpJoYXplLmxlZSwgYnllb25nanVu4oaScG90YWRvcykgYHVzZXJzLmxpc3RgXG4gKiDsnpDrj5kg66ek7Lmt7J2AIOyhsOyaqe2eiCDsi6TtjKjtlZzri6QuIOupmOyFmOydtCDruaDsp4DrqbQg7JWM66a87J20IOqwnOyduOyXkOqyjCDri7/sp4Ag7JWK7JWEIOuqqeyggSDsnpDssrTqsIBcbiAqIOyCrOudvOyngOuvgOuhnCBgU0xBQ0tfVVNFUl9NQVBgIOuqheyLnCDrp6TtlZHrp4wg7JO064ukLlxuICpcbiAqIOqzteyaqSDqs4TsoJUoYnlzdWNvLCBkZXYtY29tbW9uIOuTsSnsnYAg66ek7ZWR7JeQIOuEo+yngCDslYrripTri6Qg4oCUIOupmOyFmCDsl4bsnbQg7J2066aE66eMIOuCmOqwgOuKlCDqsoPsnbRcbiAqIOunnuuKlCDrj5nsnpHsnbTri6QuXG4gKi9cblxuLyoqIGDthqDtgbDrqoU6U2xhY2tVc2VySWRgIOuqqeuhneydhCDtjIzsi7HtlZzri6QuICovXG5leHBvcnQgZnVuY3Rpb24gcGFyc2VTbGFja1VzZXJNYXAocmF3OiBzdHJpbmcgfCB1bmRlZmluZWQpOiBNYXA8c3RyaW5nLCBzdHJpbmc+IHtcbiAgY29uc3QgbWFwID0gbmV3IE1hcDxzdHJpbmcsIHN0cmluZz4oKTtcbiAgaWYgKCFyYXcpIHJldHVybiBtYXA7XG5cbiAgZm9yIChjb25zdCBlbnRyeSBvZiByYXcuc3BsaXQoXCIsXCIpKSB7XG4gICAgY29uc3QgW25hbWUsIHVzZXJJZF0gPSBlbnRyeS5zcGxpdChcIjpcIikubWFwKChzKSA9PiBzLnRyaW0oKSk7XG4gICAgaWYgKG5hbWUgJiYgdXNlcklkKSBtYXAuc2V0KG5hbWUsIHVzZXJJZCk7XG4gIH1cbiAgcmV0dXJuIG1hcDtcbn1cblxuLyoqIGBhbnRocm9waWMveWRzYCDihpIgYHlkc2AuIHByb3ZpZGVyIHByZWZpeCDsl4bsnbQg7KCA7J6l65CcIOydtOumhOuPhCDqt7jrjIDroZwg67Cb64qU64ukLiAqL1xuZXhwb3J0IGZ1bmN0aW9uIG93bmVyT2YodG9rZW5OYW1lOiBzdHJpbmcgfCBudWxsKTogc3RyaW5nIHtcbiAgaWYgKCF0b2tlbk5hbWUpIHJldHVybiBcIlwiO1xuICBjb25zdCBzbGFzaCA9IHRva2VuTmFtZS5pbmRleE9mKFwiL1wiKTtcbiAgcmV0dXJuIHNsYXNoID09PSAtMSA/IHRva2VuTmFtZSA6IHRva2VuTmFtZS5zbGljZShzbGFzaCArIDEpO1xufVxuXG4vKiog66ek7ZWR7J20IOyeiOycvOuptCBgPEBVLi4uPmAsIOyXhuycvOuptCDruYgg66y47J6Q7Je0LiDtmLjstpzrtoDqsIAg66mY7IWYIOycoOustOuhnCDrrLjqtazrpbwg6rOg66W464ukLiAqL1xuZXhwb3J0IGZ1bmN0aW9uIG1lbnRpb25Gb3IodG9rZW5OYW1lOiBzdHJpbmcgfCBudWxsLCB1c2VyTWFwOiBNYXA8c3RyaW5nLCBzdHJpbmc+KTogc3RyaW5nIHtcbiAgY29uc3QgdXNlcklkID0gdXNlck1hcC5nZXQob3duZXJPZih0b2tlbk5hbWUpKTtcbiAgcmV0dXJuIHVzZXJJZCA/IGA8QCR7dXNlcklkfT5gIDogXCJcIjtcbn1cblxuLyoqXG4gKiDtmZjqsr3rs4DsiJjripQg7ZSE66Gc7IS47IqkIOyImOuqhSDrj5nslYgg6rOg7KCV7J206528IOunpOuyiCDtjIzsi7HtlaAg7J207Jyg6rCAIOyXhuuLpC4g7IKs66edIOyVjOumvOydgCDsmpTssq0g6rK966Gc7JeQ7IScXG4gKiDtmLjstpzrkJjrr4DroZwg7LqQ7Iuc7ZW0IOuRlOuLpC5cbiAqL1xubGV0IGNhY2hlZDogTWFwPHN0cmluZywgc3RyaW5nPiB8IG51bGwgPSBudWxsO1xuXG5leHBvcnQgZnVuY3Rpb24gZ2V0U2xhY2tVc2VyTWFwKCk6IE1hcDxzdHJpbmcsIHN0cmluZz4ge1xuICBjYWNoZWQgPz89IHBhcnNlU2xhY2tVc2VyTWFwKHByb2Nlc3MuZW52LlNMQUNLX1VTRVJfTUFQKTtcbiAgcmV0dXJuIGNhY2hlZDtcbn1cblxuLyoqIO2FjOyKpO2KuOyXkOyEnCBlbnYg66W8IOuwlOq/lCDrgbzsmrgg65WMIOyTtOuLpC4gKi9cbmV4cG9ydCBmdW5jdGlvbiByZXNldFNsYWNrVXNlck1hcENhY2hlKCk6IHZvaWQge1xuICBjYWNoZWQgPSBudWxsO1xufVxuIl0sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7QUFZQSxTQUFnQixrQkFBa0IsS0FBOEM7Q0FDOUUsTUFBTSxzQkFBTSxJQUFJLElBQW9CO0NBQ3BDLElBQUksQ0FBQyxLQUFLLE9BQU87Q0FFakIsS0FBSyxNQUFNLFNBQVMsSUFBSSxNQUFNLEdBQUcsR0FBRztFQUNsQyxNQUFNLENBQUMsTUFBTSxVQUFVLE1BQU0sTUFBTSxHQUFHLENBQUMsQ0FBQyxLQUFLLE1BQU0sRUFBRSxLQUFLLENBQUM7RUFDM0QsSUFBSSxRQUFRLFFBQVEsSUFBSSxJQUFJLE1BQU0sTUFBTTtDQUMxQztDQUNBLE9BQU87QUFDVDs7QUFHQSxTQUFnQixRQUFRLFdBQWtDO0NBQ3hELElBQUksQ0FBQyxXQUFXLE9BQU87Q0FDdkIsTUFBTSxRQUFRLFVBQVUsUUFBUSxHQUFHO0NBQ25DLE9BQU8sVUFBVSxLQUFLLFlBQVksVUFBVSxNQUFNLFFBQVEsQ0FBQztBQUM3RDs7QUFHQSxTQUFnQixXQUFXLFdBQTBCLFNBQXNDO0NBQ3pGLE1BQU0sU0FBUyxRQUFRLElBQUksUUFBUSxTQUFTLENBQUM7Q0FDN0MsT0FBTyxTQUFTLEtBQUssT0FBTyxLQUFLO0FBQ25DOzs7OztBQU1BLElBQUksU0FBcUM7QUFFekMsU0FBZ0Isa0JBQXVDO0NBQ3JELFdBQVcsa0JBQWtCLFFBQVEsSUFBSSxjQUFjO0NBQ3ZELE9BQU87QUFDVDs7QUFHQSxTQUFnQix5QkFBK0I7Q0FDN0MsU0FBUztBQUNYIn0=
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/bundle/dist/application/qgrid/token-death.js

@@ -70,7 +70,8 @@ function notifyLastActiveTokenDying(token, reasonCode) {
 			token.provider,
 			reasonCode
 		].filter(Boolean).join(" · ") + " · 풀이 비지 않도록 유지 중입니다. 전 토큰이 동시에 실패했다면 client_id 취소나 OAuth 계약 변경을 의심하세요",
-		color: SLACK_COLOR.bad
+		color: SLACK_COLOR.bad,
+		urgent: true
 	});
 }
 /** 로그인이 완료돼 토큰이 저장됐을 때. 신규·재로그인을 가리지 않는다. */
@@ -90,4 +91,4 @@ function notifyTokenAdded(name, provider) {
 //#endregion
 export { deactivateAuthDeadToken, notifyTokenAdded };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"token-death.js","names":[],"sources":["../../../src/application/qgrid/token-death.ts"],"sourcesContent":["/**\n * 세션 만료(auth-dead) 토큰의 라우팅 제외 지점.\n *\n * refresh 가 재로그인 외 복구 불가한 실패를 반환한 순간에만 호출된다. 비활성화는\n * `active=true` 조건부 갱신 1회이고, 그 갱신을 이긴 프로세스만 Slack 알림을 보낸다 —\n * 공유 DB 를 쓰는 인스턴스가 몇이든 사건당 알림은 1건이다.\n */\nimport { getLogger } from \"@logtape/logtape\";\n\nimport { getRefreshToken } from \"../../utils/providers/common/credentials\";\nimport { notifySlack, SLACK_COLOR } from \"../../utils/slack-notify\";\nimport { TokenModel } from \"../token/token.model\";\nimport { getSlackUserMap, mentionFor } from \"./slack-user-map\";\n\nconst logger = getLogger([\"qgrid\", \"token-death\"]);\n\ntype DeadTokenRef = {\n  id: number;\n  name: string;\n  provider: string;\n};\n\n/**\n * @param usedRefreshToken 실패한 요청이 실제로 사용한 refresh token.\n *   refresh token 은 회전 저장되므로, 이미 회전된 옛 토큰으로 늦게 도착한 재시도가\n *   400 을 받는 것은 정상 레이스다. DB 의 현재 값과 다르면 사망으로 보지 않는다.\n * @param reasonCode `provider:code` 형태의 내부 코드. provider 응답 본문에는 계정 이메일이나\n *   토큰 조각이 섞일 수 있어 raw 메시지를 그대로 알림에 싣지 않는다.\n */\nexport async function deactivateAuthDeadToken(\n  token: DeadTokenRef,\n  usedRefreshToken: string,\n  reasonCode: string,\n): Promise<boolean> {\n  const current = await TokenModel.findOne(\"A\", { id: token.id });\n  if (!current) return false;\n\n  const currentRefreshToken = getRefreshToken(current.credentials);\n  if (currentRefreshToken && currentRefreshToken !== usedRefreshToken) {\n    logger.info(\n      `skipping auth-death for ${token.name}(id=${token.id}): refresh token rotated since this attempt`,\n    );\n    return false;\n  }\n\n  const { deactivated, keptAsLastActive } = await TokenModel.deactivateIfActive(token.id);\n  if (!deactivated) {\n    if (keptAsLastActive) notifyLastActiveTokenDying(token, reasonCode);\n    return false;\n  }\n\n  logger.warn(`token deactivated (auth dead): ${token.name}(id=${token.id}) reason=${reasonCode}`);\n  // 만료 직후가 재로그인하기 가장 좋은 타이밍이다. 소유자를 멘션해 그 순간 당사자에게\n  // 꽂는다 — 다이제스트를 기다리면 다음 주기까지 토큰이 빠진 채로 남는다.\n  const mention = mentionFor(token.name, getSlackUserMap());\n  void notifySlack({\n    title: \"세션 만료\",\n    subject: token.name,\n    context: [mention, token.provider, reasonCode, \"재로그인이 필요합니다\"]\n      .filter(Boolean)\n      .join(\" · \"),\n    color: SLACK_COLOR.bad,\n  });\n  return true;\n}\n\n/**\n * 마지막 활성 토큰이 죽었을 때의 알림 쿨다운.\n *\n * 이 경우 토큰은 비활성화되지 않고 살아남으므로, 뒤따르는 요청마다 같은 실패를 반복해\n * 알림이 폭주한다. 비활성화 성공 경로가 조건부 UPDATE 로 중복을 막는 것과 달리 여기엔\n * 상태 변화가 없어 DB 로 억제할 수 없다 — provider 단위로 시간 창을 둔다.\n */\nconst LAST_ACTIVE_ALERT_COOLDOWN_MS = 30 * 60 * 1000;\nconst lastActiveAlertAt = new Map<string, number>();\n\nfunction notifyLastActiveTokenDying(token: DeadTokenRef, reasonCode: string): void {\n  const now = Date.now();\n  const previous = lastActiveAlertAt.get(token.provider);\n  if (previous !== undefined && now - previous < LAST_ACTIVE_ALERT_COOLDOWN_MS) return;\n  lastActiveAlertAt.set(token.provider, now);\n\n  const mention = mentionFor(token.name, getSlackUserMap());\n  void notifySlack({\n    title: \"마지막 토큰 사망\",\n    subject: token.name,\n    context:\n      [mention, token.provider, reasonCode].filter(Boolean).join(\" · \") +\n      ` · 풀이 비지 않도록 유지 중입니다. ` +\n      `전 토큰이 동시에 실패했다면 client_id 취소나 OAuth 계약 변경을 의심하세요`,\n    color: SLACK_COLOR.bad,\n  });\n}\n\n/** 로그인이 완료돼 토큰이 저장됐을 때. 신규·재로그인을 가리지 않는다. */\nexport function notifyTokenAdded(name: string, provider: string): void {\n  logger.info(`token added: ${name} (${provider})`);\n  const mention = mentionFor(name, getSlackUserMap());\n  void notifySlack({\n    title: \"토큰 추가\",\n    subject: name,\n    context: [mention, provider, \"요청 처리에 사용됩니다\"].filter(Boolean).join(\" · \"),\n    color: SLACK_COLOR.good,\n  });\n}\n"],"mappings":";;;;;;;;;;;;;AAcA,MAAM,SAAS,UAAU,CAAC,SAAS,aAAa,CAAC;;;;;;;;AAejD,eAAsB,wBACpB,OACA,kBACA,YACkB;CAClB,MAAM,UAAU,MAAM,WAAW,QAAQ,KAAK,EAAE,IAAI,MAAM,GAAG,CAAC;CAC9D,IAAI,CAAC,SAAS,OAAO;CAErB,MAAM,sBAAsB,gBAAgB,QAAQ,WAAW;CAC/D,IAAI,uBAAuB,wBAAwB,kBAAkB;EACnE,OAAO,KACL,2BAA2B,MAAM,KAAK,MAAM,MAAM,GAAG,4CACvD;EACA,OAAO;CACT;CAEA,MAAM,EAAE,aAAa,qBAAqB,MAAM,WAAW,mBAAmB,MAAM,EAAE;CACtF,IAAI,CAAC,aAAa;EAChB,IAAI,kBAAkB,2BAA2B,OAAO,UAAU;EAClE,OAAO;CACT;CAEA,OAAO,KAAK,kCAAkC,MAAM,KAAK,MAAM,MAAM,GAAG,WAAW,YAAY;CAG/F,MAAM,UAAU,WAAW,MAAM,MAAM,gBAAgB,CAAC;CACxD,AAAK,YAAY;EACf,OAAO;EACP,SAAS,MAAM;EACf,SAAS;GAAC;GAAS,MAAM;GAAU;GAAY;EAAa,CAAC,CAC1D,OAAO,OAAO,CAAC,CACf,KAAK,KAAK;EACb,OAAO,YAAY;CACrB,CAAC;CACD,OAAO;AACT;;;;;;;;AASA,MAAM,gCAAgC,OAAU;AAChD,MAAM,oCAAoB,IAAI,IAAoB;AAElD,SAAS,2BAA2B,OAAqB,YAA0B;CACjF,MAAM,MAAM,KAAK,IAAI;CACrB,MAAM,WAAW,kBAAkB,IAAI,MAAM,QAAQ;CACrD,IAAI,aAAa,UAAa,MAAM,WAAW,+BAA+B;CAC9E,kBAAkB,IAAI,MAAM,UAAU,GAAG;CAEzC,MAAM,UAAU,WAAW,MAAM,MAAM,gBAAgB,CAAC;CACxD,AAAK,YAAY;EACf,OAAO;EACP,SAAS,MAAM;EACf,SACE;GAAC;GAAS,MAAM;GAAU;EAAU,CAAC,CAAC,OAAO,OAAO,CAAC,CAAC,KAAK,KAAK,IAChE;EAEF,OAAO,YAAY;CACrB,CAAC;AACH;;AAGA,SAAgB,iBAAiB,MAAc,UAAwB;CACrE,OAAO,KAAK,gBAAgB,KAAK,IAAI,SAAS,EAAE;CAEhD,AAAK,YAAY;EACf,OAAO;EACP,SAAS;EACT,SAAS;GAJK,WAAW,MAAM,gBAAgB,CAIrC;GAAS;GAAU;EAAc,CAAC,CAAC,OAAO,OAAO,CAAC,CAAC,KAAK,KAAK;EACvE,OAAO,YAAY;CACrB,CAAC;AACH"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"token-death.js","names":[],"sources":["../../../src/application/qgrid/token-death.ts"],"sourcesContent":["/**\n * 세션 만료(auth-dead) 토큰의 라우팅 제외 지점.\n *\n * refresh 가 재로그인 외 복구 불가한 실패를 반환한 순간에만 호출된다. 비활성화는\n * `active=true` 조건부 갱신 1회이고, 그 갱신을 이긴 프로세스만 Slack 알림을 보낸다 —\n * 공유 DB 를 쓰는 인스턴스가 몇이든 사건당 알림은 1건이다.\n */\nimport { getLogger } from \"@logtape/logtape\";\n\nimport { getRefreshToken } from \"../../utils/providers/common/credentials\";\nimport { notifySlack, SLACK_COLOR } from \"../../utils/slack-notify\";\nimport { TokenModel } from \"../token/token.model\";\nimport { getSlackUserMap, mentionFor } from \"./slack-user-map\";\n\nconst logger = getLogger([\"qgrid\", \"token-death\"]);\n\ntype DeadTokenRef = {\n  id: number;\n  name: string;\n  provider: string;\n};\n\n/**\n * @param usedRefreshToken 실패한 요청이 실제로 사용한 refresh token.\n *   refresh token 은 회전 저장되므로, 이미 회전된 옛 토큰으로 늦게 도착한 재시도가\n *   400 을 받는 것은 정상 레이스다. DB 의 현재 값과 다르면 사망으로 보지 않는다.\n * @param reasonCode `provider:code` 형태의 내부 코드. provider 응답 본문에는 계정 이메일이나\n *   토큰 조각이 섞일 수 있어 raw 메시지를 그대로 알림에 싣지 않는다.\n */\nexport async function deactivateAuthDeadToken(\n  token: DeadTokenRef,\n  usedRefreshToken: string,\n  reasonCode: string,\n): Promise<boolean> {\n  const current = await TokenModel.findOne(\"A\", { id: token.id });\n  if (!current) return false;\n\n  const currentRefreshToken = getRefreshToken(current.credentials);\n  if (currentRefreshToken && currentRefreshToken !== usedRefreshToken) {\n    logger.info(\n      `skipping auth-death for ${token.name}(id=${token.id}): refresh token rotated since this attempt`,\n    );\n    return false;\n  }\n\n  const { deactivated, keptAsLastActive } = await TokenModel.deactivateIfActive(token.id);\n  if (!deactivated) {\n    if (keptAsLastActive) notifyLastActiveTokenDying(token, reasonCode);\n    return false;\n  }\n\n  logger.warn(`token deactivated (auth dead): ${token.name}(id=${token.id}) reason=${reasonCode}`);\n  // 만료 직후가 재로그인하기 가장 좋은 타이밍이다. 소유자를 멘션해 그 순간 당사자에게\n  // 꽂는다 — 다이제스트를 기다리면 다음 주기까지 토큰이 빠진 채로 남는다.\n  const mention = mentionFor(token.name, getSlackUserMap());\n  void notifySlack({\n    title: \"세션 만료\",\n    subject: token.name,\n    context: [mention, token.provider, reasonCode, \"재로그인이 필요합니다\"]\n      .filter(Boolean)\n      .join(\" · \"),\n    color: SLACK_COLOR.bad,\n  });\n  return true;\n}\n\n/**\n * 마지막 활성 토큰이 죽었을 때의 알림 쿨다운.\n *\n * 이 경우 토큰은 비활성화되지 않고 살아남으므로, 뒤따르는 요청마다 같은 실패를 반복해\n * 알림이 폭주한다. 비활성화 성공 경로가 조건부 UPDATE 로 중복을 막는 것과 달리 여기엔\n * 상태 변화가 없어 DB 로 억제할 수 없다 — provider 단위로 시간 창을 둔다.\n */\nconst LAST_ACTIVE_ALERT_COOLDOWN_MS = 30 * 60 * 1000;\nconst lastActiveAlertAt = new Map<string, number>();\n\nfunction notifyLastActiveTokenDying(token: DeadTokenRef, reasonCode: string): void {\n  const now = Date.now();\n  const previous = lastActiveAlertAt.get(token.provider);\n  if (previous !== undefined && now - previous < LAST_ACTIVE_ALERT_COOLDOWN_MS) return;\n  lastActiveAlertAt.set(token.provider, now);\n\n  const mention = mentionFor(token.name, getSlackUserMap());\n  void notifySlack({\n    title: \"마지막 토큰 사망\",\n    subject: token.name,\n    context:\n      [mention, token.provider, reasonCode].filter(Boolean).join(\" · \") +\n      ` · 풀이 비지 않도록 유지 중입니다. ` +\n      `전 토큰이 동시에 실패했다면 client_id 취소나 OAuth 계약 변경을 의심하세요`,\n    color: SLACK_COLOR.bad,\n    // provider 전체가 죽었다는 신호다. 조용 시간에 묻히면 다음 근무일까지 서비스가 멈춘다.\n    urgent: true,\n  });\n}\n\n/** 로그인이 완료돼 토큰이 저장됐을 때. 신규·재로그인을 가리지 않는다. */\nexport function notifyTokenAdded(name: string, provider: string): void {\n  logger.info(`token added: ${name} (${provider})`);\n  const mention = mentionFor(name, getSlackUserMap());\n  void notifySlack({\n    title: \"토큰 추가\",\n    subject: name,\n    context: [mention, provider, \"요청 처리에 사용됩니다\"].filter(Boolean).join(\" · \"),\n    color: SLACK_COLOR.good,\n  });\n}\n"],"mappings":";;;;;;;;;;;;;AAcA,MAAM,SAAS,UAAU,CAAC,SAAS,aAAa,CAAC;;;;;;;;AAejD,eAAsB,wBACpB,OACA,kBACA,YACkB;CAClB,MAAM,UAAU,MAAM,WAAW,QAAQ,KAAK,EAAE,IAAI,MAAM,GAAG,CAAC;CAC9D,IAAI,CAAC,SAAS,OAAO;CAErB,MAAM,sBAAsB,gBAAgB,QAAQ,WAAW;CAC/D,IAAI,uBAAuB,wBAAwB,kBAAkB;EACnE,OAAO,KACL,2BAA2B,MAAM,KAAK,MAAM,MAAM,GAAG,4CACvD;EACA,OAAO;CACT;CAEA,MAAM,EAAE,aAAa,qBAAqB,MAAM,WAAW,mBAAmB,MAAM,EAAE;CACtF,IAAI,CAAC,aAAa;EAChB,IAAI,kBAAkB,2BAA2B,OAAO,UAAU;EAClE,OAAO;CACT;CAEA,OAAO,KAAK,kCAAkC,MAAM,KAAK,MAAM,MAAM,GAAG,WAAW,YAAY;CAG/F,MAAM,UAAU,WAAW,MAAM,MAAM,gBAAgB,CAAC;CACxD,AAAK,YAAY;EACf,OAAO;EACP,SAAS,MAAM;EACf,SAAS;GAAC;GAAS,MAAM;GAAU;GAAY;EAAa,CAAC,CAC1D,OAAO,OAAO,CAAC,CACf,KAAK,KAAK;EACb,OAAO,YAAY;CACrB,CAAC;CACD,OAAO;AACT;;;;;;;;AASA,MAAM,gCAAgC,OAAU;AAChD,MAAM,oCAAoB,IAAI,IAAoB;AAElD,SAAS,2BAA2B,OAAqB,YAA0B;CACjF,MAAM,MAAM,KAAK,IAAI;CACrB,MAAM,WAAW,kBAAkB,IAAI,MAAM,QAAQ;CACrD,IAAI,aAAa,UAAa,MAAM,WAAW,+BAA+B;CAC9E,kBAAkB,IAAI,MAAM,UAAU,GAAG;CAEzC,MAAM,UAAU,WAAW,MAAM,MAAM,gBAAgB,CAAC;CACxD,AAAK,YAAY;EACf,OAAO;EACP,SAAS,MAAM;EACf,SACE;GAAC;GAAS,MAAM;GAAU;EAAU,CAAC,CAAC,OAAO,OAAO,CAAC,CAAC,KAAK,KAAK,IAChE;EAEF,OAAO,YAAY;EAEnB,QAAQ;CACV,CAAC;AACH;;AAGA,SAAgB,iBAAiB,MAAc,UAAwB;CACrE,OAAO,KAAK,gBAAgB,KAAK,IAAI,SAAS,EAAE;CAEhD,AAAK,YAAY;EACf,OAAO;EACP,SAAS;EACT,SAAS;GAJK,WAAW,MAAM,gBAAgB,CAIrC;GAAS;GAAU;EAAc,CAAC,CAAC,OAAO,OAAO,CAAC,CAAC,KAAK,KAAK;EACvE,OAAO,YAAY;CACrB,CAAC;AACH"}

package/bundle/dist/application/qgrid/tool-emulation.js

@@ -1,6 +1,6 @@
+import { getLogger } from "@logtape/logtape";
 import { Buffer } from "node:buffer";
 import { z } from "zod";
-import { getLogger } from "@logtape/logtape";
 //#region src/application/qgrid/tool-emulation.ts
 const STRUCTURED_ENVELOPE_LIMITS = {
 	maxUtf8Bytes: 512 * 1024,

package/bundle/dist/application/queries.generated.js

@@ -13,6 +13,12 @@ let TokenService;
 	_TokenService.getToken = (subset, id) => createSSRQuery("TokenModel", "findById", [subset, id], ["Token", "getToken"]);
 	_TokenService.getTokens = (subset, rawParams) => createSSRQuery("TokenModel", "findMany", [subset, rawParams], ["Token", "getTokens"]);
 })(TokenService || (TokenService = {}));
+let SettingService;
+(function(_SettingService) {
+	_SettingService.getSetting = (subset, id) => createSSRQuery("SettingModel", "findById", [subset, id], ["Setting", "getSetting"]);
+	_SettingService.getSettings = (subset, rawParams) => createSSRQuery("SettingModel", "findMany", [subset, rawParams], ["Setting", "getSettings"]);
+	_SettingService.getSettingList = () => createSSRQuery("SettingModel", "listSettings", [], ["Setting", "getSettingList"]);
+})(SettingService || (SettingService = {}));
 let RequestLogStepService;
 (function(_RequestLogStepService) {
 	_RequestLogStepService.getRequestLogStep = (subset, id) => createSSRQuery("RequestLogStepModel", "findById", [subset, id], ["RequestLogStep", "getRequestLogStep"]);
@@ -38,6 +44,6 @@ let MonitService;
 	_MonitService.monitInfo = () => createSSRQuery("MonitFrame", "monitInfo", [], ["Monit", "monitInfo"]);
 })(MonitService || (MonitService = {}));
 //#endregion
-export { MonitService, QgridService, RequestLogService, RequestLogStepService, TokenService };
+export { MonitService, QgridService, RequestLogService, RequestLogStepService, SettingService, TokenService };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"queries.generated.js","names":[],"sources":["../../src/application/queries.generated.ts"],"sourcesContent":["/**\n * @generated\n * 직접 수정하지 마세요.\n */\n\n/* oxlint-disable */\n\nimport type { SSRQuery } from \"sonamu/ssr\";\n\n// SSRQuery 헬퍼 함수\nfunction createSSRQuery(\n  modelName: string,\n  methodName: string,\n  params: any[],\n  serviceKey: [string, string],\n): SSRQuery {\n  return { modelName, methodName, params, serviceKey, __brand: \"SSRQuery\" } as SSRQuery;\n}\n\nimport { RequestLogStepListParams } from \"./request-log-step/request-log-step.types\";\nimport { RequestLogListParams } from \"./request-log/request-log.types\";\nimport { SettingListParams } from \"./setting/setting.types\";\nimport {\n  TokenSubsetKey,\n  SettingSubsetKey,\n  RequestLogStepSubsetKey,\n  RequestLogSubsetKey,\n} from \"./sonamu.generated\";\nimport { TokenListParams } from \"./token/token.types\";\n\nexport namespace TokenService {\n  export const getToken = <T extends TokenSubsetKey>(subset: T, id: number): SSRQuery =>\n    createSSRQuery(\"TokenModel\", \"findById\", [subset, id], [\"Token\", \"getToken\"]);\n\n  export const getTokens = <T extends TokenSubsetKey, LP extends TokenListParams>(\n    subset: T,\n    rawParams?: LP,\n  ): SSRQuery =>\n    createSSRQuery(\"TokenModel\", \"findMany\", [subset, rawParams], [\"Token\", \"getTokens\"]);\n}\n\nexport namespace SettingService {\n  export const getSetting = <T extends SettingSubsetKey>(subset: T, id: number): SSRQuery =>\n    createSSRQuery(\"SettingModel\", \"findById\", [subset, id], [\"Setting\", \"getSetting\"]);\n\n  export const getSettings = <T extends SettingSubsetKey, LP extends SettingListParams>(\n    subset: T,\n    rawParams?: LP,\n  ): SSRQuery =>\n    createSSRQuery(\"SettingModel\", \"findMany\", [subset, rawParams], [\"Setting\", \"getSettings\"]);\n\n  export const getSettingList = (): SSRQuery =>\n    createSSRQuery(\"SettingModel\", \"listSettings\", [], [\"Setting\", \"getSettingList\"]);\n}\n\nexport namespace RequestLogStepService {\n  export const getRequestLogStep = <T extends RequestLogStepSubsetKey>(\n    subset: T,\n    id: number,\n  ): SSRQuery =>\n    createSSRQuery(\n      \"RequestLogStepModel\",\n      \"findById\",\n      [subset, id],\n      [\"RequestLogStep\", \"getRequestLogStep\"],\n    );\n\n  export const getRequestLogSteps = <\n    T extends RequestLogStepSubsetKey,\n    LP extends RequestLogStepListParams,\n  >(\n    subset: T,\n    rawParams?: LP,\n  ): SSRQuery =>\n    createSSRQuery(\n      \"RequestLogStepModel\",\n      \"findMany\",\n      [subset, rawParams],\n      [\"RequestLogStep\", \"getRequestLogSteps\"],\n    );\n}\n\nexport namespace RequestLogService {\n  export const getRequestLog = <T extends RequestLogSubsetKey>(subset: T, id: number): SSRQuery =>\n    createSSRQuery(\"RequestLogModel\", \"findById\", [subset, id], [\"RequestLog\", \"getRequestLog\"]);\n\n  export const getRequestLogs = <T extends RequestLogSubsetKey, LP extends RequestLogListParams>(\n    subset: T,\n    rawParams?: LP,\n  ): SSRQuery =>\n    createSSRQuery(\n      \"RequestLogModel\",\n      \"findMany\",\n      [subset, rawParams],\n      [\"RequestLog\", \"getRequestLogs\"],\n    );\n}\n\nexport namespace QgridService {\n  export const stats = (): SSRQuery =>\n    createSSRQuery(\"QgridFrame\", \"stats\", [], [\"Qgrid\", \"stats\"]);\n\n  export const totalCost = (params?: RequestLogListParams): SSRQuery =>\n    createSSRQuery(\"QgridFrame\", \"totalCost\", [params], [\"Qgrid\", \"totalCost\"]);\n\n  export const projectNames = (): SSRQuery =>\n    createSSRQuery(\"QgridFrame\", \"projectNames\", [], [\"Qgrid\", \"projectNames\"]);\n\n  export const modelNames = (): SSRQuery =>\n    createSSRQuery(\"QgridFrame\", \"modelNames\", [], [\"Qgrid\", \"modelNames\"]);\n\n  export const usage = (tokenId?: number): SSRQuery =>\n    createSSRQuery(\"QgridFrame\", \"usage\", [tokenId], [\"Qgrid\", \"usage\"]);\n\n  export const health = (): SSRQuery =>\n    createSSRQuery(\"QgridFrame\", \"health\", [], [\"Qgrid\", \"health\"]);\n}\n\nexport namespace MonitService {\n  export const monitLogs = (cursor?: number): SSRQuery =>\n    createSSRQuery(\"MonitFrame\", \"monitLogs\", [cursor], [\"Monit\", \"monitLogs\"]);\n\n  export const monitInfo = (): SSRQuery =>\n    createSSRQuery(\"MonitFrame\", \"monitInfo\", [], [\"Monit\", \"monitInfo\"]);\n}\n"],"mappings":";AAUA,SAAS,eACP,WACA,YACA,QACA,YACU;CACV,OAAO;EAAE;EAAW;EAAY;EAAQ;EAAY,SAAS;CAAW;AAC1E;AAaO,IAAU;CAAV,SAAA,eAAA;CACQ,cAAA,YAAsC,QAAW,OAC5D,eAAe,cAAc,YAAY,CAAC,QAAQ,EAAE,GAAG,CAAC,SAAS,UAAU,CAAC;CAEjE,cAAA,aACX,QACA,cAEA,eAAe,cAAc,YAAY,CAAC,QAAQ,SAAS,GAAG,CAAC,SAAS,WAAW,CAAC;AACvF,EAAA,CAAA,iBAAA,eAAA,CAAA,EAAD;AAEO,IAAU;CAAV,SAAA,iBAAA;CACQ,gBAAA,cAA0C,QAAW,OAChE,eAAe,gBAAgB,YAAY,CAAC,QAAQ,EAAE,GAAG,CAAC,WAAW,YAAY,CAAC;CAEvE,gBAAA,eACX,QACA,cAEA,eAAe,gBAAgB,YAAY,CAAC,QAAQ,SAAS,GAAG,CAAC,WAAW,aAAa,CAAC;CAE/E,gBAAA,uBACX,eAAe,gBAAgB,gBAAgB,CAAC,GAAG,CAAC,WAAW,gBAAgB,CAAC;AACnF,EAAA,CAAA,mBAAA,iBAAA,CAAA,EAAD;AAEO,IAAU;CAAV,SAAA,wBAAA;CACQ,uBAAA,qBACX,QACA,OAEA,eACE,uBACA,YACA,CAAC,QAAQ,EAAE,GACX,CAAC,kBAAkB,mBAAmB,CACxC;CAEW,uBAAA,sBAIX,QACA,cAEA,eACE,uBACA,YACA,CAAC,QAAQ,SAAS,GAClB,CAAC,kBAAkB,oBAAoB,CACzC;AACH,EAAA,CAAA,0BAAA,wBAAA,CAAA,EAAD;AAEO,IAAU;CAAV,SAAA,oBAAA;CACQ,mBAAA,iBAAgD,QAAW,OACtE,eAAe,mBAAmB,YAAY,CAAC,QAAQ,EAAE,GAAG,CAAC,cAAc,eAAe,CAAC;CAEhF,mBAAA,kBACX,QACA,cAEA,eACE,mBACA,YACA,CAAC,QAAQ,SAAS,GAClB,CAAC,cAAc,gBAAgB,CACjC;AACH,EAAA,CAAA,sBAAA,oBAAA,CAAA,EAAD;AAEO,IAAU;CAAV,SAAA,eAAA;CACQ,cAAA,cACX,eAAe,cAAc,SAAS,CAAC,GAAG,CAAC,SAAS,OAAO,CAAC;CAEjD,cAAA,aAAa,WACxB,eAAe,cAAc,aAAa,CAAC,MAAM,GAAG,CAAC,SAAS,WAAW,CAAC;CAE/D,cAAA,qBACX,eAAe,cAAc,gBAAgB,CAAC,GAAG,CAAC,SAAS,cAAc,CAAC;CAE/D,cAAA,mBACX,eAAe,cAAc,cAAc,CAAC,GAAG,CAAC,SAAS,YAAY,CAAC;CAE3D,cAAA,SAAS,YACpB,eAAe,cAAc,SAAS,CAAC,OAAO,GAAG,CAAC,SAAS,OAAO,CAAC;CAExD,cAAA,eACX,eAAe,cAAc,UAAU,CAAC,GAAG,CAAC,SAAS,QAAQ,CAAC;AACjE,EAAA,CAAA,iBAAA,eAAA,CAAA,EAAD;AAEO,IAAU;CAAV,SAAA,eAAA;CACQ,cAAA,aAAa,WACxB,eAAe,cAAc,aAAa,CAAC,MAAM,GAAG,CAAC,SAAS,WAAW,CAAC;CAE/D,cAAA,kBACX,eAAe,cAAc,aAAa,CAAC,GAAG,CAAC,SAAS,WAAW,CAAC;AACvE,EAAA,CAAA,iBAAA,eAAA,CAAA,EAAD"}

package/bundle/dist/application/request-log/request-log.model.js

@@ -1,8 +1,8 @@
 import { SD } from "../../i18n/sd.generated.js";
-import { calculateCostUsd } from "../../utils/providers/common/model-cost.js";
+import { requestLogLoaderQueries, requestLogSubsetQueries } from "../sonamu.generated.sso.js";
 import __decorateMetadata from "../../_virtual/_@oxc-project_runtime@0.140.0/helpers/esm/decorateMetadata.js";
 import __decorate from "../../_virtual/_@oxc-project_runtime@0.140.0/helpers/esm/decorate.js";
-import { requestLogLoaderQueries, requestLogSubsetQueries } from "../sonamu.generated.sso.js";
+import { calculateCostUsd } from "../../utils/providers/common/model-cost.js";
 import { BadRequestException, BaseModelClass, NotFoundException, Puri, api, asArray, transactional } from "sonamu";
 //#region src/application/request-log/request-log.model.ts
 const MICRO_USD = 1e6;

package/bundle/dist/application/request-log-step/request-log-step.model.js

@@ -1,7 +1,7 @@
 import { SD } from "../../i18n/sd.generated.js";
+import { requestLogStepLoaderQueries, requestLogStepSubsetQueries } from "../sonamu.generated.sso.js";
 import __decorateMetadata from "../../_virtual/_@oxc-project_runtime@0.140.0/helpers/esm/decorateMetadata.js";
 import __decorate from "../../_virtual/_@oxc-project_runtime@0.140.0/helpers/esm/decorate.js";
-import { requestLogStepLoaderQueries, requestLogStepSubsetQueries } from "../sonamu.generated.sso.js";
 import { BadRequestException, BaseModelClass, NotFoundException, api, asArray, exhaustive } from "sonamu";
 //#region src/application/request-log-step/request-log-step.model.ts
 var RequestLogStepModelClass = class extends BaseModelClass {

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"}