@cartanova/qgrid-cli 1.0.1 → 1.0.3

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

@@ -0,0 +1,132 @@
+/**
+ * ClaudePool — 멀티 토큰 프로세스 풀.
+ *
+ * 2-layer 아키텍처: ClaudePool → Worker (flat)
+ * - Map<token, Worker[]>로 토큰별 워커 관리 (원본 토큰이 키)
+ * - least-queue-depth 라우팅
+ * - 투명한 쿼터 failover (QuotaError 시 다른 토큰으로 자동 재시도)
+ * - 워커 관리만 담당 (DB 의존 없음)
+ */
+import type { CliResult, PoolConfig, QueryInput, TokenStats } from "./qgrid.types";
+import { QuotaError } from "./qgrid.types";
+import { Worker, type WorkerConfig } from "./worker";
+
+export class ClaudePool {
+  workers = new Map<string, Worker[]>();
+  quotaExhausted = new Set<string>();
+  requestCounts = new Map<string, number>();
+  lastUsedToken = "";
+  size: number;
+  model: string;
+  timeout: number;
+  cwd: string;
+  maxCalls: number;
+
+  constructor(config: PoolConfig) {
+    this.size = config.size ?? 3;
+    this.model = config.model ?? "sonnet";
+    this.timeout = config.timeout ?? 300_000;
+    this.cwd = config.cwd ?? "/tmp/qgrid";
+    this.maxCalls = config.maxCalls ?? 500;
+
+    config.tokens.forEach((token) => {
+      this.createWorkers(token);
+    });
+  }
+
+  getStats(tokenNames?: Map<string, string>): TokenStats[] {
+    return [...this.workers.keys()].map((token) => ({
+      token,
+      name: tokenNames?.get(token) ?? "Unknown Key",
+      requests: this.requestCounts.get(token) ?? 0,
+      active: !this.quotaExhausted.has(token),
+    }));
+  }
+
+  selectWorker(): Worker | null {
+    const candidates = [...this.workers.entries()]
+      .filter(([token]) => !this.quotaExhausted.has(token))
+      .flatMap(([, workers]) => workers);
+
+    if (candidates.length === 0) return null;
+
+    return candidates.reduce((best, w) => (w.getQueueDepth() < best.getQueueDepth() ? w : best));
+  }
+
+  async query(input: QueryInput, timeoutMs?: number): Promise<CliResult> {
+    const triedTokens = new Set<string>();
+
+    while (true) {
+      const worker = this.selectWorker();
+      if (!worker) {
+        throw new QuotaError("All tokens exhausted");
+      }
+
+      if (triedTokens.has(worker.tokenId)) {
+        throw new QuotaError("All tokens exhausted");
+      }
+
+      try {
+        const result = await worker.query(input, timeoutMs);
+        this.lastUsedToken = worker.tokenId;
+        this.requestCounts.set(worker.tokenId, (this.requestCounts.get(worker.tokenId) ?? 0) + 1);
+
+        return result;
+      } catch (err) {
+        if (err instanceof QuotaError) {
+          this.quotaExhausted.add(worker.tokenId);
+          triedTokens.add(worker.tokenId);
+          continue;
+        }
+        throw err;
+      }
+    }
+  }
+
+  kill(): void {
+    [...this.workers.values()].flat().forEach((w) => {
+      w.kill();
+    });
+  }
+
+  createWorkers(token: string): void {
+    if (this.workers.has(token)) return;
+
+    const workerConfig: WorkerConfig = {
+      token,
+      model: this.model,
+      timeout: this.timeout,
+      cwd: this.cwd,
+      maxCalls: this.maxCalls,
+    };
+
+    const workers = Array.from({ length: this.size }, () => new Worker(workerConfig));
+    this.workers.set(token, workers);
+    this.requestCounts.set(token, 0);
+  }
+
+  destroyWorkers(token: string): void {
+    const workers = this.workers.get(token);
+    if (!workers) return;
+
+    workers.forEach((w) => {
+      w.kill();
+    });
+    this.workers.delete(token);
+    this.quotaExhausted.delete(token);
+    this.requestCounts.delete(token);
+  }
+}
+
+// Pool 싱글턴 관리
+let pool: ClaudePool | null = null;
+
+export function initPool(tokens: string[]): ClaudePool {
+  pool = new ClaudePool({ tokens });
+  return pool;
+}
+
+export function getPool(): ClaudePool {
+  if (!pool) throw new Error("Pool not initialized. Call initPool() first.");
+  return pool;
+}

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

@@ -0,0 +1,275 @@
+import type { FastifyReply } from "fastify";
+import { api, BaseFrameClass } from "sonamu";
+
+import { RequestLogModel } from "../request-log/request-log.model";
+import { TokenModel } from "../token/token.model";
+import type { RefreshTokenParams } from "../token/token.types";
+import {
+  buildAuthUrl,
+  exchangeCodeForTokens,
+  fetchUsage,
+  generatePKCE,
+  refreshAccessToken,
+} from "./oauth";
+import { type ClaudePool, getPool } from "./pool";
+import type {
+  CliResult,
+  HealthResponse,
+  OAuthStartResult,
+  TokenStats,
+  UsageResponse,
+} from "./qgrid.types";
+
+// PKCE 세션 메모리 저장 (state → { codeVerifier, name, redirectUri })
+const pendingOAuth = new Map<string, { codeVerifier: string; name: string; redirectUri: string }>();
+
+class QgridFrameClass extends BaseFrameClass {
+  constructor() {
+    super("Qgrid");
+  }
+
+  @api({ httpMethod: "POST", clients: ["axios", "tanstack-mutation"] })
+  async query(prompt: string, system?: string, timeout?: number): Promise<CliResult> {
+    const pool = getPool();
+    const result = await pool.query({ system, prompt }, timeout);
+
+    // 로그 기록 실패해도 쿼리 결과는 반환
+    TokenModel.findByToken("A", pool.lastUsedToken)
+      .then((tokenEntry) => {
+        RequestLogModel.save([
+          {
+            token_name: tokenEntry?.name ?? "Unknown Key",
+            query: system ? `[System]\n${system}\n\n[User]\n${prompt}` : prompt,
+            response: result.text,
+            input_tokens: result.usage.input_tokens,
+            output_tokens: result.usage.output_tokens,
+            cache_read_tokens: result.usage.cache_read_input_tokens,
+            cache_creation_tokens: result.usage.cache_creation_input_tokens,
+            duration_ms: result.durationMs,
+          },
+        ]);
+      })
+      .catch((e) => console.error("requestLog save failed:", e));
+
+    return result;
+  }
+
+  @api({ httpMethod: "GET", clients: ["axios", "tanstack-query"] })
+  async stats(): Promise<TokenStats[]> {
+    const pool = getPool();
+    const entries = await TokenModel.findActive("A");
+    const tokenNames = new Map(entries.map((e) => [e.token, e.name]));
+    return pool.getStats(tokenNames);
+  }
+
+  @api({ httpMethod: "POST", clients: ["axios", "tanstack-mutation"] })
+  async addToken(token: string, name: string, refreshToken?: string): Promise<{ added: boolean }> {
+    await TokenModel.save([
+      {
+        token,
+        name,
+        ...(refreshToken && refreshToken.length > 0 ? { refresh_token: refreshToken } : {}),
+      },
+    ]);
+    getPool().createWorkers(token);
+    return { added: true };
+  }
+
+  @api({ httpMethod: "POST", clients: ["axios", "tanstack-mutation"] })
+  async updateToken(
+    token: string,
+    name?: string,
+    newToken?: string,
+    refreshToken?: string,
+  ): Promise<{ updated: boolean }> {
+    const pool = getPool();
+    const entry = await TokenModel.findByToken("A", token);
+    if (!entry) return { updated: false };
+
+    const hasNewToken = newToken !== undefined && newToken.length > 0;
+    const hasRefreshToken = refreshToken !== undefined && refreshToken.length > 0;
+    await TokenModel.save([
+      {
+        id: entry.id,
+        token: hasNewToken ? newToken : entry.token,
+        name: name !== undefined ? name : entry.name,
+        ...(hasRefreshToken ? { refresh_token: refreshToken } : {}),
+      },
+    ]);
+
+    if (hasNewToken) {
+      pool.destroyWorkers(token);
+      pool.createWorkers(newToken);
+    }
+    return { updated: true };
+  }
+
+  @api({ httpMethod: "POST", clients: ["axios", "tanstack-mutation"] })
+  async removeToken(token: string): Promise<{ removed: boolean }> {
+    const pool = getPool();
+    if (!pool.workers.has(token)) return { removed: false };
+
+    const entry = await TokenModel.findByToken("A", token);
+    if (entry) await TokenModel.del([entry.id]);
+    pool.destroyWorkers(token);
+    return { removed: true };
+  }
+
+  /**
+   *
+   * @param id token_id
+   * 토큰 활성화/비활성화 토글 (pool 워커 생성/제거 & DB의 active 필드 업데이트)
+   *
+   * @returns 토큰 활성화 여부
+   */
+  @api({ httpMethod: "POST", clients: ["axios", "tanstack-mutation"] })
+  async toggleToken(id: number): Promise<{ active: boolean }> {
+    const pool = getPool();
+    const entry = await TokenModel.findOne("A", { id });
+    if (!entry) return { active: false };
+
+    const newActive = !entry.active;
+    await TokenModel.save([{ id, token: entry.token, active: newActive, name: entry.name }]);
+
+    // 토큰의 새로운 상태가 활성화면/비활성화면
+    if (newActive) {
+      // 워커 생성
+      pool.createWorkers(entry.token);
+    } else {
+      // 워커 제거
+      pool.destroyWorkers(entry.token);
+    }
+
+    return { active: newActive };
+  }
+
+  // OAuth 로그인: authUrl 생성 (프론트에서 이 API 호출 후 authUrl로 리다이렉트)
+  @api({ httpMethod: "POST", clients: ["axios", "tanstack-mutation"] })
+  async oauthStart(name: string): Promise<OAuthStartResult> {
+    const { codeVerifier, codeChallenge, state } = generatePKCE();
+
+    const serverPort = process.env.PORT ?? "44900";
+    const redirectUri = `http://localhost:${serverPort}/callback`;
+    const authUrl = buildAuthUrl(codeChallenge, state, redirectUri);
+
+    // PKCE를 메모리에 저장 (5분 TTL)
+    pendingOAuth.set(state, { codeVerifier, name, redirectUri });
+    setTimeout(() => pendingOAuth.delete(state), 300_000);
+
+    return { authUrl };
+  }
+
+  // OAuth 콜백 처리 — sonamu.config.ts의 custom 라우트에서 호출됨
+  async handleOAuthCallback(code: string, state: string, reply: FastifyReply): Promise<void> {
+    const pool = getPool();
+    const pending = pendingOAuth.get(state);
+    if (!pending) {
+      return reply.redirect("/?oauth=error&reason=invalid_state");
+    }
+    pendingOAuth.delete(state);
+
+    try {
+      const tokens = await exchangeCodeForTokens(
+        code,
+        pending.codeVerifier,
+        state,
+        pending.redirectUri,
+      );
+
+      // 같은 계정의 이전 토큰이 있으면 교체
+      if (tokens.accountUuid) {
+        const oldEntries = await TokenModel.findByAccountUuid("A", tokens.accountUuid);
+        for (const old of oldEntries) {
+          pool.destroyWorkers(old.token);
+          await TokenModel.del([old.id]);
+        }
+      }
+
+      // 새 토큰 저장 + pool에 등록
+      await TokenModel.save([
+        {
+          token: tokens.accessToken,
+          name: pending.name,
+          refresh_token: tokens.refreshToken,
+          expires_at: tokens.expiresAt ? BigInt(tokens.expiresAt) : null,
+          account_uuid: tokens.accountUuid,
+        },
+      ]);
+      pool.createWorkers(tokens.accessToken);
+
+      return reply.redirect(`/?oauth=success&name=${encodeURIComponent(pending.name)}`);
+    } catch (e) {
+      return reply.redirect(`/?oauth=error&reason=${encodeURIComponent((e as Error).message)}`);
+    }
+  }
+
+  // 토큰 사용량 조회 (OAuth usage API)
+  @api({ httpMethod: "GET", clients: ["axios", "tanstack-query"] })
+  async usage(tokenName?: string): Promise<UsageResponse> {
+    const pool = getPool();
+    const { rows: allTokens } = await TokenModel.findMany("A");
+    const entry = tokenName
+      ? allTokens.find((e) => e.name === tokenName)
+      : allTokens.findLast((e) => e.active);
+
+    if (!entry) return { error: "NOT_FOUND" };
+
+    // 만료 확인 + refresh 시도
+    let accessToken = entry.token;
+    const isExpired = entry.expires_at && Number(entry.expires_at) < Date.now();
+
+    if (isExpired && entry.refresh_token) {
+      try {
+        accessToken = await this.refreshToken(pool, entry);
+      } catch (e) {
+        console.warn(`[usage] refresh failed for ${entry.name}: ${(e as Error).message}`);
+        return { error: "re-login required" };
+      }
+    }
+
+    // usage 호출
+    const result = await fetchUsage(accessToken);
+
+    // 인증 에러면 refresh_token으로 재시도
+    if (result.error && entry.refresh_token) {
+      try {
+        accessToken = await this.refreshToken(pool, entry);
+        return await fetchUsage(accessToken);
+      } catch (e) {
+        console.warn(`[usage] refresh failed for ${entry.name}: ${(e as Error).message}`);
+        return { error: "re-login required" };
+      }
+    }
+
+    return result;
+  }
+
+  async refreshToken(pool: ClaudePool, token: RefreshTokenParams): Promise<string> {
+    if (!token.refresh_token) throw new Error("No refresh token");
+    const refreshed = await refreshAccessToken(token.refresh_token);
+    await TokenModel.save([
+      {
+        id: token.id,
+        token: refreshed.accessToken,
+        refresh_token: refreshed.refreshToken,
+        expires_at: BigInt(refreshed.expiresAt),
+        name: token.name ?? "",
+      },
+    ]);
+    pool.destroyWorkers(token.token);
+    pool.createWorkers(refreshed.accessToken);
+    return refreshed.accessToken;
+  }
+
+  @api({ httpMethod: "GET", clients: ["axios", "tanstack-query"] })
+  async health(): Promise<HealthResponse> {
+    const pool = getPool();
+    return {
+      status: "ok",
+      workers: [...pool.workers.values()].flat().length,
+      activeTokens: pool.workers.size - pool.quotaExhausted.size,
+    };
+  }
+}
+
+export const QgridFrame = new QgridFrameClass();

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

@@ -0,0 +1,117 @@
+import { z } from "zod";
+
+// ─── Query ───
+
+export const QueryInput = z.object({
+  system: z.string().optional(),
+  prompt: z.string(),
+  timeout: z.number().optional(),
+});
+export type QueryInput = z.infer<typeof QueryInput>;
+
+export const CliResult = z.object({
+  text: z.string(),
+  usage: z.object({
+    input_tokens: z.number(),
+    output_tokens: z.number(),
+    cache_creation_input_tokens: z.number(),
+    cache_read_input_tokens: z.number(),
+  }),
+  durationMs: z.number(),
+  costUsd: z.number(),
+});
+export type CliResult = z.infer<typeof CliResult>;
+
+// ─── Pool Config ───
+
+export const PoolConfig = z.object({
+  tokens: z.array(z.string()),
+  size: z.number().optional(),
+  model: z.string().optional(),
+  timeout: z.number().optional(),
+  cwd: z.string().optional(),
+  maxCalls: z.number().optional(),
+});
+export type PoolConfig = z.infer<typeof PoolConfig>;
+
+// ─── Token Management ───
+
+export const AddTokenInput = z.object({
+  token: z.string(),
+  name: z.string(),
+});
+export type AddTokenInput = z.infer<typeof AddTokenInput>;
+
+export const RemoveTokenInput = z.object({
+  token: z.string(),
+});
+export type RemoveTokenInput = z.infer<typeof RemoveTokenInput>;
+
+export const TokenStats = z.object({
+  token: z.string(),
+  name: z.string(),
+  requests: z.number(),
+  active: z.boolean(),
+});
+export type TokenStats = z.infer<typeof TokenStats>;
+
+// ─── OAuth ───
+
+export const OAuthStartResult = z.object({
+  authUrl: z.string(),
+});
+export type OAuthStartResult = z.infer<typeof OAuthStartResult>;
+
+const RateLimit = z
+  .object({
+    utilization: z.number().nullable(),
+    resets_at: z.string().nullable(),
+  })
+  .nullable();
+
+export const UsageResponse = z.object({
+  error: z.string().optional(),
+  five_hour: RateLimit.optional(),
+  seven_day: RateLimit.optional(),
+  seven_day_opus: RateLimit.optional(),
+  seven_day_sonnet: RateLimit.optional(),
+  seven_day_oauth_apps: RateLimit.optional(),
+  seven_day_cowork: RateLimit.optional(),
+  extra_usage: z
+    .object({
+      is_enabled: z.boolean(),
+      monthly_limit: z.number().nullable(),
+      used_credits: z.number().nullable(),
+      utilization: z.number().nullable(),
+    })
+    .nullable()
+    .optional(),
+});
+export type UsageResponse = z.infer<typeof UsageResponse>;
+
+// ─── Health ───
+
+export const HealthResponse = z.object({
+  status: z.string(),
+  workers: z.number(),
+  activeTokens: z.number(),
+});
+export type HealthResponse = z.infer<typeof HealthResponse>;
+
+// ─── Errors ───
+
+export class QuotaError extends Error {
+  readonly code = "QUOTA_EXHAUSTED" as const;
+}
+export class TimeoutError extends Error {
+  readonly code = "TIMEOUT" as const;
+}
+export class ProcessError extends Error {
+  readonly code = "PROCESS_ERROR" as const;
+}
+
+// ─── Utils ───
+
+export function maskToken(token: string): string {
+  return token.length > 4 ? `...${token.slice(-4)}` : token;
+}