@cartanova/qgrid-cli 1.9.0 → 2.0.1

package/bundle/dist/utils/providers/openai/openai-dispatcher.js

@@ -0,0 +1,325 @@
+import "../../../_virtual/_rolldown/runtime.js";
+import { TokenModel } from "../../../application/token/token.model.js";
+import { CodexAppServerWorker } from "./codex-worker.js";
+import { handleChatgptAuthTokensRefresh } from "./openai-refresh.js";
+import { getLogger } from "@logtape/logtape";
+//#region src/utils/providers/openai/openai-dispatcher.ts
+/**
+* OpenAIDispatcher — codex app-server worker pool + 토큰 라우팅.
+*
+* - 토큰당 N worker (CodexAppServerWorker), 기본 3
+* - idle worker round-robin 선택 + 큐 대기 (전부 busy 시)
+* - TokenSubscriber 이벤트로 worker pool 동기화
+* - backpressure: 큐 full 또는 timeout 시 SERVER_BUSY
+*/
+const logger = getLogger(["qgrid", "openai-dispatcher"]);
+const DEFAULT_EFFORT = "low";
+const WORKERS_PER_TOKEN = Math.min(Number(process.env.QGRID_WORKERS_PER_TOKEN ?? 3), 5);
+const QUEUE_TIMEOUT_MS = 6e4;
+const MAX_QUEUE_SIZE = 50;
+const SPAWN_INTERVAL_MS = 500;
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var OpenAIDispatcher = class OpenAIDispatcher {
+	workerPool = /* @__PURE__ */ new Map();
+	rrCursor = 0;
+	queue = [];
+	async start() {
+		const { rows } = await TokenModel.findMany("A");
+		const openaiTokens = rows.filter((t) => t.provider === "openai");
+		logger.info(`starting ${openaiTokens.length} openai tokens (${WORKERS_PER_TOKEN} workers each)`);
+		await Promise.allSettled(openaiTokens.map(async (t) => {
+			await this.spawnWorkers(t.id, t.name, t.credentials);
+			if (!t.active) this.onTokenDeactivated(t.id);
+		}));
+	}
+	async stop() {
+		this.rejectAllQueued("DISPATCHER_SHUTDOWN");
+		const kills = [...this.workerPool.values()].flat().map((w) => w.kill());
+		await Promise.allSettled(kills);
+		this.workerPool.clear();
+	}
+	async onTokenAdded(id, name, credentials) {
+		if (this.workerPool.has(id)) return;
+		await this.spawnWorkers(id, name, credentials);
+	}
+	async onTokenRemoved(id) {
+		const workers = this.workerPool.get(id) ?? [];
+		this.workerPool.delete(id);
+		await Promise.allSettled(workers.map((w) => w.kill()));
+		if (this.getAllReadyActiveWorkers().length === 0) this.rejectAllQueued("NO_OPENAI_WORKERS");
+		if (workers.length > 0) logger.info(`workers removed for token ${id}: ${workers.length}`);
+	}
+	async onTokenUpdated(id, name, credentials) {
+		const existing = this.workerPool.get(id) ?? [];
+		this.workerPool.delete(id);
+		await Promise.allSettled(existing.map((w) => w.kill()));
+		await this.spawnWorkers(id, name, credentials);
+	}
+	onTokenDeactivated(id) {
+		(this.workerPool.get(id) ?? []).forEach((w) => {
+			w.active = false;
+		});
+		if (this.getAllReadyActiveWorkers().length === 0) this.rejectAllQueued("NO_ACTIVE_WORKERS");
+		logger.info(`workers deactivated: token ${id}`);
+	}
+	onTokenActivated(id) {
+		(this.workerPool.get(id) ?? []).forEach((w) => {
+			w.active = true;
+		});
+		this.drainQueue();
+		logger.info(`workers activated: token ${id}`);
+	}
+	async generate(req) {
+		const worker = this.acquireIdleWorker();
+		if (worker) {
+			logger.info(`→ ${worker.tokenName}[${worker.tokenId}] (model: ${req.model})`);
+			return this.executeAndRelease(worker, (w) => this.executeTurn(w, req));
+		}
+		return this.enqueue((w) => {
+			logger.info(`→ ${w.tokenName}[${w.tokenId}] (model: ${req.model}, queued)`);
+			return this.executeTurn(w, req);
+		});
+	}
+	async generateStream(req, cb) {
+		const worker = this.acquireIdleWorker();
+		if (worker) {
+			logger.info(`→ ${worker.tokenName}[${worker.tokenId}] (model: ${req.model}, [stream])`);
+			return this.executeAndRelease(worker, (w) => this.executeStreamTurn(w, req, cb));
+		}
+		return this.enqueue((w) => {
+			logger.info(`→ ${w.tokenName}[${w.tokenId}] (model: ${req.model}, [stream], queued)`);
+			return this.executeStreamTurn(w, req, cb);
+		});
+	}
+	async interruptWorkerTurn(threadId, turnId) {
+		const allWorkers = [...this.workerPool.values()].flat().filter((w) => w.isReady);
+		await Promise.allSettled(allWorkers.map((w) => w.interruptTurn(threadId, turnId)));
+	}
+	acquireIdleWorker() {
+		const allWorkers = this.getAllReadyActiveWorkers();
+		if (allWorkers.length === 0) return null;
+		for (let i = 0; i < allWorkers.length; i++) {
+			const w = allWorkers[(this.rrCursor + i) % allWorkers.length];
+			if (w.tryAcquireTurn()) {
+				this.rrCursor = (this.rrCursor + i + 1) % allWorkers.length;
+				return w;
+			}
+		}
+		return null;
+	}
+	getAllReadyActiveWorkers() {
+		return [...this.workerPool.values()].flat().filter((w) => w.isReady && w.active);
+	}
+	enqueue(execute) {
+		if (this.getAllReadyActiveWorkers().length === 0) return Promise.reject(/* @__PURE__ */ new Error("NO_OPENAI_WORKERS"));
+		if (this.queue.length >= MAX_QUEUE_SIZE) return Promise.reject(/* @__PURE__ */ new Error("SERVER_BUSY"));
+		return new Promise((resolve, reject) => {
+			const item = {
+				resolve: (worker) => {
+					clearTimeout(item.timer);
+					item.abortCleanup?.();
+					Promise.resolve().then(() => this.executeAndRelease(worker, execute)).then(resolve, reject);
+				},
+				reject: (err) => {
+					clearTimeout(item.timer);
+					item.abortCleanup?.();
+					reject(err);
+				},
+				timer: setTimeout(() => {
+					this.removeFromQueue(item);
+					reject(/* @__PURE__ */ new Error("SERVER_BUSY"));
+				}, QUEUE_TIMEOUT_MS)
+			};
+			this.queue.push(item);
+		});
+	}
+	removeFromQueue(item) {
+		clearTimeout(item.timer);
+		item.abortCleanup?.();
+		const idx = this.queue.indexOf(item);
+		if (idx !== -1) this.queue.splice(idx, 1);
+	}
+	rejectAllQueued(reason) {
+		const err = new Error(reason);
+		this.queue.forEach((item) => {
+			clearTimeout(item.timer);
+			item.abortCleanup?.();
+			item.reject(err);
+		});
+		this.queue = [];
+	}
+	drainQueue(releasedWorker) {
+		if (releasedWorker && this.queue.length > 0 && releasedWorker.isReady && releasedWorker.active && releasedWorker.tryAcquireTurn()) {
+			this.queue.shift().resolve(releasedWorker);
+			return;
+		}
+		while (this.queue.length > 0) {
+			const worker = this.acquireIdleWorker();
+			if (!worker) break;
+			this.queue.shift().resolve(worker);
+		}
+	}
+	async executeAndRelease(worker, execute) {
+		try {
+			return await execute(worker);
+		} finally {
+			worker.releaseTurn();
+			this.drainQueue(worker);
+		}
+	}
+	async executeTurn(worker, req) {
+		const turnReq = {
+			input: req.input,
+			developerInstructions: req.systemPrompt,
+			outputSchema: req.outputSchema,
+			effort: req.effort ?? DEFAULT_EFFORT,
+			model: req.model,
+			history: req.history,
+			verbosity: req.verbosity,
+			reasoningSummary: req.reasoningSummary,
+			serviceTier: req.serviceTier
+		};
+		const result = await worker.executeTurn(turnReq);
+		return {
+			text: result.text,
+			tokenName: worker.tokenName,
+			usage: result.usage,
+			durationMs: result.durationMs,
+			model: result.model
+		};
+	}
+	async executeStreamTurn(worker, req, cb) {
+		const turnReq = {
+			input: req.input,
+			developerInstructions: req.systemPrompt,
+			outputSchema: req.outputSchema,
+			effort: req.effort ?? DEFAULT_EFFORT,
+			model: req.model,
+			history: req.history,
+			verbosity: req.verbosity,
+			reasoningSummary: req.reasoningSummary,
+			serviceTier: req.serviceTier
+		};
+		const wrappedCb = {
+			...cb,
+			onComplete: (result) => {
+				cb.onComplete({
+					...result,
+					tokenName: worker.tokenName
+				});
+			}
+		};
+		await worker.executeTurnStream(turnReq, wrappedCb);
+	}
+	async spawnWorkers(tokenId, tokenName, credentials) {
+		const workers = [];
+		for (let i = 0; i < WORKERS_PER_TOKEN; i++) {
+			if (i > 0) await sleep(SPAWN_INTERVAL_MS);
+			const worker = await this.spawnSingleWorker(tokenId, tokenName, credentials, i);
+			if (worker) workers.push(worker);
+		}
+		if (workers.length > 0) {
+			this.workerPool.set(tokenId, workers);
+			logger.info(`${workers.length}/${WORKERS_PER_TOKEN} workers spawned for ${tokenName}`);
+		}
+	}
+	async spawnSingleWorker(tokenId, tokenName, credentials, workerIndex) {
+		const worker = new CodexAppServerWorker({
+			tokenId,
+			tokenName,
+			accessToken: credentials.accessToken,
+			accountId: credentials.accountId,
+			planType: credentials.planType,
+			workerIndex
+		});
+		worker.onReady = () => this.drainQueue();
+		worker.setServerRequestHandler(async (method) => {
+			if (method === "account/chatgptAuthTokens/refresh") return handleChatgptAuthTokensRefresh(tokenId);
+			throw new Error(`unhandled server-request: ${method}`);
+		});
+		try {
+			await worker.initialize();
+			logger.info(`worker spawned: ${tokenName}[${workerIndex}] (id=${tokenId + 1})`);
+			return worker;
+		} catch (e) {
+			logger.warn(`worker spawn failed: ${tokenName}[${workerIndex}]: ${e.message}`);
+			await worker.kill().catch(() => {});
+			return null;
+		}
+	}
+	rateLimitsCache = /* @__PURE__ */ new Map();
+	static RATE_LIMITS_CACHE_TTL = 6e4;
+	async getRateLimits(tokenName) {
+		const cacheKey = tokenName ?? "_default";
+		const cached = this.rateLimitsCache.get(cacheKey);
+		if (cached && Date.now() - cached.cachedAt < OpenAIDispatcher.RATE_LIMITS_CACHE_TTL) return cached.data;
+		const allWorkers = [...this.workerPool.values()].flat().filter((w) => w.isReady);
+		const worker = tokenName ? allWorkers.find((w) => w.tokenName === tokenName) : allWorkers[0];
+		if (!worker) throw new Error("no ready openai workers");
+		const data = await worker.getRateLimits();
+		this.rateLimitsCache.set(cacheKey, {
+			data,
+			cachedAt: Date.now()
+		});
+		return data;
+	}
+	pendingLogin = null;
+	async startBrowserLogin(name) {
+		if (this.pendingLogin) {
+			this.pendingLogin.worker.kill().catch(() => {});
+			clearTimeout(this.pendingLogin.timer);
+			this.pendingLogin = null;
+		}
+		const worker = new CodexAppServerWorker({
+			tokenId: Date.now(),
+			tokenName: name,
+			accessToken: "",
+			accountId: ""
+		});
+		const authUrl = await worker.startBrowserLogin();
+		this.pendingLogin = {
+			worker,
+			name,
+			timer: setTimeout(() => {
+				if (this.pendingLogin?.worker === worker) {
+					logger.warn(`browser login timeout for ${name}, killing worker`);
+					worker.kill().catch(() => {});
+					this.pendingLogin = null;
+				}
+			}, 3e5)
+		};
+		return { authUrl };
+	}
+	get pendingLoginName() {
+		return this.pendingLogin?.name ?? null;
+	}
+	async completeBrowserLogin() {
+		if (!this.pendingLogin) throw new Error("no pending login");
+		const { worker, timer } = this.pendingLogin;
+		try {
+			await worker.waitForBrowserLoginComplete();
+			const creds = await worker.readManagedCredentials();
+			if (!creds) throw new Error("failed to read credentials after login");
+			return creds;
+		} finally {
+			clearTimeout(timer);
+			this.pendingLogin = null;
+			await worker.kill().catch(() => {});
+		}
+	}
+	get workerCount() {
+		return [...this.workerPool.values()].flat().length;
+	}
+	get readyWorkerCount() {
+		return [...this.workerPool.values()].flat().filter((w) => w.isReady).length;
+	}
+	get queueLength() {
+		return this.queue.length;
+	}
+};
+//#endregion
+export { OpenAIDispatcher };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"openai-dispatcher.js","names":[],"sources":["../../../../src/utils/providers/openai/openai-dispatcher.ts"],"sourcesContent":["/**\n * OpenAIDispatcher — codex app-server worker pool + 토큰 라우팅.\n *\n * - 토큰당 N worker (CodexAppServerWorker), 기본 3\n * - idle worker round-robin 선택 + 큐 대기 (전부 busy 시)\n * - TokenSubscriber 이벤트로 worker pool 동기화\n * - backpressure: 큐 full 또는 timeout 시 SERVER_BUSY\n */\nimport { getLogger } from \"@logtape/logtape\";\n\nimport { TokenModel } from \"../../../application/token/token.model\";\nimport { type OpenAICredentials } from \"../../../application/token/token.types\";\nimport {\n  type GenerateRequest,\n  type GenerateResult,\n  type ProviderDispatcher,\n} from \"../common/provider-dispatcher\";\nimport {\n  CodexAppServerWorker,\n  type StreamCallbacks,\n  type TurnRequest,\n  type TurnResult,\n} from \"./codex-worker\";\nimport { handleChatgptAuthTokensRefresh } from \"./openai-refresh\";\n\nconst logger = getLogger([\"qgrid\", \"openai-dispatcher\"]);\n\nconst DEFAULT_EFFORT = \"low\";\nconst MAX_WORKERS_PER_TOKEN = 5;\nconst WORKERS_PER_TOKEN = Math.min(\n  Number(process.env.QGRID_WORKERS_PER_TOKEN ?? 3),\n  MAX_WORKERS_PER_TOKEN,\n);\nconst QUEUE_TIMEOUT_MS = 60_000;\nconst MAX_QUEUE_SIZE = 50;\nconst SPAWN_INTERVAL_MS = 500;\n\nfunction sleep(ms: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, ms));\n}\n\ntype QueueItem = {\n  resolve: (worker: CodexAppServerWorker) => void;\n  reject: (error: Error) => void;\n  timer: ReturnType<typeof setTimeout>;\n  abortCleanup?: () => void;\n};\n\nexport class OpenAIDispatcher implements ProviderDispatcher {\n  workerPool = new Map<number, CodexAppServerWorker[]>();\n  rrCursor = 0;\n  queue: QueueItem[] = [];\n\n  async start(): Promise<void> {\n    const { rows } = await TokenModel.findMany(\"A\");\n    const openaiTokens = rows.filter((t) => t.provider === \"openai\");\n    logger.info(\n      `starting ${openaiTokens.length} openai tokens (${WORKERS_PER_TOKEN} workers each)`,\n    );\n\n    await Promise.allSettled(\n      openaiTokens.map(async (t) => {\n        await this.spawnWorkers(t.id, t.name, t.credentials as OpenAICredentials);\n        if (!t.active) this.onTokenDeactivated(t.id);\n      }),\n    );\n  }\n\n  async stop(): Promise<void> {\n    this.rejectAllQueued(\"DISPATCHER_SHUTDOWN\");\n    const kills = [...this.workerPool.values()].flat().map((w) => w.kill());\n    await Promise.allSettled(kills);\n    this.workerPool.clear();\n  }\n\n  // ── Token events (from TokenSubscriber) ─────────────────────────\n\n  async onTokenAdded(id: number, name: string, credentials: OpenAICredentials): Promise<void> {\n    if (this.workerPool.has(id)) return;\n    await this.spawnWorkers(id, name, credentials);\n  }\n\n  async onTokenRemoved(id: number): Promise<void> {\n    const workers = this.workerPool.get(id) ?? [];\n    this.workerPool.delete(id);\n    await Promise.allSettled(workers.map((w) => w.kill()));\n    if (this.getAllReadyActiveWorkers().length === 0) {\n      this.rejectAllQueued(\"NO_OPENAI_WORKERS\");\n    }\n    if (workers.length > 0) logger.info(`workers removed for token ${id}: ${workers.length}`);\n  }\n\n  async onTokenUpdated(id: number, name: string, credentials: OpenAICredentials): Promise<void> {\n    const existing = this.workerPool.get(id) ?? [];\n    this.workerPool.delete(id);\n    await Promise.allSettled(existing.map((w) => w.kill()));\n    await this.spawnWorkers(id, name, credentials);\n  }\n\n  onTokenDeactivated(id: number): void {\n    (this.workerPool.get(id) ?? []).forEach((w) => {\n      w.active = false;\n    });\n    if (this.getAllReadyActiveWorkers().length === 0) {\n      this.rejectAllQueued(\"NO_ACTIVE_WORKERS\");\n    }\n    logger.info(`workers deactivated: token ${id}`);\n  }\n\n  onTokenActivated(id: number): void {\n    (this.workerPool.get(id) ?? []).forEach((w) => {\n      w.active = true;\n    });\n    this.drainQueue();\n    logger.info(`workers activated: token ${id}`);\n  }\n\n  // ── Generate ────────────────────────────────────────────────────\n\n  async generate(req: GenerateRequest): Promise<GenerateResult> {\n    const worker = this.acquireIdleWorker();\n    if (worker) {\n      logger.info(`→ ${worker.tokenName}[${worker.tokenId}] (model: ${req.model})`);\n      return this.executeAndRelease(worker, (w) => this.executeTurn(w, req));\n    }\n    return this.enqueue((w) => {\n      logger.info(`→ ${w.tokenName}[${w.tokenId}] (model: ${req.model}, queued)`);\n      return this.executeTurn(w, req);\n    });\n  }\n\n  async generateStream(req: GenerateRequest, cb: StreamCallbacks): Promise<void> {\n    const worker = this.acquireIdleWorker();\n    if (worker) {\n      logger.info(`→ ${worker.tokenName}[${worker.tokenId}] (model: ${req.model}, [stream])`);\n      return this.executeAndRelease(worker, (w) => this.executeStreamTurn(w, req, cb));\n    }\n    return this.enqueue((w) => {\n      logger.info(`→ ${w.tokenName}[${w.tokenId}] (model: ${req.model}, [stream], queued)`);\n      return this.executeStreamTurn(w, req, cb);\n    });\n  }\n\n  async interruptWorkerTurn(threadId: string, turnId: string): Promise<void> {\n    const allWorkers = [...this.workerPool.values()].flat().filter((w) => w.isReady);\n    await Promise.allSettled(allWorkers.map((w) => w.interruptTurn(threadId, turnId)));\n  }\n\n  // ── Worker selection ────────────────────────────────────────────\n  //  기본 round-robin\n  // TODO: 추후 다른 알고리즘으로 변경 가능하게 지원\n  acquireIdleWorker(): CodexAppServerWorker | null {\n    const allWorkers = this.getAllReadyActiveWorkers();\n    if (allWorkers.length === 0) return null;\n    for (let i = 0; i < allWorkers.length; i++) {\n      const w = allWorkers[(this.rrCursor + i) % allWorkers.length]!;\n      if (w.tryAcquireTurn()) {\n        this.rrCursor = (this.rrCursor + i + 1) % allWorkers.length;\n        return w;\n      }\n    }\n    return null;\n  }\n\n  getAllReadyActiveWorkers(): CodexAppServerWorker[] {\n    return [...this.workerPool.values()].flat().filter((w) => w.isReady && w.active);\n  }\n\n  // ── Queue ───────────────────────────────────────────────────────\n\n  enqueue<T>(execute: (worker: CodexAppServerWorker) => Promise<T>): Promise<T> {\n    if (this.getAllReadyActiveWorkers().length === 0) {\n      return Promise.reject(new Error(\"NO_OPENAI_WORKERS\"));\n    }\n    if (this.queue.length >= MAX_QUEUE_SIZE) {\n      return Promise.reject(new Error(\"SERVER_BUSY\"));\n    }\n\n    return new Promise<T>((resolve, reject) => {\n      const item: QueueItem = {\n        resolve: (worker) => {\n          clearTimeout(item.timer);\n          item.abortCleanup?.();\n          Promise.resolve()\n            .then(() => this.executeAndRelease(worker, execute))\n            .then(resolve, reject);\n        },\n        reject: (err) => {\n          clearTimeout(item.timer);\n          item.abortCleanup?.();\n          reject(err);\n        },\n        timer: setTimeout(() => {\n          this.removeFromQueue(item);\n          reject(new Error(\"SERVER_BUSY\"));\n        }, QUEUE_TIMEOUT_MS),\n      };\n\n      this.queue.push(item);\n    });\n  }\n\n  removeFromQueue(item: QueueItem): void {\n    clearTimeout(item.timer);\n    item.abortCleanup?.();\n    const idx = this.queue.indexOf(item);\n    if (idx !== -1) this.queue.splice(idx, 1);\n  }\n\n  rejectAllQueued(reason: string): void {\n    const err = new Error(reason);\n    this.queue.forEach((item) => {\n      clearTimeout(item.timer);\n      item.abortCleanup?.();\n      item.reject(err);\n    });\n    this.queue = [];\n  }\n\n  drainQueue(releasedWorker?: CodexAppServerWorker): void {\n    if (\n      releasedWorker &&\n      this.queue.length > 0 &&\n      releasedWorker.isReady &&\n      releasedWorker.active &&\n      releasedWorker.tryAcquireTurn()\n    ) {\n      const next = this.queue.shift()!;\n      next.resolve(releasedWorker);\n      return;\n    }\n\n    while (this.queue.length > 0) {\n      const worker = this.acquireIdleWorker();\n      if (!worker) break;\n      const next = this.queue.shift()!;\n      next.resolve(worker);\n    }\n  }\n\n  // ── Execution ───────────────────────────────────────────────────\n\n  async executeAndRelease<T>(\n    worker: CodexAppServerWorker,\n    execute: (worker: CodexAppServerWorker) => Promise<T>,\n  ): Promise<T> {\n    try {\n      return await execute(worker);\n    } finally {\n      worker.releaseTurn();\n      this.drainQueue(worker);\n    }\n  }\n\n  async executeTurn(worker: CodexAppServerWorker, req: GenerateRequest): Promise<GenerateResult> {\n    const turnReq: TurnRequest = {\n      input: req.input,\n      developerInstructions: req.systemPrompt,\n      outputSchema: req.outputSchema,\n      effort: req.effort ?? DEFAULT_EFFORT,\n      model: req.model,\n      history: req.history,\n      verbosity: req.verbosity,\n      reasoningSummary: req.reasoningSummary,\n      serviceTier: req.serviceTier,\n    };\n    const result: TurnResult = await worker.executeTurn(turnReq);\n    return {\n      text: result.text,\n      tokenName: worker.tokenName,\n      usage: result.usage,\n      durationMs: result.durationMs,\n      model: result.model,\n    };\n  }\n\n  async executeStreamTurn(\n    worker: CodexAppServerWorker,\n    req: GenerateRequest,\n    cb: StreamCallbacks,\n  ): Promise<void> {\n    const turnReq: TurnRequest = {\n      input: req.input,\n      developerInstructions: req.systemPrompt,\n      outputSchema: req.outputSchema,\n      effort: req.effort ?? DEFAULT_EFFORT,\n      model: req.model,\n      history: req.history,\n      verbosity: req.verbosity,\n      reasoningSummary: req.reasoningSummary,\n      serviceTier: req.serviceTier,\n    };\n    const wrappedCb: StreamCallbacks = {\n      ...cb,\n      onComplete: (result) => {\n        cb.onComplete({ ...result, tokenName: worker.tokenName } as TurnResult & {\n          tokenName: string;\n        });\n      },\n    };\n    await worker.executeTurnStream(turnReq, wrappedCb);\n  }\n\n  // ── Spawn ───────────────────────────────────────────────────────\n\n  async spawnWorkers(\n    tokenId: number,\n    tokenName: string,\n    credentials: OpenAICredentials,\n  ): Promise<void> {\n    const workers: CodexAppServerWorker[] = [];\n    for (let i = 0; i < WORKERS_PER_TOKEN; i++) {\n      if (i > 0) await sleep(SPAWN_INTERVAL_MS);\n      const worker = await this.spawnSingleWorker(tokenId, tokenName, credentials, i);\n      if (worker) workers.push(worker);\n    }\n    if (workers.length > 0) {\n      this.workerPool.set(tokenId, workers);\n      logger.info(`${workers.length}/${WORKERS_PER_TOKEN} workers spawned for ${tokenName}`);\n    }\n  }\n\n  async spawnSingleWorker(\n    tokenId: number,\n    tokenName: string,\n    credentials: OpenAICredentials,\n    workerIndex: number,\n  ): Promise<CodexAppServerWorker | null> {\n    const worker = new CodexAppServerWorker({\n      tokenId,\n      tokenName,\n      accessToken: credentials.accessToken,\n      accountId: credentials.accountId,\n      planType: credentials.planType,\n      workerIndex,\n    });\n\n    worker.onReady = () => this.drainQueue();\n\n    worker.setServerRequestHandler(async (method) => {\n      if (method === \"account/chatgptAuthTokens/refresh\") {\n        return handleChatgptAuthTokensRefresh(tokenId);\n      }\n      throw new Error(`unhandled server-request: ${method}`);\n    });\n\n    try {\n      await worker.initialize();\n      logger.info(`worker spawned: ${tokenName}[${workerIndex}] (id=${tokenId + 1})`);\n      return worker;\n    } catch (e) {\n      logger.warn(`worker spawn failed: ${tokenName}[${workerIndex}]: ${(e as Error).message}`);\n      await worker.kill().catch(() => {});\n      return null;\n    }\n  }\n\n  // ── Rate limits ─────────────────────────────────────────────────\n\n  rateLimitsCache = new Map<string, { data: unknown; cachedAt: number }>();\n  static readonly RATE_LIMITS_CACHE_TTL = 60_000;\n\n  async getRateLimits(tokenName?: string): Promise<unknown> {\n    const cacheKey = tokenName ?? \"_default\";\n    const cached = this.rateLimitsCache.get(cacheKey);\n    if (cached && Date.now() - cached.cachedAt < OpenAIDispatcher.RATE_LIMITS_CACHE_TTL) {\n      return cached.data;\n    }\n\n    const allWorkers = [...this.workerPool.values()].flat().filter((w) => w.isReady);\n    const worker = tokenName ? allWorkers.find((w) => w.tokenName === tokenName) : allWorkers[0];\n    if (!worker) throw new Error(\"no ready openai workers\");\n    const data = await worker.getRateLimits();\n    this.rateLimitsCache.set(cacheKey, { data, cachedAt: Date.now() });\n    return data;\n  }\n\n  // ── Browser login flow ───────────────────────────────────────────\n\n  pendingLogin: {\n    worker: CodexAppServerWorker;\n    name: string;\n    timer: ReturnType<typeof setTimeout>;\n  } | null = null;\n\n  async startBrowserLogin(name: string): Promise<{ authUrl: string }> {\n    if (this.pendingLogin) {\n      this.pendingLogin.worker.kill().catch(() => {});\n      clearTimeout(this.pendingLogin.timer);\n      this.pendingLogin = null;\n    }\n\n    const tempId = Date.now();\n    const worker = new CodexAppServerWorker({\n      tokenId: tempId,\n      tokenName: name,\n      accessToken: \"\",\n      accountId: \"\",\n    });\n\n    const authUrl = await worker.startBrowserLogin();\n\n    const timer = setTimeout(() => {\n      if (this.pendingLogin?.worker === worker) {\n        logger.warn(`browser login timeout for ${name}, killing worker`);\n        worker.kill().catch(() => {});\n        this.pendingLogin = null;\n      }\n    }, 300_000);\n\n    this.pendingLogin = { worker, name, timer };\n    return { authUrl };\n  }\n\n  get pendingLoginName(): string | null {\n    return this.pendingLogin?.name ?? null;\n  }\n\n  async completeBrowserLogin(): Promise<{\n    accessToken: string;\n    refreshToken: string;\n    idToken?: string;\n    accountId: string;\n  }> {\n    if (!this.pendingLogin) throw new Error(\"no pending login\");\n    const { worker, timer } = this.pendingLogin;\n\n    try {\n      await worker.waitForBrowserLoginComplete();\n      const creds = await worker.readManagedCredentials();\n      if (!creds) throw new Error(\"failed to read credentials after login\");\n      return creds;\n    } finally {\n      clearTimeout(timer);\n      this.pendingLogin = null;\n      await worker.kill().catch(() => {});\n    }\n  }\n\n  // ── Stats ───────────────────────────────────────────────────────\n\n  get workerCount(): number {\n    return [...this.workerPool.values()].flat().length;\n  }\n\n  get readyWorkerCount(): number {\n    return [...this.workerPool.values()].flat().filter((w) => w.isReady).length;\n  }\n\n  get queueLength(): number {\n    return this.queue.length;\n  }\n}\n"],"mappings":"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"}

package/bundle/dist/utils/providers/openai/openai-refresh.js

@@ -0,0 +1,93 @@
+import "../../../_virtual/_rolldown/runtime.js";
+import { TokenModel } from "../../../application/token/token.model.js";
+import { OPENAI_CLIENT_ID, OPENAI_TOKEN_URL } from "./openai-constants.js";
+import { getLogger } from "@logtape/logtape";
+//#region src/utils/providers/openai/openai-refresh.ts
+/**
+* OpenAI chatgptAuthTokens refresh handler.
+*
+* - codex app-server 가 401 받으면 `account/chatgptAuthTokens/refresh` server-request 를 보냄
+* - qgrid 가 DB 의 refresh_token 으로 새 access_token 을 발급받아 응답
+* - per-token inflight promise 로 concurrent refresh dedup
+* - rotation 감지: 새 refresh_token 있으면 DB 즉시 업데이트
+*/
+const logger = getLogger(["qgrid", "openai-refresh"]);
+const inflightRefresh = /* @__PURE__ */ new Map();
+const lastRefreshTime = /* @__PURE__ */ new Map();
+const REFRESH_MIN_INTERVAL_MS = 5e3;
+async function handleChatgptAuthTokensRefresh(tokenId) {
+	const existing = inflightRefresh.get(tokenId);
+	if (existing) {
+		logger.info(`refresh dedup for token ${tokenId}`);
+		return existing;
+	}
+	const lastAt = lastRefreshTime.get(tokenId) ?? 0;
+	if (Date.now() - lastAt < REFRESH_MIN_INTERVAL_MS) {
+		logger.info(`refresh too soon for token ${tokenId}, reading current creds from DB`);
+		return readCurrentCreds(tokenId);
+	}
+	lastRefreshTime.set(tokenId, Date.now());
+	const promise = doRefresh(tokenId);
+	inflightRefresh.set(tokenId, promise);
+	try {
+		return await promise;
+	} finally {
+		inflightRefresh.delete(tokenId);
+	}
+}
+async function readCurrentCreds(tokenId) {
+	const token = await TokenModel.findOne("A", { id: tokenId });
+	if (!token || token.provider !== "openai") throw new Error(`token ${tokenId} not found`);
+	const creds = token.credentials;
+	return {
+		accessToken: creds.accessToken,
+		chatgptAccountId: creds.accountId,
+		chatgptPlanType: creds.planType
+	};
+}
+async function doRefresh(tokenId) {
+	const token = await TokenModel.findOne("A", { id: tokenId });
+	if (!token || token.provider !== "openai") throw new Error(`token ${tokenId} not found or not openai`);
+	const creds = token.credentials;
+	if (!creds.refreshToken) throw new Error(`token ${tokenId} has no refreshToken`);
+	logger.info(`refreshing token ${token.name} (id=${tokenId})`);
+	const resp = await fetch(OPENAI_TOKEN_URL, {
+		method: "POST",
+		headers: { "Content-Type": "application/x-www-form-urlencoded" },
+		body: new URLSearchParams({
+			grant_type: "refresh_token",
+			client_id: OPENAI_CLIENT_ID,
+			refresh_token: creds.refreshToken
+		})
+	});
+	if (!resp.ok) {
+		const body = await resp.text().catch(() => "");
+		throw new Error(`OpenAI refresh failed: ${resp.status} ${body}`);
+	}
+	const data = await resp.json();
+	const newRefreshToken = data.refresh_token ?? creds.refreshToken;
+	if (data.refresh_token !== null && data.refresh_token !== void 0 && data.refresh_token !== creds.refreshToken) logger.info(`refresh_token rotated for token ${token.name}`);
+	const updatedCreds = {
+		...creds,
+		accessToken: data.access_token,
+		refreshToken: newRefreshToken,
+		accessTokenExpiresAt: data.expires_in ? Date.now() + data.expires_in * 1e3 : creds.accessTokenExpiresAt,
+		...data.id_token ? { idToken: data.id_token } : {}
+	};
+	await TokenModel.save([{
+		id: tokenId,
+		provider: "openai",
+		credentials: updatedCreds,
+		name: token.name
+	}]);
+	logger.info(`token ${token.name} refreshed successfully`);
+	return {
+		accessToken: data.access_token,
+		chatgptAccountId: creds.accountId,
+		chatgptPlanType: creds.planType
+	};
+}
+//#endregion
+export { handleChatgptAuthTokensRefresh };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"openai-refresh.js","names":[],"sources":["../../../../src/utils/providers/openai/openai-refresh.ts"],"sourcesContent":["/**\n * OpenAI chatgptAuthTokens refresh handler.\n *\n * - codex app-server 가 401 받으면 `account/chatgptAuthTokens/refresh` server-request 를 보냄\n * - qgrid 가 DB 의 refresh_token 으로 새 access_token 을 발급받아 응답\n * - per-token inflight promise 로 concurrent refresh dedup\n * - rotation 감지: 새 refresh_token 있으면 DB 즉시 업데이트\n */\nimport { getLogger } from \"@logtape/logtape\";\n\nimport { TokenModel } from \"../../../application/token/token.model\";\nimport { type OpenAICredentials } from \"../../../application/token/token.types\";\n\nconst logger = getLogger([\"qgrid\", \"openai-refresh\"]);\n\nimport { OPENAI_CLIENT_ID, OPENAI_TOKEN_URL } from \"./openai-constants\";\n\n// per-token inflight promise dedup + minimum interval\nconst inflightRefresh = new Map<number, Promise<RefreshResult>>();\nconst lastRefreshTime = new Map<number, number>();\nconst REFRESH_MIN_INTERVAL_MS = 5_000;\n\ninterface RefreshResult {\n  accessToken: string;\n  chatgptAccountId: string;\n  chatgptPlanType?: string;\n}\n\nexport async function handleChatgptAuthTokensRefresh(tokenId: number): Promise<RefreshResult> {\n  const existing = inflightRefresh.get(tokenId);\n  if (existing) {\n    logger.info(`refresh dedup for token ${tokenId}`);\n    return existing;\n  }\n\n  const lastAt = lastRefreshTime.get(tokenId) ?? 0;\n  if (Date.now() - lastAt < REFRESH_MIN_INTERVAL_MS) {\n    logger.info(`refresh too soon for token ${tokenId}, reading current creds from DB`);\n    return readCurrentCreds(tokenId);\n  }\n\n  lastRefreshTime.set(tokenId, Date.now());\n  const promise = doRefresh(tokenId);\n  inflightRefresh.set(tokenId, promise);\n\n  try {\n    return await promise;\n  } finally {\n    inflightRefresh.delete(tokenId);\n  }\n}\n\nasync function readCurrentCreds(tokenId: number): Promise<RefreshResult> {\n  const token = await TokenModel.findOne(\"A\", { id: tokenId });\n  if (!token || token.provider !== \"openai\") throw new Error(`token ${tokenId} not found`);\n  const creds = token.credentials as OpenAICredentials;\n  return {\n    accessToken: creds.accessToken,\n    chatgptAccountId: creds.accountId,\n    chatgptPlanType: creds.planType,\n  };\n}\n\nasync function doRefresh(tokenId: number): Promise<RefreshResult> {\n  const token = await TokenModel.findOne(\"A\", { id: tokenId });\n  if (!token || token.provider !== \"openai\") {\n    throw new Error(`token ${tokenId} not found or not openai`);\n  }\n\n  const creds = token.credentials as OpenAICredentials;\n  if (!creds.refreshToken) {\n    throw new Error(`token ${tokenId} has no refreshToken`);\n  }\n\n  logger.info(`refreshing token ${token.name} (id=${tokenId})`);\n\n  const resp = await fetch(OPENAI_TOKEN_URL, {\n    method: \"POST\",\n    headers: { \"Content-Type\": \"application/x-www-form-urlencoded\" },\n    body: new URLSearchParams({\n      grant_type: \"refresh_token\",\n      client_id: OPENAI_CLIENT_ID,\n      refresh_token: creds.refreshToken,\n    }),\n  });\n\n  if (!resp.ok) {\n    const body = await resp.text().catch(() => \"\");\n    throw new Error(`OpenAI refresh failed: ${resp.status} ${body}`);\n  }\n\n  const data = (await resp.json()) as {\n    access_token: string;\n    refresh_token?: string;\n    expires_in?: number;\n    id_token?: string;\n  };\n\n  const newRefreshToken = data.refresh_token ?? creds.refreshToken;\n  const rotated =\n    data.refresh_token !== null &&\n    data.refresh_token !== undefined &&\n    data.refresh_token !== creds.refreshToken;\n  if (rotated) {\n    logger.info(`refresh_token rotated for token ${token.name}`);\n  }\n\n  const updatedCreds: OpenAICredentials = {\n    ...creds,\n    accessToken: data.access_token,\n    refreshToken: newRefreshToken,\n    accessTokenExpiresAt: data.expires_in\n      ? Date.now() + data.expires_in * 1000\n      : creds.accessTokenExpiresAt,\n    ...(data.id_token ? { idToken: data.id_token } : {}),\n  };\n\n  await TokenModel.save([\n    {\n      id: tokenId,\n      provider: \"openai\",\n      credentials: updatedCreds,\n      name: token.name,\n    },\n  ]);\n\n  logger.info(`token ${token.name} refreshed successfully`);\n\n  return {\n    accessToken: data.access_token,\n    chatgptAccountId: creds.accountId,\n    chatgptPlanType: creds.planType,\n  };\n}\n"],"mappings":";;;;;;;;;;;;;AAaA,MAAM,SAAS,UAAU,CAAC,SAAS,iBAAiB,CAAC;AAKrD,MAAM,kCAAkB,IAAI,KAAqC;AACjE,MAAM,kCAAkB,IAAI,KAAqB;AACjD,MAAM,0BAA0B;AAQhC,eAAsB,+BAA+B,SAAyC;CAC5F,MAAM,WAAW,gBAAgB,IAAI,QAAQ;AAC7C,KAAI,UAAU;AACZ,SAAO,KAAK,2BAA2B,UAAU;AACjD,SAAO;;CAGT,MAAM,SAAS,gBAAgB,IAAI,QAAQ,IAAI;AAC/C,KAAI,KAAK,KAAK,GAAG,SAAS,yBAAyB;AACjD,SAAO,KAAK,8BAA8B,QAAQ,iCAAiC;AACnF,SAAO,iBAAiB,QAAQ;;AAGlC,iBAAgB,IAAI,SAAS,KAAK,KAAK,CAAC;CACxC,MAAM,UAAU,UAAU,QAAQ;AAClC,iBAAgB,IAAI,SAAS,QAAQ;AAErC,KAAI;AACF,SAAO,MAAM;WACL;AACR,kBAAgB,OAAO,QAAQ;;;AAInC,eAAe,iBAAiB,SAAyC;CACvE,MAAM,QAAQ,MAAM,WAAW,QAAQ,KAAK,EAAE,IAAI,SAAS,CAAC;AAC5D,KAAI,CAAC,SAAS,MAAM,aAAa,SAAU,OAAM,IAAI,MAAM,SAAS,QAAQ,YAAY;CACxF,MAAM,QAAQ,MAAM;AACpB,QAAO;EACL,aAAa,MAAM;EACnB,kBAAkB,MAAM;EACxB,iBAAiB,MAAM;EACxB;;AAGH,eAAe,UAAU,SAAyC;CAChE,MAAM,QAAQ,MAAM,WAAW,QAAQ,KAAK,EAAE,IAAI,SAAS,CAAC;AAC5D,KAAI,CAAC,SAAS,MAAM,aAAa,SAC/B,OAAM,IAAI,MAAM,SAAS,QAAQ,0BAA0B;CAG7D,MAAM,QAAQ,MAAM;AACpB,KAAI,CAAC,MAAM,aACT,OAAM,IAAI,MAAM,SAAS,QAAQ,sBAAsB;AAGzD,QAAO,KAAK,oBAAoB,MAAM,KAAK,OAAO,QAAQ,GAAG;CAE7D,MAAM,OAAO,MAAM,MAAM,kBAAkB;EACzC,QAAQ;EACR,SAAS,EAAE,gBAAgB,qCAAqC;EAChE,MAAM,IAAI,gBAAgB;GACxB,YAAY;GACZ,WAAW;GACX,eAAe,MAAM;GACtB,CAAC;EACH,CAAC;AAEF,KAAI,CAAC,KAAK,IAAI;EACZ,MAAM,OAAO,MAAM,KAAK,MAAM,CAAC,YAAY,GAAG;AAC9C,QAAM,IAAI,MAAM,0BAA0B,KAAK,OAAO,GAAG,OAAO;;CAGlE,MAAM,OAAQ,MAAM,KAAK,MAAM;CAO/B,MAAM,kBAAkB,KAAK,iBAAiB,MAAM;AAKpD,KAHE,KAAK,kBAAkB,QACvB,KAAK,kBAAkB,UACvB,KAAK,kBAAkB,MAAM,aAE7B,QAAO,KAAK,mCAAmC,MAAM,OAAO;CAG9D,MAAM,eAAkC;EACtC,GAAG;EACH,aAAa,KAAK;EAClB,cAAc;EACd,sBAAsB,KAAK,aACvB,KAAK,KAAK,GAAG,KAAK,aAAa,MAC/B,MAAM;EACV,GAAI,KAAK,WAAW,EAAE,SAAS,KAAK,UAAU,GAAG,EAAE;EACpD;AAED,OAAM,WAAW,KAAK,CACpB;EACE,IAAI;EACJ,UAAU;EACV,aAAa;EACb,MAAM,MAAM;EACb,CACF,CAAC;AAEF,QAAO,KAAK,SAAS,MAAM,KAAK,yBAAyB;AAEzD,QAAO;EACL,aAAa,KAAK;EAClB,kBAAkB,MAAM;EACxB,iBAAiB,MAAM;EACxB"}

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

@@ -5,7 +5,11 @@ import { createHash, randomBytes } from "node:crypto";
 
 import { getLogger } from "@logtape/logtape";
 
-import { type UsageResponse } from "./qgrid.types";
+export type AnthropicUsageRaw = {
+  error?: string;
+  five_hour?: { utilization: number | null; resets_at: string | null } | null;
+  seven_day?: { utilization: number | null; resets_at: string | null } | null;
+};
 
 const logger = getLogger(["qgrid", "oauth"]);
 
@@ -136,10 +140,10 @@ export async function refreshAccessToken(refreshToken: string): Promise<OAuthTok
   };
 }
 
-const usageCache: Record<string, { data: UsageResponse; cachedAt: number }> = {};
+const usageCache: Record<string, { data: AnthropicUsageRaw; cachedAt: number }> = {};
 const USAGE_API_CACHE_TTL = 60_000; // 1분
 
-export async function fetchUsage(accessToken: string): Promise<UsageResponse> {
+export async function fetchUsage(accessToken: string): Promise<AnthropicUsageRaw> {
   const cacheKey = accessToken.slice(-10);
   const cached = usageCache[cacheKey];
   if (cached && Date.now() - cached.cachedAt < USAGE_API_CACHE_TTL) {
@@ -177,7 +181,7 @@ export async function fetchUsage(accessToken: string): Promise<UsageResponse> {
     return errorResult;
   }
 
-  const data = (await res.json()) as UsageResponse;
+  const data = (await res.json()) as AnthropicUsageRaw;
   // cache invalidate
   usageCache[cacheKey] = { data, cachedAt: Date.now() };
   return data;