@cartanova/qgrid-cli 2.6.6 → 2.6.8

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,38 +18,58 @@ 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)에 토큰명이 이미 있으므로 본문에서는 뺀다 — 같은 이름을 두 번 쓰면
+* 읽는 사람이 다른 정보인 줄 알고 한 번 더 본다. 여러 건이면 제목이 건수라 본문에 남긴다.
+*/
 function buildReminderContext(tokens, userMap) {
-	return tokens.map((token) => {
+	const showLabel = tokens.length > 1;
+	return [...tokens.map((token) => {
 		const mention = mentionFor(token.name, userMap);
 		const label = token.name ?? "unnamed";
+		if (!showLabel) return mention;
 		return mention ? `${mention} ${label}` : label;
-	}).join("\n");
+	}), "재로그인이 필요합니다"].filter(Boolean).join("\n");
 }
-async function sendReminder(userMap) {
-	const inactive = await TokenModel.findInactive("A");
+async function sendReminder(deps) {
+	const inactive = await deps.findInactive();
 	if (inactive.length === 0) return;
-	await notifySlack({
+	const userMap = deps.getSlackUserMap();
+	await deps.sendSlack({
 		title: "세션 만료",
 		subject: inactive.length > 1 ? `${inactive.length}건` : inactive[0].name ?? "unnamed",
-		context: `${buildReminderContext(inactive, userMap)}\n재로그인이 필요합니다`,
+		context: buildReminderContext(inactive, userMap),
 		color: SLACK_COLOR.bad
 	});
 }
 let timer = null;
+function scheduleExpiredTokenReminder(runNow, deps) {
+	stopExpiredTokenReminder();
+	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)`);
-	timer = setInterval(() => {
-		sendReminder(userMap).catch((e) => logger.warn(`reminder failed: ${e.message}`));
-	}, minutes * MINUTE_MS);
+function startExpiredTokenReminder(deps = defaultDeps) {
+	scheduleExpiredTokenReminder(true, deps);
+}
+/** 설정 변경 시 기존 타이머만 새 주기로 교체한다. 저장 자체가 알림을 보내지는 않는다. */
+function rescheduleExpiredTokenReminder(deps = defaultDeps) {
+	scheduleExpiredTokenReminder(false, deps);
 }
 function stopExpiredTokenReminder() {
 	if (!timer) return;
@@ -56,6 +77,6 @@ function stopExpiredTokenReminder() {
 	timer = null;
 }
 //#endregion
-export { buildReminderContext, startExpiredTokenReminder, stopExpiredTokenReminder };
+export { buildReminderContext, rescheduleExpiredTokenReminder, 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): 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"}

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,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
+//# 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.model.js

@@ -0,0 +1,236 @@
+import { SETTING_DEFS, findSettingDef, maskSecret, validateSettingValue } from "./setting.schema.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";
+import __decorate from "../../_virtual/_@oxc-project_runtime@0.140.0/helpers/esm/decorate.js";
+import { getSetting, isStored, resetSetting, saveSetting } from "./setting.store.js";
+import { BadRequestException, BaseModelClass, NotFoundException, api, asArray, exhaustive } from "sonamu";
+//#region src/application/setting/setting.model.ts
+var SettingModelClass = class extends BaseModelClass {
+	constructor() {
+		super("Setting", settingSubsetQueries, settingLoaderQueries);
+	}
+	async findById(subset, id) {
+		const { rows } = await this.findMany(subset, {
+			id,
+			num: 1,
+			page: 1
+		});
+		if (!rows[0]) throw new NotFoundException(SD("error.entityNotFound")("Setting", id));
+		return rows[0];
+	}
+	async findOne(subset, listParams) {
+		const { rows } = await this.findMany(subset, {
+			...listParams,
+			num: 1,
+			page: 1
+		});
+		return rows[0] ?? null;
+	}
+	async findMany(subset, rawParams) {
+		const params = {
+			num: 24,
+			page: 1,
+			search: "key",
+			orderBy: "key-asc",
+			...rawParams
+		};
+		const { qb, onSubset: _ } = this.getSubsetQueries(subset);
+		if (params.id) qb.whereIn("settings.id", asArray(params.id));
+		if (params.key) qb.where("settings.key", params.key);
+		if (params.search && params.keyword && params.keyword.length > 0) if (params.search === "key") qb.where("settings.key", "like", `%${params.keyword}%`);
+		else throw new BadRequestException(SD("error.unknownSearchField")(params.search));
+		if (params.orderBy) if (params.orderBy === "key-asc") qb.orderBy("settings.key", "asc");
+		else exhaustive(params.orderBy);
+		const enhancers = this.createEnhancers({ A: (row) => ({ ...row }) });
+		return this.executeSubsetQuery({
+			subset,
+			qb,
+			params,
+			enhancers,
+			debug: false
+		});
+	}
+	async save(spa) {
+		const wdb = this.getPuri("w");
+		spa.forEach((sp) => {
+			wdb.ubRegister("settings", sp);
+		});
+		return wdb.transaction(async (trx) => {
+			return await trx.ubUpsert("settings");
+		});
+	}
+	async del(ids) {
+		await this.getPuri("w").transaction(async (trx) => {
+			return trx.table("settings").whereIn("settings.id", ids).delete();
+		});
+		return ids.length;
+	}
+	/** 저장된 설정 전체를 key→value 로. 부팅 시 한 번 읽어 메모리에 올린다. */
+	async findAllAsMap() {
+		const { rows } = await this.findMany("A", {
+			num: 0,
+			page: 1
+		});
+		return new Map(rows.map((r) => [r.key, r.value]));
+	}
+	/**
+	* key 로 upsert 한다. `save` 는 id 기준이라 key 중복을 걸러내지 못해, 기존 행을 먼저 찾아
+	* id 를 실어 보낸다.
+	*/
+	async setByKey(key, value) {
+		const existing = await this.findOne("A", {
+			key,
+			num: 1,
+			page: 1
+		});
+		await this.save([{
+			...existing ? { id: existing.id } : {},
+			key,
+			value,
+			updated_at: /* @__PURE__ */ new Date()
+		}]);
+	}
+	/** 저장값을 지워 env 기본값으로 되돌린다. */
+	async clearByKey(key) {
+		const existing = await this.findOne("A", {
+			key,
+			num: 1,
+			page: 1
+		});
+		if (existing) await this.del([existing.id]);
+	}
+	/**
+	* 편집 가능한 설정과 읽기 전용 런타임 정보. 편집 대상은 `SETTING_DEFS` 에 정의된 것뿐이다 —
+	* DB 접속 정보나 포트는 서버가 뜨기 전에 필요해 화면에서 바꿀 수 없다.
+	*/
+	async listSettings() {
+		return {
+			settings: SETTING_DEFS.map((def) => {
+				const stored = isStored(def.key);
+				const raw = getSetting(def.key, def.envKey);
+				const effective = raw ?? def.fallback;
+				const source = stored ? "db" : raw !== void 0 ? "env" : "default";
+				return {
+					key: def.key,
+					group: def.group,
+					label: def.label,
+					kind: def.kind,
+					applies: def.applies,
+					value: effective,
+					source,
+					min: def.min ?? null,
+					max: def.max ?? null,
+					help: def.help ?? null
+				};
+			}),
+			runtime: this.runtimeInfo()
+		};
+	}
+	runtimeInfo() {
+		const env = process.env;
+		const password = env.QGRID_DB_PASSWORD ?? env.SONAMU_DB_PASSWORD ?? "";
+		return [
+			{
+				label: "NODE_ENV",
+				value: env.NODE_ENV ?? "-"
+			},
+			{
+				label: "HOST",
+				value: env.HOST ?? "localhost"
+			},
+			{
+				label: "PORT",
+				value: env.PORT ?? "44900"
+			},
+			{
+				label: "DB Host",
+				value: env.QGRID_DB_HOST ?? env.SONAMU_DB_HOST ?? "-"
+			},
+			{
+				label: "DB Port",
+				value: env.QGRID_DB_PORT ?? env.SONAMU_DB_PORT ?? "-"
+			},
+			{
+				label: "DB Name",
+				value: env.QGRID_DB_NAME ?? env.SONAMU_DB_NAME ?? "-"
+			},
+			{
+				label: "DB User",
+				value: env.QGRID_DB_USER ?? env.SONAMU_DB_USER ?? "-"
+			},
+			{
+				label: "DB Password",
+				value: password ? maskSecret(password) : "-"
+			}
+		];
+	}
+	async updateSetting(key, value) {
+		const def = findSettingDef(key);
+		if (!def) throw new BadRequestException(SD("setting.unknownKey")(key));
+		const validation = validateSettingValue(def, value);
+		if (!validation.ok) throw new BadRequestException(SD("setting.invalidValue")(validation.error));
+		await saveSetting(key, validation.value);
+		return { applies: def.applies };
+	}
+	/** 저장값을 지워 env 기본값으로 되돌린다. */
+	async resetSetting(key) {
+		const def = findSettingDef(key);
+		if (!def) throw new BadRequestException(SD("setting.unknownKey")(key));
+		await resetSetting(key);
+		return { applies: def.applies };
+	}
+};
+__decorate([
+	api({
+		httpMethod: "GET",
+		clients: ["axios", "tanstack-query"],
+		resourceName: "Setting"
+	}),
+	__decorateMetadata("design:type", Function),
+	__decorateMetadata("design:paramtypes", [Object, Number]),
+	__decorateMetadata("design:returntype", Promise)
+], SettingModelClass.prototype, "findById", null);
+__decorate([
+	api({
+		httpMethod: "GET",
+		clients: ["axios", "tanstack-query"],
+		resourceName: "Settings"
+	}),
+	__decorateMetadata("design:type", Function),
+	__decorateMetadata("design:paramtypes", [Object, Object]),
+	__decorateMetadata("design:returntype", Promise)
+], SettingModelClass.prototype, "findMany", null);
+__decorate([
+	api({
+		httpMethod: "GET",
+		clients: ["axios", "tanstack-query"],
+		resourceName: "SettingList"
+	}),
+	__decorateMetadata("design:type", Function),
+	__decorateMetadata("design:paramtypes", []),
+	__decorateMetadata("design:returntype", Promise)
+], SettingModelClass.prototype, "listSettings", null);
+__decorate([
+	api({
+		httpMethod: "POST",
+		clients: ["axios", "tanstack-mutation"]
+	}),
+	__decorateMetadata("design:type", Function),
+	__decorateMetadata("design:paramtypes", [String, String]),
+	__decorateMetadata("design:returntype", Promise)
+], SettingModelClass.prototype, "updateSetting", null);
+__decorate([
+	api({
+		httpMethod: "POST",
+		clients: ["axios", "tanstack-mutation"]
+	}),
+	__decorateMetadata("design:type", Function),
+	__decorateMetadata("design:paramtypes", [String]),
+	__decorateMetadata("design:returntype", Promise)
+], SettingModelClass.prototype, "resetSetting", 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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"}