@cartanova/qgrid-cli 1.7.3 → 1.9.0

package/bundle/dist/sonamu.config.js

@@ -5,20 +5,23 @@ import path from "path";
 import { getPrettyFormatter } from "@logtape/pretty";
 import dotenv from "dotenv";
 import { drivers, store } from "sonamu/cache";
-import { drivers as drivers$1 } from "sonamu/storage";
 //#region src/sonamu.config.ts
 dotenv.config({ path: path.join(import.meta.dirname, "../.env") });
 const host = process.env.HOST ?? "localhost";
 const port = Number(process.env.PORT ?? 44900);
+const connConfig = {
+	host: process.env.QGRID_DB_HOST ?? "localhost",
+	port: Number(process.env.QGRID_DB_PORT ?? 44901),
+	user: process.env.QGRID_DB_USER ?? "postgres",
+	password: process.env.QGRID_DB_PASSWORD ?? "postgres",
+	database: process.env.QGRID_DB_NAME ?? "qgrid"
+};
 var sonamu_config_default = defineConfig({
 	projectName: process.env.PROJECT_NAME ?? "SonamuProject",
 	database: {
 		name: process.env.QGRID_DB_NAME ?? "qgrid",
 		defaultOptions: { connection: {
-			host: process.env.QGRID_DB_HOST ?? "localhost",
-			port: Number(process.env.QGRID_DB_PORT ?? 44901),
-			user: process.env.QGRID_DB_USER ?? "postgres",
-			password: process.env.QGRID_DB_PASSWORD ?? "postgres",
+			...connConfig,
 			keepAlive: true,
 			keepAliveInitialDelayMillis: 1e4
 		} },
@@ -134,29 +137,6 @@ var sonamu_config_default = defineConfig({
 				}
 			}
 		},
-		storage: { drivers: {
-			fs: drivers$1.fs({
-				location: path.join(import.meta.dirname, "/../public/uploaded"),
-				visibility: "public",
-				urlBuilder: {
-					async generateURL(key) {
-						return `/api/public/uploaded/${key}`;
-					},
-					async generateSignedURL(key) {
-						return `/api/public/uploaded/${key}`;
-					}
-				}
-			}),
-			s3: drivers$1.s3({
-				credentials: {
-					accessKeyId: process.env.AWS_ACCESS_KEY_ID ?? "",
-					secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY ?? ""
-				},
-				region: process.env.S3_REGION ?? "ap-northeast-2",
-				bucket: process.env.S3_BUCKET ?? "sonamu_default_bucket",
-				visibility: "private"
-			})
-		} },
 		cache: {
 			default: "main",
 			stores: { main: store().useL1Layer(drivers.memory({ maxSize: "50mb" })) },
@@ -178,17 +158,23 @@ var sonamu_config_default = defineConfig({
 					console.warn(`⚠ Migration skipped: ${e.message}`);
 				}
 				const { QgridDispatcher } = await import("./application/qgrid/qgrid.dispatcher.js");
+				const { ensureTokensTrigger } = await import("./application/qgrid/token-trigger-setup.js");
+				const { TokenSubscriber } = await import("./application/qgrid/token-subscriber.js");
+				let triggerReady = true;
 				try {
-					const { TokenModel } = await import("./application/token/token.model.js");
-					const entries = await TokenModel.findActive("A");
-					for (const e of entries) QgridDispatcher.addToken(e.token, e.name);
-					console.log(`🌲 Server listening on http://${host}:${port} (${QgridDispatcher.tokens.size} tokens loaded)`);
+					await ensureTokensTrigger(connConfig);
 				} catch (e) {
-					console.warn(`⚠ Dispatcher init failed: ${e.message}`);
-					console.log(`🌲 Server listening on http://${host}:${port} (no tokens)`);
+					triggerReady = false;
+					console.warn(`⚠ Token trigger setup failed: ${e.message}. Continuing with LISTEN/reconcile.`);
 				}
+				const subscriber = new TokenSubscriber(connConfig, QgridDispatcher);
+				QgridDispatcher.subscriber = subscriber;
+				const tokenInfo = await subscriber.start() ? `${QgridDispatcher.tokens.size} active tokens, LISTEN active` : `degraded — token sync retry scheduled`;
+				console.log(`🌲 Server listening on http://${host}:${port} (${tokenInfo}${triggerReady ? "" : ", trigger setup failed"})`);
 			},
-			onShutdown: () => {
+			onShutdown: async () => {
+				const { QgridDispatcher } = await import("./application/qgrid/qgrid.dispatcher.js");
+				if (QgridDispatcher.subscriber) await QgridDispatcher.subscriber.stop();
 				console.log("graceful shutdown");
 			},
 			onError: (error, _request, reply) => {
@@ -204,4 +190,4 @@ var sonamu_config_default = defineConfig({
 //#endregion
 export { sonamu_config_default as default };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"sonamu.config.js","names":["drivers","cacheDrivers"],"sources":["../src/sonamu.config.ts"],"sourcesContent":["import path from \"path\";\n\nimport { getConsoleSink } from \"@logtape/logtape\";\nimport { getPrettyFormatter } from \"@logtape/pretty\";\nimport dotenv from \"dotenv\";\nimport { CachePresets, defineConfig } from \"sonamu\";\nimport { drivers as cacheDrivers, store } from \"sonamu/cache\";\nimport { drivers } from \"sonamu/storage\";\n\ndotenv.config({ path: path.join(import.meta.dirname, \"../.env\") });\n\nconst host = process.env.HOST ?? \"localhost\";\nconst port = Number(process.env.PORT ?? 44900);\n\nexport default defineConfig({\n  projectName: process.env.PROJECT_NAME ?? \"SonamuProject\",\n  database: {\n    name: process.env.QGRID_DB_NAME ?? \"qgrid\",\n    defaultOptions: {\n      connection: {\n        host: process.env.QGRID_DB_HOST ?? \"localhost\",\n        port: Number(process.env.QGRID_DB_PORT ?? 44901),\n        user: process.env.QGRID_DB_USER ?? \"postgres\",\n        password: process.env.QGRID_DB_PASSWORD ?? \"postgres\",\n        keepAlive: true,\n        keepAliveInitialDelayMillis: 10000,\n      },\n    },\n    environments: {\n      fixture: {\n        connection: {\n          host: process.env.DEV0_DB_HOST,\n          port: Number(process.env.DEV0_DB_PORT),\n          database: process.env.QGRID_DB_NAME + \"_fixture\",\n          user: process.env.DEV0_DB_USER,\n          password: process.env.DEV0_DB_PASSWORD,\n        },\n      },\n      test: {\n        connection: {\n          host: \"0.0.0.0\",\n          port: 54321,\n          database: \"qgrid_test\",\n          user: \"postgres\",\n          password: \"postgres\",\n        },\n      },\n    },\n  },\n  api: {\n    dir: \"api\",\n    timezone: \"Asia/Seoul\",\n    route: {\n      prefix: \"/api\",\n    },\n  },\n  i18n: {\n    defaultLocale: \"ko\",\n    supportedLocales: [\"ko\", \"en\"],\n  },\n  sync: {\n    targets: [\"web\"],\n  },\n  slackConfirm:\n    process.env.SLACK_BOT_TOKEN && process.env.SLACK_CHANNEL_ID\n      ? {\n          targets: [\"development_master\", \"production_master\"],\n          botToken: process.env.SLACK_BOT_TOKEN ?? \"\",\n          channelId: process.env.SLACK_CHANNEL_ID ?? \"\",\n        }\n      : undefined,\n  test: {\n    parallel: true,\n    maxWorkers: 4,\n    devRunner: { enabled: true },\n  },\n  logging: {\n    sinks: {\n      console: getConsoleSink({\n        formatter: getPrettyFormatter({\n          timestamp: \"time\",\n          categoryWidth: 20,\n          categoryTruncate: \"middle\",\n        }),\n      }),\n    },\n    loggers: [\n      // qgrid 로그 (요청 분배, oauth/usage API)\n      { category: [\"qgrid\"], sinks: [\"console\"], lowestLevel: \"info\" },\n      // sonamu 로그는 warning 이상만\n      { category: [\"sonamu\"], sinks: [\"console\"], lowestLevel: \"warning\" },\n      // fastify 로그 차단\n      { category: [\"fastify\"], sinks: [], lowestLevel: \"fatal\" },\n    ],\n  },\n  server: {\n    listen: { port, host },\n    plugins: {\n      formbody: true,\n      qs: true,\n      multipart: { limits: { fileSize: 1024 * 1024 * 30 } },\n      static: {\n        root: path.join(import.meta.dirname, \"/../\", \"public\"),\n        prefix: \"/api/public\",\n      },\n      custom: (server) => {\n        // OAuth 콜백 — Anthropic이 /callback으로 리다이렉트\n        server.get(\"/callback\", async (request, reply) => {\n          const { code, state } = request.query as { code?: string; state?: string };\n          if (!code || !state) {\n            return reply.redirect(\"/?oauth=error&reason=missing_params\");\n          }\n          // Frame의 oauthCallback으로 위임\n          try {\n            const { QgridFrame } = await import(\"./application/qgrid/qgrid.frame\");\n            await QgridFrame.handleOAuthCallback(code, state, reply);\n          } catch (e) {\n            return reply.redirect(\n              `/?oauth=error&reason=${encodeURIComponent((e as Error).message)}`,\n            );\n          }\n        });\n      },\n    },\n    apiConfig: {\n      contextProvider: (defaultContext, request) => {\n        return {\n          ...defaultContext,\n          ip: request.ip,\n          body: request.body,\n        };\n      },\n      guardHandler: () => {},\n      cacheControlHandler: (req) => {\n        switch (req.type) {\n          case \"assets\":\n            // Hash 포함된 파일: 영구 캐시\n            if (req.path.match(/-[a-f0-9]+\\./)) {\n              return CachePresets.immutable;\n            }\n            return CachePresets.longLived;\n\n          case \"api\":\n            // GET 요청만 캐싱 고려\n            if (req.method === \"GET\") {\n              // 특정 경로는 짧은 캐시\n              if (req.path.startsWith(\"/api/static-data\")) {\n                return CachePresets.shortLived;\n              }\n              if (req.path.startsWith(\"/api/terms\")) {\n                return CachePresets.mediumLived;\n              }\n            }\n            // 기본: 캐시 없음\n            return CachePresets.noCache;\n\n          case \"ssr\":\n            // SSR 페이지: 10초 캐시\n            return CachePresets.ssr;\n\n          case \"csr\":\n            // CSR fallback (index.html): 1분 캐시\n            return CachePresets.shortLived;\n        }\n      },\n    },\n    storage: {\n      drivers: {\n        fs: drivers.fs({\n          location: path.join(import.meta.dirname, \"/../public/uploaded\"),\n          visibility: \"public\",\n          urlBuilder: {\n            async generateURL(key) {\n              return `/api/public/uploaded/${key}`;\n            },\n            async generateSignedURL(key) {\n              return `/api/public/uploaded/${key}`;\n            },\n          },\n        }),\n        s3: drivers.s3({\n          credentials: {\n            accessKeyId: process.env.AWS_ACCESS_KEY_ID ?? \"\",\n            secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY ?? \"\",\n          },\n          region: process.env.S3_REGION ?? \"ap-northeast-2\",\n          bucket: process.env.S3_BUCKET ?? \"sonamu_default_bucket\",\n          visibility: \"private\",\n        }),\n      },\n    },\n    cache: {\n      default: \"main\",\n      stores: {\n        main: store().useL1Layer(cacheDrivers.memory({ maxSize: \"50mb\" })),\n      },\n      ttl: \"5m\",\n      prefix: \"\",\n    },\n    lifecycle: {\n      onStart: async () => {\n        // DB 마이그레이션 자동 실행 (테이블 없으면 생성)\n        try {\n          const { TokenModel } = await import(\"./application/token/token.model\");\n          const knex = TokenModel.getDB(\"w\");\n          const migrationsDir = path.join(import.meta.dirname, \"../src/migrations\");\n          const [batch, log] = await knex.migrate.latest({\n            directory: migrationsDir,\n          });\n          if (log.length > 0) {\n            console.log(`✓ Migration: ${log.length} applied (batch ${batch})`);\n            log.forEach((name: string) => console.log(`  ✓ ${name}`));\n          }\n        } catch (e) {\n          console.warn(`⚠ Migration skipped: ${(e as Error).message}`);\n        }\n\n        const { QgridDispatcher } = await import(\"./application/qgrid/qgrid.dispatcher\");\n        try {\n          const { TokenModel } = await import(\"./application/token/token.model\");\n          const entries = await TokenModel.findActive(\"A\");\n          for (const e of entries) QgridDispatcher.addToken(e.token, e.name);\n          console.log(\n            `🌲 Server listening on http://${host}:${port} (${QgridDispatcher.tokens.size} tokens loaded)`,\n          );\n        } catch (e) {\n          console.warn(`⚠ Dispatcher init failed: ${(e as Error).message}`);\n          console.log(`🌲 Server listening on http://${host}:${port} (no tokens)`);\n        }\n      },\n      onShutdown: () => {\n        console.log(\"graceful shutdown\");\n      },\n      onError: (error, _request, reply) => {\n        console.error(error);\n        reply.status(500).send({\n          name: error.name,\n          message: error.message,\n        });\n      },\n    },\n  },\n});\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"sonamu.config.js","names":["cacheDrivers"],"sources":["../src/sonamu.config.ts"],"sourcesContent":["import path from \"path\";\n\nimport { getConsoleSink } from \"@logtape/logtape\";\nimport { getPrettyFormatter } from \"@logtape/pretty\";\nimport dotenv from \"dotenv\";\nimport { CachePresets, defineConfig } from \"sonamu\";\nimport { drivers as cacheDrivers, store } from \"sonamu/cache\";\n\ndotenv.config({ path: path.join(import.meta.dirname, \"../.env\") });\n\nconst host = process.env.HOST ?? \"localhost\";\nconst port = Number(process.env.PORT ?? 44900);\n\nconst connConfig = {\n  host: process.env.QGRID_DB_HOST ?? \"localhost\",\n  port: Number(process.env.QGRID_DB_PORT ?? 44901),\n  user: process.env.QGRID_DB_USER ?? \"postgres\",\n  password: process.env.QGRID_DB_PASSWORD ?? \"postgres\",\n  database: process.env.QGRID_DB_NAME ?? \"qgrid\",\n};\n\nexport default defineConfig({\n  projectName: process.env.PROJECT_NAME ?? \"SonamuProject\",\n  database: {\n    name: process.env.QGRID_DB_NAME ?? \"qgrid\",\n    defaultOptions: {\n      connection: {\n        ...connConfig,\n        keepAlive: true,\n        keepAliveInitialDelayMillis: 10000,\n      },\n    },\n    environments: {\n      fixture: {\n        connection: {\n          host: process.env.DEV0_DB_HOST,\n          port: Number(process.env.DEV0_DB_PORT),\n          database: process.env.QGRID_DB_NAME + \"_fixture\",\n          user: process.env.DEV0_DB_USER,\n          password: process.env.DEV0_DB_PASSWORD,\n        },\n      },\n      test: {\n        connection: {\n          host: \"0.0.0.0\",\n          port: 54321,\n          database: \"qgrid_test\",\n          user: \"postgres\",\n          password: \"postgres\",\n        },\n      },\n    },\n  },\n  api: {\n    dir: \"api\",\n    timezone: \"Asia/Seoul\",\n    route: {\n      prefix: \"/api\",\n    },\n  },\n  i18n: {\n    defaultLocale: \"ko\",\n    supportedLocales: [\"ko\", \"en\"],\n  },\n  sync: {\n    targets: [\"web\"],\n  },\n  slackConfirm:\n    process.env.SLACK_BOT_TOKEN && process.env.SLACK_CHANNEL_ID\n      ? {\n          targets: [\"development_master\", \"production_master\"],\n          botToken: process.env.SLACK_BOT_TOKEN ?? \"\",\n          channelId: process.env.SLACK_CHANNEL_ID ?? \"\",\n        }\n      : undefined,\n  test: {\n    parallel: true,\n    maxWorkers: 4,\n    devRunner: { enabled: true },\n  },\n  logging: {\n    sinks: {\n      console: getConsoleSink({\n        formatter: getPrettyFormatter({\n          timestamp: \"time\",\n          categoryWidth: 20,\n          categoryTruncate: \"middle\",\n        }),\n      }),\n    },\n    loggers: [\n      // qgrid 로그 (요청 분배, oauth/usage API)\n      { category: [\"qgrid\"], sinks: [\"console\"], lowestLevel: \"info\" },\n      // sonamu 로그는 warning 이상만\n      { category: [\"sonamu\"], sinks: [\"console\"], lowestLevel: \"warning\" },\n      // fastify 로그 차단\n      { category: [\"fastify\"], sinks: [], lowestLevel: \"fatal\" },\n    ],\n  },\n  server: {\n    listen: { port, host },\n    plugins: {\n      formbody: true,\n      qs: true,\n      multipart: { limits: { fileSize: 1024 * 1024 * 30 } },\n      static: {\n        root: path.join(import.meta.dirname, \"/../\", \"public\"),\n        prefix: \"/api/public\",\n      },\n      custom: (server) => {\n        // OAuth 콜백 — Anthropic이 /callback으로 리다이렉트\n        server.get(\"/callback\", async (request, reply) => {\n          const { code, state } = request.query as { code?: string; state?: string };\n          if (!code || !state) {\n            return reply.redirect(\"/?oauth=error&reason=missing_params\");\n          }\n          // Frame의 oauthCallback으로 위임\n          try {\n            const { QgridFrame } = await import(\"./application/qgrid/qgrid.frame\");\n            await QgridFrame.handleOAuthCallback(code, state, reply);\n          } catch (e) {\n            return reply.redirect(\n              `/?oauth=error&reason=${encodeURIComponent((e as Error).message)}`,\n            );\n          }\n        });\n      },\n    },\n    apiConfig: {\n      contextProvider: (defaultContext, request) => {\n        return {\n          ...defaultContext,\n          ip: request.ip,\n          body: request.body,\n        };\n      },\n      guardHandler: () => {},\n      cacheControlHandler: (req) => {\n        switch (req.type) {\n          case \"assets\":\n            // Hash 포함된 파일: 영구 캐시\n            if (req.path.match(/-[a-f0-9]+\\./)) {\n              return CachePresets.immutable;\n            }\n            return CachePresets.longLived;\n\n          case \"api\":\n            // GET 요청만 캐싱 고려\n            if (req.method === \"GET\") {\n              // 특정 경로는 짧은 캐시\n              if (req.path.startsWith(\"/api/static-data\")) {\n                return CachePresets.shortLived;\n              }\n              if (req.path.startsWith(\"/api/terms\")) {\n                return CachePresets.mediumLived;\n              }\n            }\n            // 기본: 캐시 없음\n            return CachePresets.noCache;\n\n          case \"ssr\":\n            // SSR 페이지: 10초 캐시\n            return CachePresets.ssr;\n\n          case \"csr\":\n            // CSR fallback (index.html): 1분 캐시\n            return CachePresets.shortLived;\n        }\n      },\n    },\n    cache: {\n      default: \"main\",\n      stores: {\n        main: store().useL1Layer(cacheDrivers.memory({ maxSize: \"50mb\" })),\n      },\n      ttl: \"5m\",\n      prefix: \"\",\n    },\n    lifecycle: {\n      onStart: async () => {\n        // DB 마이그레이션 자동 실행 (테이블 없으면 생성)\n        try {\n          const { TokenModel } = await import(\"./application/token/token.model\");\n          const knex = TokenModel.getDB(\"w\");\n          const migrationsDir = path.join(import.meta.dirname, \"../src/migrations\");\n          const [batch, log] = await knex.migrate.latest({\n            directory: migrationsDir,\n          });\n          if (log.length > 0) {\n            console.log(`✓ Migration: ${log.length} applied (batch ${batch})`);\n            log.forEach((name: string) => console.log(`  ✓ ${name}`));\n          }\n        } catch (e) {\n          console.warn(`⚠ Migration skipped: ${(e as Error).message}`);\n        }\n\n        const { QgridDispatcher } = await import(\"./application/qgrid/qgrid.dispatcher\");\n        const { ensureTokensTrigger } = await import(\"./application/qgrid/token-trigger-setup\");\n        const { TokenSubscriber } = await import(\"./application/qgrid/token-subscriber\");\n\n        let triggerReady = true;\n        try {\n          await ensureTokensTrigger(connConfig);\n        } catch (e) {\n          triggerReady = false;\n          console.warn(\n            `⚠ Token trigger setup failed: ${(e as Error).message}. Continuing with LISTEN/reconcile.`,\n          );\n        }\n\n        const subscriber = new TokenSubscriber(connConfig, QgridDispatcher);\n        QgridDispatcher.subscriber = subscriber;\n\n        const started = await subscriber.start();\n        const tokenInfo = started\n          ? `${QgridDispatcher.tokens.size} active tokens, LISTEN active`\n          : `degraded — token sync retry scheduled`;\n        const triggerInfo = triggerReady ? \"\" : \", trigger setup failed\";\n        console.log(`🌲 Server listening on http://${host}:${port} (${tokenInfo}${triggerInfo})`);\n      },\n      onShutdown: async () => {\n        const { QgridDispatcher } = await import(\"./application/qgrid/qgrid.dispatcher\");\n        if (QgridDispatcher.subscriber) {\n          await QgridDispatcher.subscriber.stop();\n        }\n        console.log(\"graceful shutdown\");\n      },\n      onError: (error, _request, reply) => {\n        console.error(error);\n        reply.status(500).send({\n          name: error.name,\n          message: error.message,\n        });\n      },\n    },\n  },\n});\n"],"mappings":"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"}

package/bundle/dist/testing/setup-mocks.js

@@ -14,4 +14,4 @@ vi.mock("fs/promises", async (importOriginal) => {
 //#endregion
 export {};
 
-//# 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/utils/subset-loaders.js

@@ -9,4 +9,4 @@ function getSubsetLoaders(subsets, subsetQueries) {
 //#endregion
 export { getSubsetLoaders };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3Vic2V0LWxvYWRlcnMuanMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vc3JjL3V0aWxzL3N1YnNldC1sb2FkZXJzLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgU3Vic2V0UXVlcnkgfSBmcm9tIFwic29uYW11XCI7XG5cbmV4cG9ydCBmdW5jdGlvbiBnZXRTdWJzZXRMb2FkZXJzKHN1YnNldHM6IHN0cmluZ1tdLCBzdWJzZXRRdWVyaWVzOiBSZWNvcmQ8c3RyaW5nLCBTdWJzZXRRdWVyeT4pIHtcbiAgcmV0dXJuIHN1YnNldHMucmVkdWNlKFxuICAgIChhY2MsIHN1YnNldCkgPT4ge1xuICAgICAgYWNjW3N1YnNldF0gPSBzdWJzZXRRdWVyaWVzW3N1YnNldF0/LmxvYWRlcnMgPz8gW107XG4gICAgICByZXR1cm4gYWNjO1xuICAgIH0sXG4gICAge30gYXMgUmVjb3JkPHN0cmluZywgU3Vic2V0UXVlcnlbXCJsb2FkZXJzXCJdPixcbiAgKTtcbn1cbiJdLCJtYXBwaW5ncyI6Ijs7QUFFQSxTQUFnQixpQkFBaUIsU0FBbUIsZUFBNEM7QUFDOUYsUUFBTyxRQUFRLFFBQ1osS0FBSyxXQUFXO0FBQ2YsTUFBSSxVQUFVLGNBQWMsU0FBUyxXQUFXLEVBQUU7QUFDbEQsU0FBTztJQUVULEVBQUUsQ0FDSCJ9
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3Vic2V0LWxvYWRlcnMuanMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vc3JjL3V0aWxzL3N1YnNldC1sb2FkZXJzLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IHR5cGUgU3Vic2V0UXVlcnkgfSBmcm9tIFwic29uYW11XCI7XG5cbmV4cG9ydCBmdW5jdGlvbiBnZXRTdWJzZXRMb2FkZXJzKHN1YnNldHM6IHN0cmluZ1tdLCBzdWJzZXRRdWVyaWVzOiBSZWNvcmQ8c3RyaW5nLCBTdWJzZXRRdWVyeT4pIHtcbiAgcmV0dXJuIHN1YnNldHMucmVkdWNlKFxuICAgIChhY2MsIHN1YnNldCkgPT4ge1xuICAgICAgYWNjW3N1YnNldF0gPSBzdWJzZXRRdWVyaWVzW3N1YnNldF0/LmxvYWRlcnMgPz8gW107XG4gICAgICByZXR1cm4gYWNjO1xuICAgIH0sXG4gICAge30gYXMgUmVjb3JkPHN0cmluZywgU3Vic2V0UXVlcnlbXCJsb2FkZXJzXCJdPixcbiAgKTtcbn1cbiJdLCJtYXBwaW5ncyI6Ijs7QUFFQSxTQUFnQixpQkFBaUIsU0FBbUIsZUFBNEM7QUFDOUYsUUFBTyxRQUFRLFFBQ1osS0FBSyxXQUFXO0FBQ2YsTUFBSSxVQUFVLGNBQWMsU0FBUyxXQUFXLEVBQUU7QUFDbEQsU0FBTztJQUVULEVBQUUsQ0FDSCJ9

package/bundle/src/application/qgrid/qgrid.dispatcher.ts

@@ -2,94 +2,137 @@
  * QgridDispatcher — OAuth 토큰 선택 + claude CLI fresh spawn 디스패처 싱글턴.
  *
  * - 매 요청마다 새 claude CLI 프로세스 spawn → 응답 후 종료
- * - system 은 --append-system-prompt 로 분리 전달 (user turn 오염 방지)
  * - least-used round-robin 으로 토큰 선택
+ * - 메모리 캐시 (Map<id, TokenSubsetA>) 는 TokenSubscriber 가 pg LISTEN/NOTIFY 로 갱신
+ * - query 시 expires_at 비교 → 임박 시 preemptive refresh
  * - QuotaError 는 그대로 상위 전파 (자동 failover 없음, UI 에서 수동 토글)
  *
- * env allowlist: PATH, TMPDIR, CLAUDE_CODE_OAUTH_TOKEN + CLAUDE_CODE_DISABLE_*
+ * env allowlist: PATH, TMPDIR, CLAUDE_CODE_OAUTH_TOKEN, CLAUDE_CONFIG_DIR
+ *   + CLAUDE_CODE_DISABLE_* + CLAUDE_CODE_ATTRIBUTION_HEADER
  */
 import { spawn } from "node:child_process";
 import { mkdirSync, writeFileSync } from "node:fs";
 
 import { getLogger } from "@logtape/logtape";
 
+import { type TokenSubsetA } from "../sonamu.generated";
 import { type CliResult, type QueryInput, type TokenStats } from "./qgrid.types";
 import { maskToken, ProcessError, QuotaError, TimeoutError } from "./qgrid.types";
+import { type TokenSubscriber } from "./token-subscriber";
 
 const logger = getLogger(["qgrid"]);
 
 const DEFAULT_MODEL = "sonnet";
 const DEFAULT_TIMEOUT_MS = 600_000;
+const DEFAULT_EFFORT = "high";
 
 // claude CLI 의 cwd. 이 경로의 .claude/settings.json 이 project scope 로 로드되어
 // 혹시라도 있을 user scope (~/.claude/settings.json)를 덮어씀 (--setting-sources project 와 함께).
 const CLAUDE_CWD = "/tmp/qgrid";
 
-// qgrid 전용 project settings — user scope 격리용
+// 글로벌 user config 격리 경로. (CC에서 환경변수로 읽는변수)
+const CLAUDE_CONFIG_DIR = "/tmp/qgrid-config";
+
+// qgrid 전용 project/global settings — user scope 격리용
 const QGRID_CLAUDE_SETTINGS = {
   alwaysThinkingEnabled: false, // thinking block 차단
   includeGitInstructions: false, // system prompt 의 git 가이드 제거
   cleanupPeriodDays: 1,
 };
 
-class QgridDispatcherClass {
-  tokens = new Map<string, string>();
+// 토큰 만료 임박 임계값 — token.expiredAt이 1분 안에 만료된다면 query 시 체크하고 refresh.
+const REFRESH_SAFETY_MS = 60_000;
+
+export class QgridDispatcherClass {
+  tokens = new Map<number, TokenSubsetA>();
+
+  // key기반(tokenName) 누적 카운터. token 이 OAuth refresh 로 로테이트되도 tokenName 은 불변이라 카운터 유지됨
   requestCounts = new Map<string, number>();
   rrIndex = 0;
 
+  // sonamu.config onStart 에서 처리하는 변수
+  subscriber: TokenSubscriber | null = null;
+
   constructor() {
+    const settingsJson = JSON.stringify(QGRID_CLAUDE_SETTINGS, null, 2);
+
     mkdirSync(`${CLAUDE_CWD}/.claude`, { recursive: true });
-    writeFileSync(
-      `${CLAUDE_CWD}/.claude/settings.json`,
-      JSON.stringify(QGRID_CLAUDE_SETTINGS, null, 2),
-    );
+    writeFileSync(`${CLAUDE_CWD}/.claude/settings.json`, settingsJson);
+
+    mkdirSync(CLAUDE_CONFIG_DIR, { recursive: true });
+    writeFileSync(`${CLAUDE_CONFIG_DIR}/.claude.json`, "{}");
+    writeFileSync(`${CLAUDE_CONFIG_DIR}/settings.json`, settingsJson);
+  }
+
+  countOf(name: string): number {
+    return this.requestCounts.get(name) ?? 0;
+  }
+
+  // TokenSubscriber 콜백 — 캐시 mutation
+  upsertCache(id: number, row: TokenSubsetA): void {
+    this.tokens.set(id, row);
+  }
+
+  removeCache(id: number): void {
+    this.tokens.delete(id);
+  }
+
+  replaceCache(rows: TokenSubsetA[]): void {
+    this.tokens = new Map(rows.map((r) => [r.id, r]));
   }
 
   getStats(): TokenStats[] {
-    return [...this.tokens.entries()].map(([token, name]) => ({
-      token,
-      name,
-      requests: this.requestCounts.get(token) ?? 0,
+    return [...this.tokens.values()].map((r) => ({
+      token: r.token,
+      name: r.name,
+      requests: this.countOf(r.name),
     }));
   }
 
-  selectToken(): { token: string; name: string } | null {
-    const entries = [...this.tokens.entries()];
-    if (entries.length === 0) return null;
+  selectToken(): TokenSubsetA | null {
+    const rows = [...this.tokens.values()];
+    if (rows.length === 0) return null;
 
-    const minCount = Math.min(...entries.map(([t]) => this.requestCounts.get(t) ?? 0));
-    const idle = entries.filter(([t]) => (this.requestCounts.get(t) ?? 0) === minCount);
+    const minCount = Math.min(...rows.map((r) => this.countOf(r.name)));
+    const idle = rows.filter((r) => this.countOf(r.name) === minCount);
     const picked = idle[this.rrIndex % idle.length]!;
     this.rrIndex++;
-    return { token: picked[0], name: picked[1] };
+    return picked;
   }
 
   async query(input: QueryInput, timeoutMs?: number): Promise<CliResult> {
-    const sel = this.selectToken();
-    if (!sel) throw new QuotaError("No tokens available");
+    const electedToken = this.selectToken();
+    if (!electedToken) throw new QuotaError("No tokens available");
 
     // await 전에 count 선반영. 병렬 요청이 동시에 도착해도 각자 다른 토큰을 고르도록.
-    this.requestCounts.set(sel.token, (this.requestCounts.get(sel.token) ?? 0) + 1);
-
-    logger.info(`→ ${sel.name} (model: ${input.model ?? DEFAULT_MODEL})`);
-
-    const result = await executeClaude(input, sel.token, timeoutMs ?? DEFAULT_TIMEOUT_MS);
-    return { ...result, tokenName: sel.name, model: input.model ?? DEFAULT_MODEL };
-  }
+    this.requestCounts.set(electedToken.name, this.countOf(electedToken.name) + 1);
 
-  addToken(token: string, name: string): void {
-    if (this.tokens.has(token)) return;
-    this.tokens.set(token, name);
-    this.requestCounts.set(token, 0);
-  }
+    let token = electedToken.token;
+    // expires_at 임박이면 refresh.
+    // refresh 후 DB save → trigger NOTIFY → subscriber 가 받아 캐시 갱신 (다른 dispatcher 도 동기화)
+    if (
+      electedToken.expires_at &&
+      Number(electedToken.expires_at) - Date.now() < REFRESH_SAFETY_MS &&
+      electedToken.refresh_token
+    ) {
+      try {
+        const { QgridFrame } = await import("./qgrid.frame");
+        token = await QgridFrame.refreshToken({
+          id: electedToken.id,
+          token: electedToken.token,
+          name: electedToken.name,
+          refresh_token: electedToken.refresh_token,
+        });
+      } catch (e) {
+        logger.warn(`refresh failed for ${electedToken.name}: ${(e as Error).message}`);
+        // refresh 실패 시 기존 token 으로 진행. executeClaude 가 401 받으면 caller 처리.
+      }
+    }
 
-  removeToken(token: string): void {
-    this.tokens.delete(token);
-    this.requestCounts.delete(token);
-  }
+    logger.info(`→ ${electedToken.name} (model: ${input.model ?? DEFAULT_MODEL})`);
 
-  hasToken(token: string): boolean {
-    return this.tokens.has(token);
+    const result = await executeClaude(input, token, timeoutMs ?? DEFAULT_TIMEOUT_MS);
+    return { ...result, tokenName: electedToken.name, model: input.model ?? DEFAULT_MODEL };
   }
 }
 
@@ -111,11 +154,14 @@ async function executeClaude(
   const args: string[] = [
     "-p",
     ...toolArgs,
+    "--disallowedTools",
+    // CC에서 자동 활성화되는 deferred 도구. 토큰 최적화를위해 차단
+    ...(["Monitor", "PushNotification", "RemoteTrigger"] as const),
     "--output-format",
     "stream-json",
     "--verbose",
+    // --max-turns: structured output 은 tool_use + tool_result 로 2턴 소비
     "--max-turns",
-    // structured output 은 tool_use + tool_result 로 2턴 소비
     useStructuredOutput ? "2" : "1",
     "--permission-mode",
     "bypassPermissions",
@@ -123,31 +169,42 @@ async function executeClaude(
     "project",
     "--model",
     model,
-    // thinking 비활성화는 project settings (alwaysThinkingEnabled: false) 에서 처리
-    "--exclude-dynamic-system-prompt-sections", // cwd/env 를 user msg 로 이동 → prefix cache 안정화
-    "--no-session-persistence", // ~/.claude/projects/ 의 orphan jsonl 누적 방지
+    // --system-prompt는 반드시 명시해야함. 옵션 생략 시 CC가 default system prompt를 자동으로 주입함(23k)
+    "--system-prompt",
+    input.system ?? "",
+    "--thinking",
+    "disabled",
+    "--effort",
+    input.effort ?? DEFAULT_EFFORT,
+    "--no-session-persistence",
+    // 모든 skills 비활성화
+    "--disable-slash-commands",
   ];
   if (useStructuredOutput) {
     args.push("--json-schema", input.jsonSchema!);
   }
-  if (input.system) {
-    args.push("--append-system-prompt", input.system);
-  }
   args.push(input.prompt);
 
   const env: NodeJS.ProcessEnv = {
     PATH: process.env.PATH,
     TMPDIR: process.env.TMPDIR,
     CLAUDE_CODE_OAUTH_TOKEN: token,
+    // CLAUDE_CONFIG_DIR 환경변수로 주입
+    CLAUDE_CONFIG_DIR,
     CLAUDE_CODE_DISABLE_AUTO_MEMORY: "1",
     CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING: "1",
     CLAUDE_CODE_DISABLE_1M_CONTEXT: "1",
+    CLAUDE_CODE_DISABLE_CLAUDE_MDS: "1",
+    CLAUDE_CODE_ATTRIBUTION_HEADER: "0",
   };
 
   return new Promise<CliResult>((resolve, reject) => {
     const child = spawn("claude", args, {
       stdio: ["ignore", "pipe", "ignore"],
       env,
+      // 격리 (두 단계):
+      // 1. CLAUDE_CWD — project scope 격리 (cwd 의 .claude/settings.json)
+      // 2. CLAUDE_CONFIG_DIR — user scope 격리 cwd 격리만으론 부족.
       cwd: CLAUDE_CWD,
     });
 

package/bundle/src/application/qgrid/qgrid.frame.ts

@@ -15,6 +15,7 @@ import {
 import { QgridDispatcher } from "./qgrid.dispatcher";
 import {
   type CliResult,
+  type Effort,
   type HealthResponse,
   type OAuthStartResult,
   type TokenStats,
@@ -38,8 +39,12 @@ class QgridFrameClass extends BaseFrameClass {
     model?: string,
     projectName?: string,
     jsonSchema?: string,
+    effort?: Effort,
   ): Promise<CliResult> {
-    const result = await QgridDispatcher.query({ system, prompt, model, jsonSchema }, timeout);
+    const result = await QgridDispatcher.query(
+      { system, prompt, model, jsonSchema, effort },
+      timeout,
+    );
 
     RequestLogModel.save([
       {
@@ -85,7 +90,6 @@ class QgridFrameClass extends BaseFrameClass {
         ...(refreshToken && refreshToken.length > 0 ? { refresh_token: refreshToken } : {}),
       },
     ]);
-    QgridDispatcher.addToken(token, name);
     return { added: true };
   }
 
@@ -109,28 +113,19 @@ class QgridFrameClass extends BaseFrameClass {
         ...(hasRefreshToken ? { refresh_token: refreshToken } : {}),
       },
     ]);
-
-    if (hasNewToken) {
-      QgridDispatcher.removeToken(token);
-      QgridDispatcher.addToken(newToken, name ?? entry.name);
-    }
     return { updated: true };
   }
 
   @api({ httpMethod: "POST", clients: ["axios", "tanstack-mutation"] })
   async removeToken(token: string): Promise<{ removed: boolean }> {
-    if (!QgridDispatcher.hasToken(token)) return { removed: false };
-
     const entry = await TokenModel.findByToken("A", token);
-    if (entry) await TokenModel.del([entry.id]);
-    QgridDispatcher.removeToken(token);
+    if (!entry) return { removed: false };
+    await TokenModel.del([entry.id]);
     return { removed: true };
   }
 
   /**
-   * @param id token_id
-   * 토큰 활성화/비활성화 토글 (dispatcher 등록/제거 & DB의 active 필드 업데이트)
-   * @returns 토큰 활성화 여부
+   * 토큰 활성화/비활성화 토글 DB의 active 필드 업데이트
    */
   @api({ httpMethod: "POST", clients: ["axios", "tanstack-mutation"] })
   async toggleToken(id: number): Promise<{ active: boolean }> {
@@ -139,13 +134,6 @@ class QgridFrameClass extends BaseFrameClass {
 
     const newActive = !entry.active;
     await TokenModel.save([{ id, token: entry.token, active: newActive, name: entry.name }]);
-
-    if (newActive) {
-      QgridDispatcher.addToken(entry.token, entry.name);
-    } else {
-      QgridDispatcher.removeToken(entry.token);
-    }
-
     return { active: newActive };
   }
 
@@ -181,7 +169,6 @@ class QgridFrameClass extends BaseFrameClass {
       if (tokens.accountUuid) {
         const oldEntries = await TokenModel.findByAccountUuid("A", tokens.accountUuid);
         if (oldEntries.length > 0) {
-          for (const old of oldEntries) QgridDispatcher.removeToken(old.token);
           await TokenModel.del(oldEntries.map((o) => o.id));
         }
       }
@@ -195,7 +182,6 @@ class QgridFrameClass extends BaseFrameClass {
           account_uuid: tokens.accountUuid,
         },
       ]);
-      QgridDispatcher.addToken(tokens.accessToken, pending.name);
 
       return reply.redirect(`/?oauth=success&name=${encodeURIComponent(pending.name)}`);
     } catch (e) {
@@ -251,14 +237,16 @@ class QgridFrameClass extends BaseFrameClass {
         name: token.name ?? "",
       },
     ]);
-    QgridDispatcher.removeToken(token.token);
-    QgridDispatcher.addToken(refreshed.accessToken, token.name);
     return refreshed.accessToken;
   }
 
   @api({ httpMethod: "GET", clients: ["axios", "tanstack-query"] })
   async health(): Promise<HealthResponse> {
-    return { status: "ok", activeTokens: QgridDispatcher.tokens.size };
+    return {
+      status: "ok",
+      activeTokens: QgridDispatcher.tokens.size,
+      subscriber: QgridDispatcher.subscriber?.status() ?? null,
+    };
   }
 }
 

package/bundle/src/application/qgrid/qgrid.types.ts

@@ -2,12 +2,16 @@ import { z } from "zod";
 
 // ─── Query ───
 
+export const Effort = z.enum(["low", "medium", "high"]);
+export type Effort = z.infer<typeof Effort>;
+
 export const QueryInput = z.object({
   system: z.string().optional(),
   prompt: z.string(),
   model: z.string().optional(),
   timeout: z.number().optional(),
   jsonSchema: z.string().optional(),
+  effort: Effort.optional(),
 });
 export type QueryInput = z.infer<typeof QueryInput>;
 
@@ -82,9 +86,18 @@ export type UsageResponse = z.infer<typeof UsageResponse>;
 
 // ─── Health ───
 
+export const SubscriberStatus = z.object({
+  connected: z.boolean(),
+  connectedAt: z.date().nullable(),
+  lastReconcileAt: z.date().nullable(),
+  attempt: z.number(),
+});
+export type SubscriberStatus = z.infer<typeof SubscriberStatus>;
+
 export const HealthResponse = z.object({
   status: z.string(),
   activeTokens: z.number(),
+  subscriber: SubscriberStatus.nullable(),
 });
 export type HealthResponse = z.infer<typeof HealthResponse>;