@cartanova/qgrid-cli 2.10.10 → 2.11.1

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

@@ -1,9 +1,11 @@
 /** tokens_changed LISTEN subscriber. */
 import { getLogger } from "@logtape/logtape";
 import { Client, type ClientConfig } from "pg";
+import { z } from "zod";
 
+import { type TokenSubsetA } from "../sonamu.generated";
 import { TokenModel } from "../token/token.model";
-import { type AnthropicCredentials, type OpenAICredentials } from "../token/token.types";
+import { AnthropicCredentials, OpenAICredentials } from "../token/token.types";
 import { type QgridDispatcherClass } from "./qgrid.dispatcher";
 import { type SubscriberStatus } from "./qgrid.types";
 
@@ -15,7 +17,25 @@ const CONNECTION_TIMEOUT_MS = 5_000;
 const BACKOFF_BASE_MS = 500;
 const BACKOFF_CAP_MS = 30_000;
 
-type Payload = { op: "INSERT" | "UPDATE" | "DELETE"; id: number };
+const NotifyPayload = z.object({ op: z.enum(["INSERT", "UPDATE", "DELETE"]), id: z.number() });
+
+type CredentialRow = Pick<TokenSubsetA, "name" | "credentials">;
+
+function openAICredentialsOf(row: CredentialRow): OpenAICredentials | undefined {
+  const parsed = OpenAICredentials.safeParse(row.credentials);
+
+  if (!parsed.success) logger.warn(`skipping token ${row.name}: credentials are not OpenAI`);
+
+  return parsed.data;
+}
+
+function anthropicCredentialsOf(row: CredentialRow): AnthropicCredentials | undefined {
+  const parsed = AnthropicCredentials.safeParse(row.credentials);
+
+  if (!parsed.success) logger.warn(`skipping token ${row.name}: credentials are not Anthropic`);
+
+  return parsed.data;
+}
 
 export class TokenSubscriber {
   client: Client | null = null;
@@ -37,7 +57,9 @@ export class TokenSubscriber {
     try {
       this.tokenChangeHandler?.();
     } catch (error) {
-      logger.warn(`token change handler failed: ${(error as Error).message}`);
+      logger.warn(
+        `token change handler failed: ${error instanceof Error ? error.message : String(error)}`,
+      );
     }
   }
 
@@ -47,24 +69,31 @@ export class TokenSubscriber {
 
     try {
       await this.connectAndReconcile();
+
       return true;
     } catch (e) {
-      logger.warn(`subscriber start failed: ${(e as Error).message}, scheduling retry`);
+      logger.warn(
+        `subscriber start failed: ${e instanceof Error ? e.message : String(e)}, scheduling retry`,
+      );
       this.retryLater();
+
       return false;
     }
   }
 
   async stop(): Promise<void> {
     this.shutdownRequested = true;
+
     if (this.reconcileTimer) {
       clearInterval(this.reconcileTimer);
       this.reconcileTimer = null;
     }
+
     if (this.reconnectTimer) {
       clearTimeout(this.reconnectTimer);
       this.reconnectTimer = null;
     }
+
     await this.closeClient();
   }
 
@@ -83,7 +112,7 @@ export class TokenSubscriber {
     // LISTEN/NOTIFY 는 끊긴 동안 유실될 수 있어 주기적으로 DB 기준으로 맞춘다.
     this.reconcileTimer = setInterval(() => {
       this.reconcile().catch((e) =>
-        logger.warn(`periodic reconcile failed: ${(e as Error).message}`),
+        logger.warn(`periodic reconcile failed: ${e instanceof Error ? e.message : String(e)}`),
       );
     }, RECONCILE_INTERVAL_MS);
   }
@@ -113,7 +142,7 @@ export class TokenSubscriber {
     client.on("notification", (msg) => {
       if (msg.channel !== TOKENS_CHANGED || !msg.payload) return;
       this.handleNotification(msg.payload).catch((e) =>
-        logger.warn(`handle NOTIFY failed: ${(e as Error).message}`),
+        logger.warn(`handle NOTIFY failed: ${e instanceof Error ? e.message : String(e)}`),
       );
     });
 
@@ -135,6 +164,7 @@ export class TokenSubscriber {
 
   retryLater(): void {
     if (this.shutdownRequested) return;
+
     if (this.reconnectTimer) return;
 
     void this.closeClient();
@@ -145,7 +175,7 @@ export class TokenSubscriber {
     this.reconnectTimer = setTimeout(() => {
       this.reconnectTimer = null;
       this.connectAndReconcile().catch((e) => {
-        logger.warn(`subscriber reconnect failed: ${(e as Error).message}`);
+        logger.warn(`subscriber reconnect failed: ${e instanceof Error ? e.message : String(e)}`);
         this.retryLater();
       });
     }, delay);
@@ -153,6 +183,7 @@ export class TokenSubscriber {
 
   async closeClient(): Promise<void> {
     const client = this.client;
+
     if (!client) return;
 
     this.client = null;
@@ -165,68 +196,83 @@ export class TokenSubscriber {
   }
 
   async handleNotificationNow(payloadJson: string): Promise<void> {
-    const payload = JSON.parse(payloadJson) as Payload;
+    const payload = NotifyPayload.parse(JSON.parse(payloadJson));
+
     const previousRow = this.tokenChangeHandler
       ? this.dispatcher.tokens.get(payload.id)
       : undefined;
+
     const wasKeepaliveTarget = previousRow?.active === true && previousRow.provider === "anthropic";
+
     if (payload.op === "DELETE") {
       this.dispatcher.tokens.delete(payload.id);
       await this.dispatcher.openaiDispatcher
         ?.onTokenRemoved(payload.id)
-        .catch((e) => logger.warn(`openai token remove failed: ${(e as Error).message}`));
-      // 삭제된 토큰의 provider를 모를 수 있으므로 양쪽 풀에서 제거한다.
+        .catch((e) =>
+          logger.warn(`openai token remove failed: ${e instanceof Error ? e.message : String(e)}`),
+        );
+      // 삭제된 토큰의 provider를 모를 수 있으므로 모든 풀에서 제거한다.
       this.dispatcher.anthropicDispatcher?.onTokenRemoved(payload.id);
+      await this.removeGrokToken(payload.id);
       logger.info(`NOTIFY ${payload.op} id=${payload.id} → removed from cache`);
+
       if (previousRow === undefined || wasKeepaliveTarget) this.notifyTokensChanged();
+
       return;
     }
+
     const row = await TokenModel.findOne("A", { id: payload.id });
+
     if (!row) {
       this.dispatcher.tokens.delete(payload.id);
       await this.dispatcher.openaiDispatcher
         ?.onTokenRemoved(payload.id)
-        .catch((e) => logger.warn(`openai token remove failed: ${(e as Error).message}`));
+        .catch((e) =>
+          logger.warn(`openai token remove failed: ${e instanceof Error ? e.message : String(e)}`),
+        );
       this.dispatcher.anthropicDispatcher?.onTokenRemoved(payload.id);
+      await this.removeGrokToken(payload.id);
       logger.info(`NOTIFY ${payload.op} id=${payload.id} → missing, removed from cache`);
+
       if (previousRow === undefined || wasKeepaliveTarget) this.notifyTokensChanged();
+
       return;
     }
 
     this.dispatcher.tokens.set(payload.id, row);
 
     if (row.provider === "openai") {
-      const creds = row.credentials as Record<string, unknown>;
+      const creds = openAICredentialsOf(row);
       const openaiDispatcher = this.dispatcher.openaiDispatcher;
-      if (payload.op === "INSERT" && row.active) {
+
+      if (creds === undefined) {
+        openaiDispatcher?.onTokenDeactivated(payload.id);
+      } else if (payload.op === "INSERT" && row.active) {
         await openaiDispatcher
-          ?.onTokenAdded(
-            payload.id,
-            row.name,
-            creds as OpenAICredentials,
-            row.quota_threshold,
-            row.weight,
-          )
-          .catch((e) => logger.warn(`openai token add failed: ${(e as Error).message}`));
+          ?.onTokenAdded(payload.id, row.name, creds, row.quota_threshold, row.weight)
+          .catch((e) =>
+            logger.warn(`openai token add failed: ${e instanceof Error ? e.message : String(e)}`),
+          );
       } else if (row.active) {
         if (openaiDispatcher) {
           await openaiDispatcher
-            .onTokenUpdated(
-              payload.id,
-              row.name,
-              creds as OpenAICredentials,
-              row.quota_threshold,
-              row.weight,
-            )
+            .onTokenUpdated(payload.id, row.name, creds, row.quota_threshold, row.weight)
             .then(() => openaiDispatcher.onTokenActivated(payload.id))
-            .catch((e) => logger.warn(`openai token update failed: ${(e as Error).message}`));
+            .catch((e) =>
+              logger.warn(
+                `openai token update failed: ${e instanceof Error ? e.message : String(e)}`,
+              ),
+            );
         }
       } else {
         openaiDispatcher?.onTokenDeactivated(payload.id);
       }
     } else if (row.provider === "anthropic") {
-      const creds = row.credentials as AnthropicCredentials;
-      if (payload.op === "INSERT" && row.active) {
+      const creds = anthropicCredentialsOf(row);
+
+      if (creds === undefined) {
+        this.dispatcher.anthropicDispatcher?.onTokenRemoved(payload.id);
+      } else if (payload.op === "INSERT" && row.active) {
         this.dispatcher.anthropicDispatcher?.onTokenAdded(
           payload.id,
           row.name,
@@ -245,9 +291,43 @@ export class TokenSubscriber {
       } else {
         this.dispatcher.anthropicDispatcher?.onTokenRemoved(payload.id);
       }
+    } else if (row.provider === "grok") {
+      const grokDispatcher = this.dispatcher.grokDispatcher;
+
+      if (grokDispatcher) {
+        await Promise.resolve()
+          .then(() => {
+            if (payload.op === "INSERT" && row.active) {
+              return grokDispatcher.onTokenAdded(
+                payload.id,
+                row.name,
+                row.credentials,
+                row.quota_threshold,
+                row.weight,
+              );
+            }
+
+            if (row.active) {
+              return grokDispatcher.onTokenUpdated(
+                payload.id,
+                row.name,
+                row.credentials,
+                row.quota_threshold,
+                row.weight,
+              );
+            }
+
+            return grokDispatcher.onTokenRemoved(payload.id);
+          })
+          .catch((e) =>
+            logger.warn(`grok token sync failed: ${e instanceof Error ? e.message : String(e)}`),
+          );
+      }
     }
+
     logger.info(`NOTIFY ${payload.op} id=${payload.id} (${row.name}) active=${row.active}`);
     const isKeepaliveTarget = row.active && row.provider === "anthropic";
+
     if (wasKeepaliveTarget !== isKeepaliveTarget) this.notifyTokensChanged();
   }
 
@@ -258,37 +338,77 @@ export class TokenSubscriber {
   async reconcileNow(): Promise<void> {
     const previousAnthropicIds = this.tokenChangeHandler
       ? new Set(
-          [...this.dispatcher.tokens.values()]
-            .filter((row) => row.active && row.provider === "anthropic")
-            .map((row) => row.id),
+          [...this.dispatcher.tokens.values()].flatMap((row) =>
+            row.active && row.provider === "anthropic" ? [row.id] : [],
+          ),
         )
       : null;
+
     await TokenModel.deactivateExpiredTokens();
     const rows = await TokenModel.findActive("A");
     this.dispatcher.replaceCache(rows);
-    const anthropicRows = rows
-      .filter((r) => r.provider === "anthropic")
-      .map((r) => ({
-        id: r.id,
-        name: r.name,
-        credentials: r.credentials as AnthropicCredentials,
-        quotaThreshold: r.quota_threshold,
-        weight: r.weight,
-      }));
+
+    const anthropicRows = rows.flatMap((r) => {
+      const credentials = r.provider === "anthropic" ? anthropicCredentialsOf(r) : undefined;
+
+      return credentials === undefined
+        ? []
+        : [
+            {
+              id: r.id,
+              name: r.name,
+              credentials,
+              quotaThreshold: r.quota_threshold,
+              weight: r.weight,
+            },
+          ];
+    });
+
     this.dispatcher.anthropicDispatcher?.replaceTokens(anthropicRows);
-    const openaiRows = rows
-      .filter((r) => r.provider === "openai")
-      .map((r) => ({
-        id: r.id,
-        name: r.name,
-        credentials: r.credentials as OpenAICredentials,
-        quotaThreshold: r.quota_threshold,
-        weight: r.weight,
-      }));
+
+    const openaiRows = rows.flatMap((r) => {
+      const credentials = r.provider === "openai" ? openAICredentialsOf(r) : undefined;
+
+      return credentials === undefined
+        ? []
+        : [
+            {
+              id: r.id,
+              name: r.name,
+              credentials,
+              quotaThreshold: r.quota_threshold,
+              weight: r.weight,
+            },
+          ];
+    });
+
     await this.dispatcher.openaiDispatcher
       ?.replaceTokens(openaiRows)
-      .catch((e) => logger.warn(`openai reconcile failed: ${(e as Error).message}`));
+      .catch((e) =>
+        logger.warn(`openai reconcile failed: ${e instanceof Error ? e.message : String(e)}`),
+      );
+    const grokDispatcher = this.dispatcher.grokDispatcher;
+
+    if (grokDispatcher) {
+      const grokRows = rows
+        .filter((r) => r.provider === "grok")
+        .map((r) => ({
+          id: r.id,
+          name: r.name,
+          credentials: r.credentials,
+          quotaThreshold: r.quota_threshold,
+          weight: r.weight,
+        }));
+
+      await Promise.resolve()
+        .then(() => grokDispatcher.replaceTokens(grokRows))
+        .catch((e) =>
+          logger.warn(`grok reconcile failed: ${e instanceof Error ? e.message : String(e)}`),
+        );
+    }
+
     this.lastReconcileAt = new Date();
+
     if (
       previousAnthropicIds &&
       (previousAnthropicIds.size !== anthropicRows.length ||
@@ -298,9 +418,22 @@ export class TokenSubscriber {
     }
   }
 
+  // Grok dispatcher 는 선택적으로 주입된다. 동기/비동기 구현 모두의 실패를 격리한다.
+  async removeGrokToken(id: number): Promise<void> {
+    const grokDispatcher = this.dispatcher.grokDispatcher;
+
+    if (!grokDispatcher) return;
+    await Promise.resolve()
+      .then(() => grokDispatcher.onTokenRemoved(id))
+      .catch((e) =>
+        logger.warn(`grok token remove failed: ${e instanceof Error ? e.message : String(e)}`),
+      );
+  }
+
   enqueueOperation(operation: () => Promise<void>): Promise<void> {
     const next = this.operationChain.then(operation, operation);
     this.operationChain = next.catch(() => {});
+
     return next;
   }
 }

package/bundle/src/application/qgrid/token-trigger-setup.ts

@@ -55,6 +55,7 @@ export async function ensureTokensTrigger(connConfig: ClientConfig): Promise<voi
   });
 
   let lockAcquired = false;
+
   try {
     await client.connect();
     await client.query("SET search_path TO public");
@@ -77,6 +78,7 @@ export async function ensureTokensTrigger(connConfig: ClientConfig): Promise<voi
         ])
         .catch(() => {});
     }
+
     await client.end().catch(() => {});
   }
 }

package/bundle/src/application/qgrid/token-window-keepalive.ts

@@ -33,7 +33,7 @@ type TimerHandle = ReturnType<typeof setTimeout>;
 export type TokenWindowKeepaliveDeps = {
   findTokens: () => Promise<KeepaliveToken[]>;
   readUsage: (tokenId: number) => Promise<UsageResponse>;
-  dispatch: (input: InternalQueryInput) => Promise<unknown>;
+  dispatch: (input: InternalQueryInput) => Promise<void>;
   readSetting: typeof getSetting;
   isRunnerEnabled: () => boolean;
   now: () => number;
@@ -44,7 +44,9 @@ export type TokenWindowKeepaliveDeps = {
 const defaultDeps: TokenWindowKeepaliveDeps = {
   findTokens: () => TokenModel.findActiveByProvider("A", "anthropic"),
   readUsage: (tokenId) => QgridFrame.usage(tokenId),
-  dispatch: (input) => QgridFrame.query(input),
+  dispatch: async (input) => {
+    await QgridFrame.query(input);
+  },
   readSetting: getSetting,
   isRunnerEnabled: () => process.env[KEEPALIVE_ENV_KEY] === "true",
   now: () => Date.now(),
@@ -58,6 +60,7 @@ let generation = 0;
 
 function clearTokenTimer(tokenId: number): void {
   const timer = timers.get(tokenId);
+
   if (!timer) return;
   timer.clear(timer.handle);
   timers.delete(tokenId);
@@ -72,17 +75,22 @@ function scheduleToken(
 ): void {
   if (generation !== expectedGeneration) return;
   clearTokenTimer(token.id);
+
   const handle = deps.setTimer(
     () => {
       timers.delete(token.id);
+
       if (generation !== expectedGeneration) return;
       void inspectToken(token, deps, expectedGeneration, allowFire).catch((error) => {
-        logger.warn(`keepalive cycle failed for ${token.name}: ${(error as Error).message}`);
+        logger.warn(
+          `keepalive cycle failed for ${token.name}: ${error instanceof Error ? error.message : String(error)}`,
+        );
         scheduleFallback(token, deps, expectedGeneration);
       });
     },
     Math.max(0, delayMs),
   );
+
   timers.set(token.id, { handle, clear: deps.clearTimer });
 }
 
@@ -114,40 +122,55 @@ async function inspectToken(
 ): Promise<void> {
   const now = deps.now();
   const guard = fireGuards.get(token.id);
+
   if (guard && guard.untilMs > now) {
     scheduleToken(token, deps, expectedGeneration, guard.untilMs - now, guard.allowFireAtExpiry);
+
     return;
   }
+
   if (guard) fireGuards.delete(token.id);
 
   let usage: UsageResponse;
+
   try {
     usage = await deps.readUsage(token.id);
   } catch (error) {
-    logger.warn(`usage lookup failed for ${token.name}: ${(error as Error).message}`);
+    logger.warn(
+      `usage lookup failed for ${token.name}: ${error instanceof Error ? error.message : String(error)}`,
+    );
     scheduleFallback(token, deps, expectedGeneration);
+
     return;
   }
+
   if (generation !== expectedGeneration) return;
 
   if (usage.error) {
     logger.warn(`usage lookup failed for ${token.name}: ${usage.error}`);
     scheduleFallback(token, deps, expectedGeneration);
+
     return;
   }
 
   const resetsAt = usage.fiveHour?.resetsAt;
+
   if (resetsAt) {
     const resetMs = Date.parse(resetsAt);
+
     if (!Number.isFinite(resetMs)) {
       logger.warn(`invalid five-hour reset for ${token.name}: ${resetsAt}`);
       scheduleFallback(token, deps, expectedGeneration);
+
       return;
     }
+
     const inspectedAt = deps.now();
+
     if (resetMs > inspectedAt) {
       fireGuards.delete(token.id);
       scheduleToken(token, deps, expectedGeneration, resetMs - inspectedAt + RESET_GRACE_MS, true);
+
       return;
     }
   }
@@ -155,10 +178,12 @@ async function inspectToken(
   // 발사 직후 확인에서는 캐시된 null/과거 reset을 봐도 다시 발사하지 않는다.
   if (!allowFire) {
     scheduleFallback(token, deps, expectedGeneration);
+
     return;
   }
 
   deferToken(token, deps, expectedGeneration, POST_KEEPALIVE_USAGE_DELAY_MS, false);
+
   try {
     await deps.dispatch({
       prompt: "Reply OK.",
@@ -170,12 +195,16 @@ async function inspectToken(
     });
     logger.info(`keepalive sent for ${token.name}`);
   } catch (error) {
-    logger.warn(`keepalive failed for ${token.name}: ${(error as Error).message}`);
+    logger.warn(
+      `keepalive failed for ${token.name}: ${error instanceof Error ? error.message : String(error)}`,
+    );
     scheduleFallback(token, deps, expectedGeneration);
+
     return;
   }
 
   const postFireGuard = fireGuards.get(token.id);
+
   if (postFireGuard) {
     scheduleToken(
       token,
@@ -189,6 +218,7 @@ async function inspectToken(
 
 function clearScheduledTimers(): void {
   generation++;
+
   for (const tokenId of timers.keys()) clearTokenTimer(tokenId);
 }
 
@@ -196,32 +226,45 @@ export async function startTokenWindowKeepalive(
   deps: TokenWindowKeepaliveDeps = defaultDeps,
 ): Promise<void> {
   clearScheduledTimers();
+
   if (!deps.isRunnerEnabled()) {
     logger.info("token window keepalive runner disabled for this instance");
+
     return;
   }
+
   if (deps.readSetting(KEEPALIVE_SETTING_KEY) === "false") {
     logger.info("token window keepalive disabled");
+
     return;
   }
+
   const expectedGeneration = generation;
 
   let tokens: KeepaliveToken[];
+
   try {
     tokens = await deps.findTokens();
   } catch (error) {
-    logger.warn(`token discovery failed: ${(error as Error).message}`);
+    logger.warn(
+      `token discovery failed: ${error instanceof Error ? error.message : String(error)}`,
+    );
+
     return;
   }
+
   if (generation !== expectedGeneration) return;
 
   const targets = tokens.filter(
     (token) => token.active && token.provider === "anthropic" && token.keepalive_enabled,
   );
+
   const targetIds = new Set(targets.map((token) => token.id));
+
   for (const tokenId of fireGuards.keys()) {
     if (!targetIds.has(tokenId)) fireGuards.delete(tokenId);
   }
+
   logger.info(`token window keepalive scheduling ${targets.length} token(s)`);
   await Promise.all(targets.map((token) => inspectToken(token, deps, expectedGeneration, true)));
 }