@cartanova/qgrid-cli 1.0.0 → 1.0.2

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

@@ -0,0 +1,181 @@
+/**
+ * OAuth 유틸 — Claude Code 소스의 OAuth 플로우 그대로 재현
+ */
+import { createHash, randomBytes } from "node:crypto";
+
+import type { UsageResponse } from "./qgrid.types";
+
+const CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
+const AUTHORIZE_URL = "https://claude.com/cai/oauth/authorize";
+const TOKEN_URL = "https://platform.claude.com/v1/oauth/token";
+
+// login 시 사용 (authorize URL)
+const ALL_SCOPES = [
+  "org:create_api_key",
+  "user:profile",
+  "user:inference",
+  "user:sessions:claude_code",
+  "user:mcp_servers",
+  "user:file_upload",
+];
+
+// refresh 시 사용 (org:create_api_key 제외)
+const REFRESH_SCOPES = [
+  "user:profile",
+  "user:inference",
+  "user:sessions:claude_code",
+  "user:mcp_servers",
+  "user:file_upload",
+];
+
+function base64URLEncode(buffer: Buffer): string {
+  return buffer.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+
+export function generatePKCE(): { codeVerifier: string; codeChallenge: string; state: string } {
+  const codeVerifier = base64URLEncode(randomBytes(32));
+  const codeChallenge = base64URLEncode(createHash("sha256").update(codeVerifier).digest());
+  const state = base64URLEncode(randomBytes(32));
+  return { codeVerifier, codeChallenge, state };
+}
+
+export function buildAuthUrl(codeChallenge: string, state: string, redirectUri: string): string {
+  const url = new URL(AUTHORIZE_URL);
+  url.searchParams.append("code", "true");
+  url.searchParams.append("client_id", CLIENT_ID);
+  url.searchParams.append("response_type", "code");
+  url.searchParams.append("redirect_uri", redirectUri);
+  url.searchParams.append("scope", ALL_SCOPES.join(" "));
+  url.searchParams.append("code_challenge", codeChallenge);
+  url.searchParams.append("code_challenge_method", "S256");
+  url.searchParams.append("state", state);
+  return url.toString();
+}
+
+export type OAuthTokens = {
+  accessToken: string;
+  refreshToken: string;
+  expiresAt: number;
+  scope: string;
+  accountUuid?: string;
+  emailAddress?: string;
+};
+
+export async function exchangeCodeForTokens(
+  code: string,
+  codeVerifier: string,
+  state: string,
+  redirectUri: string,
+): Promise<OAuthTokens> {
+  const res = await fetch(TOKEN_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      grant_type: "authorization_code",
+      code,
+      redirect_uri: redirectUri,
+      client_id: CLIENT_ID,
+      code_verifier: codeVerifier,
+      state,
+    }),
+  });
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`Token exchange failed (${res.status}): ${text}`);
+  }
+
+  const data = (await res.json()) as {
+    access_token: string;
+    refresh_token: string;
+    expires_in: number;
+    scope: string;
+    account?: { uuid: string; email_address: string };
+  };
+
+  return {
+    accessToken: data.access_token,
+    refreshToken: data.refresh_token,
+    expiresAt: Date.now() + data.expires_in * 1000,
+    scope: data.scope,
+    accountUuid: data.account?.uuid,
+    emailAddress: data.account?.email_address,
+  };
+}
+
+export async function refreshAccessToken(refreshToken: string): Promise<OAuthTokens> {
+  const res = await fetch(TOKEN_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      grant_type: "refresh_token",
+      refresh_token: refreshToken,
+      client_id: CLIENT_ID,
+      scope: REFRESH_SCOPES.join(" "),
+    }),
+  });
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`Token refresh failed (${res.status}): ${text}`);
+  }
+  const data = (await res.json()) as {
+    access_token: string;
+    refresh_token: string;
+    expires_in: number;
+    scope: string;
+  };
+
+  return {
+    accessToken: data.access_token,
+    refreshToken: data.refresh_token ?? refreshToken,
+    expiresAt: Date.now() + data.expires_in * 1000,
+    scope: data.scope,
+  };
+}
+
+const usageCache: Record<string, { data: UsageResponse; cachedAt: number }> = {};
+const USAGE_API_CACHE_TTL = 60_000; // 1분
+
+export async function fetchUsage(accessToken: string): Promise<UsageResponse> {
+  const cacheKey = accessToken.slice(-10);
+  const cached = usageCache[cacheKey];
+  if (cached && Date.now() - cached.cachedAt < USAGE_API_CACHE_TTL) {
+    console.log(`[usage] cache hit: ${cacheKey}`);
+    return cached.data;
+  }
+
+  const res = await fetch("https://api.anthropic.com/api/oauth/usage", {
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+      "Content-Type": "application/json",
+      "anthropic-beta": "oauth-2025-04-20",
+    },
+    signal: AbortSignal.timeout(5000),
+  });
+  if (!res.ok) {
+    const text = await res.text();
+
+    // 파싱 시도해서 에러 메시지 추출
+    let errorMessage = `Error ${res.status}`;
+    try {
+      const parsed = JSON.parse(text);
+      errorMessage = parsed.error?.message ?? errorMessage;
+    } catch {
+      // 파싱 안 되면 기본 메시지
+    }
+
+    console.warn(`[usage] ${res.status}: ${errorMessage}`);
+
+    // 이전 성공 캐시 있으면 유지
+    if (cached?.data && !cached.data.error) return cached.data;
+
+    // 실패도 캐시 (반복 호출 방지)
+    const errorResult = { error: errorMessage };
+    usageCache[cacheKey] = { data: errorResult, cachedAt: Date.now() };
+    return errorResult;
+  }
+
+  const data = (await res.json()) as UsageResponse;
+  // cache invalidate
+  usageCache[cacheKey] = { data, cachedAt: Date.now() };
+  return data;
+}

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;
+}