@cartanova/qgrid-cli 1.9.0 → 2.0.1

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

@@ -1,28 +1,77 @@
+import crypto from "node:crypto";
+
 import { getLogger } from "@logtape/logtape";
 import { type FastifyReply } from "fastify";
-import { api, BaseFrameClass } from "sonamu";
+import { api, BaseFrameClass, Sonamu, stream } from "sonamu";
+import { getCacheManagerRef } from "sonamu/cache";
 
+import {
+  getAccessToken,
+  getExpiresAt,
+  getRefreshToken,
+} from "../../utils/providers/common/credentials";
 import { MICRO_USD, RequestLogModel } from "../request-log/request-log.model";
+import { type TokenSubsetA } from "../sonamu.generated";
 import { TokenModel } from "../token/token.model";
-import { type RefreshTokenParams } from "../token/token.types";
+import { TokenCredentials } from "../token/token.types";
 import {
+  type AnthropicUsageRaw,
   buildAuthUrl,
   exchangeCodeForTokens,
   fetchUsage,
   generatePKCE,
   refreshAccessToken,
 } from "./oauth";
+import {
+  afterQuery,
+  beforeQuery,
+  finishRunAborted,
+  finishRunWithError,
+} from "./qgrid-run-lifecycle";
 import { QgridDispatcher } from "./qgrid.dispatcher";
 import {
-  type CliResult,
-  type Effort,
+  type QueryInput,
+  type AppendStepInput,
+  type CreateRunInput,
+  type FinishRunInput,
   type HealthResponse,
   type OAuthStartResult,
+  type QueryOutput,
+  StreamEvents,
   type TokenStats,
   type UsageResponse,
 } from "./qgrid.types";
 
-const pendingOAuth = new Map<string, { codeVerifier: string; name: string; redirectUri: string }>();
+const pendingStreams = new Map<string, QueryInput>();
+
+type PendingOAuth = { codeVerifier: string; name: string; redirectUri: string };
+const OAUTH_STATE_PREFIX = "oauth:state:";
+const OAUTH_STATE_TTL = "5m";
+
+async function setOAuthState(state: string, data: PendingOAuth): Promise<void> {
+  const cache = getCacheManagerRef();
+  if (!cache) throw new Error("CacheManager not initialized");
+  await cache.set({
+    key: `${OAUTH_STATE_PREFIX}${state}`,
+    value: JSON.stringify(data),
+    ttl: OAUTH_STATE_TTL,
+  });
+}
+
+async function getOAuthState(state: string): Promise<PendingOAuth | undefined> {
+  const cache = getCacheManagerRef();
+  if (!cache) throw new Error("CacheManager not initialized");
+  const raw = await cache.get<string>({ key: `${OAUTH_STATE_PREFIX}${state}` });
+  if (!raw) return undefined;
+  return JSON.parse(raw) as PendingOAuth;
+}
+
+async function deleteOAuthState(state: string): Promise<void> {
+  const cache = getCacheManagerRef();
+  if (!cache) return;
+  await cache.delete({ key: `${OAUTH_STATE_PREFIX}${state}` });
+}
+
 const logger = getLogger(["qgrid"]);
 const oauthLogger = getLogger(["qgrid", "oauth"]);
 
@@ -32,40 +81,204 @@ class QgridFrameClass extends BaseFrameClass {
   }
 
   @api({ httpMethod: "POST", clients: ["axios", "tanstack-mutation"] })
-  async query(
-    prompt: string,
-    system?: string,
-    timeout?: number,
-    model?: string,
-    projectName?: string,
-    jsonSchema?: string,
-    effort?: Effort,
-  ): Promise<CliResult> {
-    const result = await QgridDispatcher.query(
-      { system, prompt, model, jsonSchema, effort },
-      timeout,
-    );
-
-    RequestLogModel.save([
-      {
-        token_name: result.tokenName,
-        project_name: projectName && projectName.length > 0 ? projectName : null,
-        model_name: result.model ?? null,
-        user_prompt: prompt,
-        system_prompt: system ?? null,
-        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,
-        cost_usd: result.costUsd !== null ? Math.round(result.costUsd * MICRO_USD) : null,
-      },
-    ]).catch((e) => logger.error(`requestLog save failed: ${(e as Error).message}`));
+  async query(args: QueryInput): Promise<QueryOutput> {
+    const effectiveLogMode = args.logMode ?? (args.isStep ? "run" : "auto");
+
+    // logMode: "run" → 서버가 lifecycle 관리
+    if (effectiveLogMode === "run") {
+      const { requestLogId, stepIndex } = await beforeQuery(args);
+      try {
+        const result = await QgridDispatcher.query(args, args.timeout);
+        const lifecycle = await afterQuery(requestLogId, stepIndex, args, result);
+        return { ...result, runContext: lifecycle.runContext };
+      } catch (e) {
+        await finishRunWithError(requestLogId, (e as Error).message, args);
+        throw e;
+      }
+    }
+
+    // logMode: "auto" (기존 non-step 경로) 또는 "none"
+    const result = await QgridDispatcher.query(args, args.timeout);
+
+    if (effectiveLogMode === "auto") {
+      const toolCallCount = result.content.filter((item) => item.type === "tool-call").length;
+      const responseText = result.content
+        .filter((item) => item.type === "text")
+        .map((item) => item.text)
+        .join("\n");
+
+      RequestLogModel.save([
+        {
+          token_name: result.tokenName,
+          project_name: args.projectName?.length ? args.projectName : null,
+          model_name: result.model ?? null,
+          user_prompt: args.prompt,
+          system_prompt: args.system ?? null,
+          response: responseText,
+          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,
+          cost_usd: result.costUsd !== null ? Math.round(result.costUsd * MICRO_USD) : null,
+          effort: args.effort ?? null,
+          history: args.history ? JSON.parse(args.history) : null,
+          status: "succeeded",
+          tool_call_count: toolCallCount,
+        },
+      ]).catch((e) => logger.error(`requestLog save failed: ${(e as Error).message}`));
+    }
 
     return result;
   }
 
+  @api({ httpMethod: "POST", clients: ["axios", "tanstack-mutation"] })
+  async prepareStream(args: QueryInput): Promise<{ streamId: string }> {
+    const streamId = crypto.randomUUID();
+    pendingStreams.set(streamId, args);
+    setTimeout(() => pendingStreams.delete(streamId), 30_000);
+    return { streamId };
+  }
+
+  @stream({ type: "sse", events: StreamEvents })
+  async queryStream(streamId: string): Promise<void> {
+    const args = pendingStreams.get(streamId);
+    pendingStreams.delete(streamId);
+    if (!args) throw new Error("invalid or expired streamId");
+
+    const effectiveLogMode = args.logMode ?? (args.isStep ? "run" : "auto");
+    const shouldLog = effectiveLogMode === "run";
+
+    let runInfo: { requestLogId: number; stepIndex: number } | undefined;
+    if (shouldLog) {
+      try {
+        runInfo = await beforeQuery(args);
+      } catch (e) {
+        logger.error(`stream beforeQuery failed: ${(e as Error).message}`);
+      }
+    }
+
+    const ctx = Sonamu.getContext();
+    const sse = ctx.createSSE(StreamEvents);
+    let threadId: string | undefined;
+    let turnId: string | undefined;
+    let streamResult: QueryOutput | undefined;
+    let streamError: Error | undefined;
+
+    sse.onClose(() => {
+      if (threadId && turnId) {
+        QgridDispatcher.openaiDispatcher?.interruptWorkerTurn(threadId, turnId).catch(() => {});
+      }
+    });
+
+    try {
+      await QgridDispatcher.queryStream(args, {
+        onDelta: (text) => {
+          if (!sse.closed) sse.publish("delta", { text });
+        },
+        onThreadId: (id) => {
+          threadId = id;
+          if (sse.closed && turnId) {
+            QgridDispatcher.openaiDispatcher?.interruptWorkerTurn(threadId, turnId).catch(() => {});
+          }
+        },
+        onTurnId: (id) => {
+          turnId = id;
+          if (sse.closed && threadId) {
+            QgridDispatcher.openaiDispatcher?.interruptWorkerTurn(threadId, turnId).catch(() => {});
+          }
+        },
+        onComplete: (result) => {
+          streamResult = result;
+        },
+        onError: (err) => {
+          streamError = err;
+        },
+      });
+    } catch (e) {
+      streamError = e as Error;
+    }
+
+    // dispatcher 완료 후 lifecycle 처리 (await 안전)
+    if (streamResult) {
+      let runContext: { requestLogId: number } | undefined;
+      if (runInfo) {
+        try {
+          const lifecycle = await afterQuery(
+            runInfo.requestLogId,
+            runInfo.stepIndex,
+            args,
+            streamResult,
+          );
+          runContext = lifecycle.runContext;
+        } catch (e) {
+          logger.error(`stream afterQuery failed: ${(e as Error).message}`);
+        }
+      }
+      if (!sse.closed) sse.publish("done", { ...streamResult, runContext });
+    } else if (streamError) {
+      if (runInfo) await finishRunWithError(runInfo.requestLogId, streamError.message, args);
+      if (!sse.closed) sse.publish("error", { message: streamError.message });
+    } else if (sse.closed && runInfo) {
+      await finishRunAborted(runInfo.requestLogId, args);
+    }
+
+    await sse.end();
+  }
+
+  @api({ httpMethod: "POST", clients: ["axios", "tanstack-mutation"] })
+  async createRun(input: CreateRunInput): Promise<{ requestLogId: number }> {
+    const requestLogId = await RequestLogModel.createRun({
+      user_prompt: input.userPrompt,
+      model_name: input.modelName,
+      effort: input.effort,
+      project_name: input.projectName,
+      system_prompt: input.systemPrompt,
+    });
+    return { requestLogId };
+  }
+
+  @api({ httpMethod: "POST", clients: ["axios", "tanstack-mutation"] })
+  async appendStep(input: AppendStepInput): Promise<{ stepId: number }> {
+    const stepId = await RequestLogModel.appendStep(input.requestLogId, {
+      step_index: input.stepIndex,
+      type: input.type,
+      input_tokens: input.inputTokens,
+      output_tokens: input.outputTokens,
+      cache_read_tokens: input.cacheReadTokens,
+      cache_creation_tokens: input.cacheCreationTokens,
+      duration_ms: input.durationMs,
+      finish_reason: input.finishReason,
+      reasoning_text: input.reasoningText,
+      reasoning_tokens: input.reasoningTokens,
+      tool_call_index: input.toolCallIndex,
+      tool_call_id: input.toolCallId,
+      tool_name: input.toolName,
+      tool_args: input.toolArgs,
+      tool_result: input.toolResult,
+      tool_duration_ms: input.toolDurationMs,
+      error: input.error,
+    });
+    return { stepId };
+  }
+
+  @api({ httpMethod: "POST", clients: ["axios", "tanstack-mutation"] })
+  async finishRun(input: FinishRunInput): Promise<{ ok: boolean }> {
+    await RequestLogModel.finishRun(input.requestLogId, {
+      status: input.status,
+      response: input.response,
+      token_name: input.tokenName,
+      input_tokens: input.totalInputTokens,
+      output_tokens: input.totalOutputTokens,
+      cache_read_tokens: input.totalCacheReadTokens,
+      cache_creation_tokens: input.totalCacheCreationTokens,
+      duration_ms: input.totalDurationMs,
+      history: input.history ? JSON.parse(input.history) : undefined,
+      error_message: input.errorMessage,
+    });
+    return { ok: true };
+  }
+
   @api({ httpMethod: "GET", clients: ["axios", "tanstack-query"] })
   async stats(): Promise<TokenStats[]> {
     return QgridDispatcher.getStats();
@@ -82,43 +295,40 @@ class QgridFrameClass extends BaseFrameClass {
   }
 
   @api({ httpMethod: "POST", clients: ["axios", "tanstack-mutation"] })
-  async addToken(token: string, name: string, refreshToken?: string): Promise<{ added: boolean }> {
+  async addToken(
+    provider: string,
+    credentials: TokenCredentials,
+    name: string,
+  ): Promise<{ added: boolean }> {
     await TokenModel.save([
       {
-        token,
+        provider,
+        credentials,
         name,
-        ...(refreshToken && refreshToken.length > 0 ? { refresh_token: refreshToken } : {}),
       },
     ]);
     return { added: true };
   }
 
   @api({ httpMethod: "POST", clients: ["axios", "tanstack-mutation"] })
-  async updateToken(
-    token: string,
-    name?: string,
-    newToken?: string,
-    refreshToken?: string,
-  ): Promise<{ updated: boolean }> {
-    const entry = await TokenModel.findByToken("A", token);
+  async updateToken(id: number, name?: string): Promise<{ updated: boolean }> {
+    const entry = await TokenModel.findOne("A", { id });
     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,
+        provider: entry.provider,
+        credentials: entry.credentials,
         name: name !== undefined ? name : entry.name,
-        ...(hasRefreshToken ? { refresh_token: refreshToken } : {}),
       },
     ]);
     return { updated: true };
   }
 
   @api({ httpMethod: "POST", clients: ["axios", "tanstack-mutation"] })
-  async removeToken(token: string): Promise<{ removed: boolean }> {
-    const entry = await TokenModel.findByToken("A", token);
+  async removeToken(id: number): Promise<{ removed: boolean }> {
+    const entry = await TokenModel.findOne("A", { id });
     if (!entry) return { removed: false };
     await TokenModel.del([entry.id]);
     return { removed: true };
@@ -133,7 +343,15 @@ class QgridFrameClass extends BaseFrameClass {
     if (!entry) return { active: false };
 
     const newActive = !entry.active;
-    await TokenModel.save([{ id, token: entry.token, active: newActive, name: entry.name }]);
+    await TokenModel.save([
+      {
+        id,
+        provider: entry.provider,
+        credentials: entry.credentials,
+        active: newActive,
+        name: entry.name,
+      },
+    ]);
     return { active: newActive };
   }
 
@@ -145,18 +363,18 @@ class QgridFrameClass extends BaseFrameClass {
     const redirectUri = `http://localhost:${serverPort}/callback`;
     const authUrl = buildAuthUrl(codeChallenge, state, redirectUri);
 
-    pendingOAuth.set(state, { codeVerifier, name, redirectUri });
-    setTimeout(() => pendingOAuth.delete(state), 300_000);
+    await setOAuthState(state, { codeVerifier, name, redirectUri });
 
     return { authUrl };
   }
 
   async handleOAuthCallback(code: string, state: string, reply: FastifyReply): Promise<void> {
-    const pending = pendingOAuth.get(state);
+    const pending = await getOAuthState(state);
     if (!pending) {
+      logger.warn("oauth callback: invalid_state");
       return reply.redirect("/?oauth=error&reason=invalid_state");
     }
-    pendingOAuth.delete(state);
+    await deleteOAuthState(state);
 
     try {
       const tokens = await exchangeCodeForTokens(
@@ -167,7 +385,11 @@ class QgridFrameClass extends BaseFrameClass {
       );
 
       if (tokens.accountUuid) {
-        const oldEntries = await TokenModel.findByAccountUuid("A", tokens.accountUuid);
+        const oldEntries = await TokenModel.findByAccountIdentifier(
+          "A",
+          "anthropic",
+          tokens.accountUuid,
+        );
         if (oldEntries.length > 0) {
           await TokenModel.del(oldEntries.map((o) => o.id));
         }
@@ -175,11 +397,14 @@ class QgridFrameClass extends BaseFrameClass {
 
       await TokenModel.save([
         {
-          token: tokens.accessToken,
+          provider: "anthropic",
+          credentials: {
+            accessToken: tokens.accessToken,
+            refreshToken: tokens.refreshToken,
+            expiresAt: tokens.expiresAt ?? 0,
+            accountUuid: tokens.accountUuid ?? "",
+          },
           name: pending.name,
-          refresh_token: tokens.refreshToken,
-          expires_at: tokens.expiresAt ? BigInt(tokens.expiresAt) : null,
-          account_uuid: tokens.accountUuid,
         },
       ]);
 
@@ -189,19 +414,93 @@ class QgridFrameClass extends BaseFrameClass {
     }
   }
 
+  @api({ httpMethod: "POST", clients: ["axios", "tanstack-mutation"] })
+  async oauthStartOpenAI(name: string): Promise<OAuthStartResult> {
+    if (!QgridDispatcher.openaiDispatcher) throw new Error("OpenAI dispatcher not initialized");
+    const { authUrl } = await QgridDispatcher.openaiDispatcher.startBrowserLogin(name);
+
+    // fire-and-forget: codex login 완료 대기 → 토큰 저장
+    QgridDispatcher.openaiDispatcher
+      .completeBrowserLogin()
+      .then(async (creds) => {
+        if (creds.accountId) {
+          const oldEntries = await TokenModel.findByAccountIdentifier(
+            "A",
+            "openai",
+            creds.accountId,
+          );
+          if (oldEntries.length > 0) {
+            await TokenModel.del(oldEntries.map((o) => o.id));
+          }
+        }
+        await TokenModel.save([
+          {
+            provider: "openai",
+            credentials: {
+              accessToken: creds.accessToken,
+              refreshToken: creds.refreshToken,
+              idToken: creds.idToken,
+              accessTokenExpiresAt: Date.now() + 10 * 24 * 3600 * 1000,
+              accountId: creds.accountId,
+            },
+            name,
+          },
+        ]);
+        logger.info(`OpenAI token saved for ${name}`);
+      })
+      .catch((e) => {
+        logger.warn(`OpenAI browser login failed: ${(e as Error).message}`);
+      });
+
+    return { authUrl };
+  }
+
   @api({ httpMethod: "GET", clients: ["axios", "tanstack-query"] })
-  async usage(tokenName?: string): Promise<UsageResponse> {
+  async usage(tokenId?: number): Promise<UsageResponse> {
     const { rows: allTokens } = await TokenModel.findMany("A");
-    const entry = tokenName
-      ? allTokens.find((e) => e.name === tokenName)
-      : allTokens.findLast((e) => e.active);
+    const entry = tokenId
+      ? allTokens.find((e) => e.id === tokenId)
+      : allTokens.findLast((e) => e.active && e.provider === "anthropic");
 
     if (!entry) return { error: "NOT_FOUND" };
 
-    let accessToken = entry.token;
-    const isExpired = entry.expires_at && Number(entry.expires_at) < Date.now();
+    if (entry.provider === "openai") {
+      try {
+        const raw = (await QgridDispatcher.openaiDispatcher?.getRateLimits(entry.name)) as {
+          rateLimits?: {
+            primary?: { usedPercent: number; windowDurationMins: number; resetsAt: number };
+            secondary?: { usedPercent: number; windowDurationMins: number; resetsAt: number };
+          };
+        };
+        const rl = raw?.rateLimits;
+        return {
+          provider: "openai",
+          fiveHour: rl?.primary
+            ? {
+                utilization: rl.primary.usedPercent,
+                resetsAt: new Date(rl.primary.resetsAt * 1000).toISOString(),
+              }
+            : null,
+          sevenDay: rl?.secondary
+            ? {
+                utilization: rl.secondary.usedPercent,
+                resetsAt: new Date(rl.secondary.resetsAt * 1000).toISOString(),
+              }
+            : null,
+        };
+      } catch (e) {
+        return { error: `OpenAI usage failed: ${(e as Error).message}` };
+      }
+    }
+
+    if (entry.provider !== "anthropic") {
+      return { error: `usage API not supported for provider: ${entry.provider}` };
+    }
+
+    let accessToken = getAccessToken(entry.credentials);
+    const isExpired = getExpiresAt(entry.credentials) < Date.now();
 
-    if (isExpired && entry.refresh_token) {
+    if (isExpired && getRefreshToken(entry.credentials)) {
       try {
         accessToken = await this.refreshToken(entry);
       } catch (e) {
@@ -210,31 +509,39 @@ class QgridFrameClass extends BaseFrameClass {
       }
     }
 
-    const result = await fetchUsage(accessToken);
-
-    if (result.error && entry.refresh_token) {
+    const raw = await fetchUsage(accessToken);
+    if (raw.error && getRefreshToken(entry.credentials)) {
       try {
         accessToken = await this.refreshToken(entry);
-        return await fetchUsage(accessToken);
+        const retried = await fetchUsage(accessToken);
+        if (retried.error) return { error: retried.error };
+        return convertAnthropicUsage(retried);
       } catch (e) {
         oauthLogger.warn(`refresh failed for ${entry.name}: ${(e as Error).message}`);
         return { error: "re-login required" };
       }
     }
-
-    return result;
+    if (raw.error) return { error: raw.error };
+    return convertAnthropicUsage(raw);
   }
 
-  async refreshToken(token: RefreshTokenParams): Promise<string> {
-    if (!token.refresh_token) throw new Error("No refresh token");
-    const refreshed = await refreshAccessToken(token.refresh_token);
+  async refreshToken(token: TokenSubsetA): Promise<string> {
+    const creds = token.credentials;
+    const rt = getRefreshToken(creds);
+    if (!rt) throw new Error("No refresh token");
+    const refreshed = await refreshAccessToken(rt);
+    const updated = TokenCredentials.parse({
+      ...creds,
+      accessToken: refreshed.accessToken,
+      refreshToken: refreshed.refreshToken,
+      expiresAt: refreshed.expiresAt,
+    });
     await TokenModel.save([
       {
         id: token.id,
-        token: refreshed.accessToken,
-        refresh_token: refreshed.refreshToken,
-        expires_at: BigInt(refreshed.expiresAt),
-        name: token.name ?? "",
+        provider: token.provider,
+        credentials: updated,
+        name: token.name,
       },
     ]);
     return refreshed.accessToken;
@@ -251,3 +558,15 @@ class QgridFrameClass extends BaseFrameClass {
 }
 
 export const QgridFrame = new QgridFrameClass();
+
+function convertAnthropicUsage(raw: AnthropicUsageRaw): UsageResponse {
+  return {
+    provider: "anthropic",
+    fiveHour: raw.five_hour
+      ? { utilization: raw.five_hour.utilization, resetsAt: raw.five_hour.resets_at }
+      : null,
+    sevenDay: raw.seven_day
+      ? { utilization: raw.seven_day.utilization, resetsAt: raw.seven_day.resets_at }
+      : null,
+  };
+}