@cartanova/qgrid-cli 1.0.1 → 1.0.3

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

@@ -0,0 +1,234 @@
+/**
+ * Worker — Claude CLI stream-json 프로세스 하나를 관리.
+ *
+ * 기존 SocratsAI ClaudeCliService에서 추출 + 리팩터:
+ * - 토큰/모델을 생성자에서 주입
+ * - env allowlist (PATH, HOME, TMPDIR, CLAUDE_CODE_OAUTH_TOKEN만)
+ * - callCount 추적 + maxCalls 도달 시 프로세스 재활용
+ * - QuotaError/TimeoutError/ProcessError 구분
+ */
+import { type ChildProcess, spawn } from "node:child_process";
+import { mkdirSync } from "node:fs";
+
+import type { CliResult, QueryInput } from "./qgrid.types";
+import { maskToken, ProcessError, QuotaError, TimeoutError } from "./qgrid.types";
+
+type PendingRequest = {
+  resolve: (value: CliResult) => void;
+  reject: (reason: Error) => void;
+  timer: ReturnType<typeof setTimeout>;
+};
+
+export type WorkerConfig = {
+  token: string;
+  model: string;
+  timeout: number;
+  cwd: string;
+  maxCalls: number;
+};
+
+export class Worker {
+  tokenId: string;
+  config: WorkerConfig;
+  process: ChildProcess | null = null;
+  buffer = "";
+  pending: PendingRequest | null = null;
+  sessionId: string | null = null;
+  queue: Array<() => void> = [];
+  cwdCreated = false;
+  callCount = 0;
+  needsRecycle = false;
+
+  constructor(config: WorkerConfig) {
+    this.config = config;
+    this.tokenId = config.token;
+  }
+
+  getQueueDepth(): number {
+    return this.queue.length + (this.pending ? 1 : 0);
+  }
+
+  rejectPending(err: Error): void {
+    if (!this.pending) return;
+    this.pending.reject(err);
+    clearTimeout(this.pending.timer);
+    this.pending = null;
+  }
+
+  ensureProcess(): ChildProcess {
+    if (this.process && this.process.exitCode === null && !this.needsRecycle) {
+      return this.process;
+    }
+
+    if (this.process && this.process.exitCode === null) {
+      this.process.kill();
+      this.process = null;
+    }
+
+    const env: NodeJS.ProcessEnv = {
+      PATH: process.env.PATH,
+      HOME: process.env.HOME,
+      TMPDIR: process.env.TMPDIR,
+      CLAUDE_CODE_OAUTH_TOKEN: this.config.token,
+    };
+
+    const { cwd } = this.config;
+    if (!this.cwdCreated) {
+      mkdirSync(cwd, { recursive: true });
+      this.cwdCreated = true;
+    }
+
+    const child = spawn(
+      "claude",
+      [
+        "-p",
+        "--input-format",
+        "stream-json",
+        "--output-format",
+        "stream-json",
+        "--verbose",
+        "--max-turns",
+        "1",
+        "--model",
+        this.config.model,
+      ],
+      { stdio: ["pipe", "pipe", "ignore"], env, cwd },
+    );
+
+    child.stdout?.on("data", (d: Buffer) => {
+      this.buffer += d.toString();
+      this.processBuffer();
+    });
+
+    child.on("close", () => {
+      this.process = null;
+      this.rejectPending(
+        new ProcessError(`CLI process closed (token: ${maskToken(this.tokenId)})`),
+      );
+      this.drainQueue();
+    });
+
+    child.on("error", (err) => {
+      this.process = null;
+      this.rejectPending(
+        new ProcessError(`CLI process error: ${err.message} (token: ${maskToken(this.tokenId)})`),
+      );
+      this.drainQueue();
+    });
+
+    this.process = child;
+    this.buffer = "";
+    this.sessionId = null;
+    this.callCount = 0;
+    this.needsRecycle = false;
+    return child;
+  }
+
+  processBuffer(): void {
+    const lines = this.buffer.split("\n");
+    this.buffer = lines.pop() ?? "";
+
+    lines
+      .filter((line) => line.trim() !== "")
+      .forEach((line) => {
+        try {
+          const j = JSON.parse(line);
+
+          if (j.type === "system" && j.subtype === "init" && j.session_id) {
+            this.sessionId = j.session_id;
+          }
+
+          if (j.type === "result" && this.pending) {
+            let text: string = j.result ?? "";
+            text = text.replace(/^```(?:json)?\s*\n?/i, "").replace(/\n?```\s*$/i, "");
+
+            if (text.startsWith("You've hit")) {
+              this.pending.reject(
+                new QuotaError(`Quota exhausted (token: ${maskToken(this.tokenId)})`),
+              );
+              clearTimeout(this.pending.timer);
+              this.pending = null;
+              this.drainQueue();
+              return;
+            }
+
+            const u = j.usage ?? {};
+            this.pending.resolve({
+              text,
+              usage: {
+                input_tokens: u.input_tokens ?? 0,
+                output_tokens: u.output_tokens ?? 0,
+                cache_creation_input_tokens: u.cache_creation_input_tokens ?? 0,
+                cache_read_input_tokens: u.cache_read_input_tokens ?? 0,
+              },
+              durationMs: j.duration_ms ?? 0,
+              costUsd: j.total_cost_usd ?? 0,
+            });
+            clearTimeout(this.pending.timer);
+            this.pending = null;
+            this.drainQueue();
+          }
+        } catch {
+          // skip non-json lines
+        }
+      });
+  }
+
+  drainQueue(): void {
+    if (this.pending) return;
+    const next = this.queue.shift();
+    if (next) next();
+  }
+
+  async query(input: QueryInput, timeoutMs?: number): Promise<CliResult> {
+    if (this.pending) {
+      await new Promise<void>((resolve) => {
+        this.queue.push(resolve);
+      });
+    }
+
+    const child = this.ensureProcess();
+    const timeout = timeoutMs ?? this.config.timeout;
+
+    this.callCount++;
+    if (this.callCount >= this.config.maxCalls) {
+      this.needsRecycle = true;
+    }
+
+    const prompt = input.system ? `${input.system}\n\n${input.prompt}` : input.prompt;
+
+    return new Promise<CliResult>((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending = null;
+        reject(
+          new TimeoutError(`Timeout after ${timeout / 1000}s (token: ${maskToken(this.tokenId)})`),
+        );
+        this.kill();
+      }, timeout);
+
+      this.pending = { resolve, reject, timer };
+
+      const msg = JSON.stringify({
+        type: "user",
+        message: { role: "user", content: prompt },
+        session_id: this.sessionId ?? "default",
+        parent_tool_use_id: null,
+      });
+
+      child.stdin?.write(`${msg}\n`);
+    });
+  }
+
+  kill(): void {
+    if (this.process && this.process.exitCode === null) {
+      this.process.kill();
+    }
+    this.process = null;
+    this.buffer = "";
+    this.sessionId = null;
+    this.callCount = 0;
+    this.needsRecycle = false;
+    this.rejectPending(new ProcessError(`Worker killed (token: ${maskToken(this.tokenId)})`));
+    this.drainQueue();
+  }
+}

package/bundle/src/application/queries.generated.ts

@@ -0,0 +1,59 @@
+/**
+ * @generated
+ * 직접 수정하지 마세요.
+ */
+/* oxlint-disable */
+
+import type { SSRQuery } from "sonamu/ssr";
+
+// SSRQuery 헬퍼 함수
+function createSSRQuery(
+  modelName: string,
+  methodName: string,
+  params: any[],
+  serviceKey: [string, string],
+): SSRQuery {
+  return { modelName, methodName, params, serviceKey, __brand: "SSRQuery" } as SSRQuery;
+}
+
+import { RequestLogListParams } from "./request-log/request-log.types";
+import { TokenSubsetKey, RequestLogSubsetKey } from "./sonamu.generated";
+import { TokenListParams } from "./token/token.types";
+
+export namespace TokenService {
+  export const getToken = <T extends TokenSubsetKey>(subset: T, id: number): SSRQuery =>
+    createSSRQuery("TokenModel", "findById", [subset, id], ["Token", "getToken"]);
+
+  export const getTokens = <T extends TokenSubsetKey, LP extends TokenListParams>(
+    subset: T,
+    rawParams?: LP,
+  ): SSRQuery =>
+    createSSRQuery("TokenModel", "findMany", [subset, rawParams], ["Token", "getTokens"]);
+}
+
+export namespace RequestLogService {
+  export const getRequestLog = <T extends RequestLogSubsetKey>(subset: T, id: number): SSRQuery =>
+    createSSRQuery("RequestLogModel", "findById", [subset, id], ["RequestLog", "getRequestLog"]);
+
+  export const getRequestLogs = <T extends RequestLogSubsetKey, LP extends RequestLogListParams>(
+    subset: T,
+    rawParams?: LP,
+  ): SSRQuery =>
+    createSSRQuery(
+      "RequestLogModel",
+      "findMany",
+      [subset, rawParams],
+      ["RequestLog", "getRequestLogs"],
+    );
+}
+
+export namespace QgridService {
+  export const stats = (): SSRQuery =>
+    createSSRQuery("QgridFrame", "stats", [], ["Qgrid", "stats"]);
+
+  export const usage = (tokenName?: string): SSRQuery =>
+    createSSRQuery("QgridFrame", "usage", [tokenName], ["Qgrid", "usage"]);
+
+  export const health = (): SSRQuery =>
+    createSSRQuery("QgridFrame", "health", [], ["Qgrid", "health"]);
+}

package/bundle/src/application/request-log/request-log.model.ts

@@ -0,0 +1,155 @@
+import {
+  api,
+  asArray,
+  BadRequestException,
+  BaseModelClass,
+  exhaustive,
+  type ListResult,
+  NotFoundException,
+} from "sonamu";
+
+import { SD } from "../../i18n/sd.generated";
+import type { RequestLogSubsetKey, RequestLogSubsetMapping } from "../sonamu.generated";
+import { requestLogLoaderQueries, requestLogSubsetQueries } from "../sonamu.generated.sso";
+import type { RequestLogListParams, RequestLogSaveParams } from "./request-log.types";
+
+/*
+  RequestLog Model
+*/
+class RequestLogModelClass extends BaseModelClass<
+  RequestLogSubsetKey,
+  RequestLogSubsetMapping,
+  typeof requestLogSubsetQueries,
+  typeof requestLogLoaderQueries
+> {
+  constructor() {
+    super("RequestLog", requestLogSubsetQueries, requestLogLoaderQueries);
+  }
+
+  @api({ httpMethod: "GET", clients: ["axios", "tanstack-query"], resourceName: "RequestLog" })
+  async findById<T extends RequestLogSubsetKey>(
+    subset: T,
+    id: number,
+  ): Promise<RequestLogSubsetMapping[T]> {
+    const { rows } = await this.findMany(subset, {
+      id,
+      num: 1,
+      page: 1,
+    });
+    if (!rows[0]) {
+      throw new NotFoundException(SD("error.entityNotFound")("RequestLog", id));
+    }
+
+    return rows[0];
+  }
+
+  async findOne<T extends RequestLogSubsetKey>(
+    subset: T,
+    listParams: RequestLogListParams,
+  ): Promise<RequestLogSubsetMapping[T] | null> {
+    const { rows } = await this.findMany(subset, {
+      ...listParams,
+      num: 1,
+      page: 1,
+    });
+
+    return rows[0] ?? null;
+  }
+
+  @api({ httpMethod: "GET", clients: ["axios", "tanstack-query"], resourceName: "RequestLogs" })
+  async findMany<T extends RequestLogSubsetKey, LP extends RequestLogListParams>(
+    subset: T,
+    rawParams?: LP,
+  ): Promise<ListResult<LP, RequestLogSubsetMapping[T]>> {
+    // params with defaults
+    const params = {
+      num: 24,
+      page: 1,
+      search: "id" as const,
+      orderBy: "id-desc" as const,
+      ...rawParams,
+    } satisfies RequestLogListParams;
+
+    // build queries
+    const { qb, onSubset: _ } = this.getSubsetQueries(subset);
+
+    // id
+    if (params.id) {
+      qb.whereIn("request_logs.id", asArray(params.id));
+    }
+
+    // token_name filter (toFilter)
+    if (params.token_name) {
+      qb.where("request_logs.token_name", params.token_name);
+    }
+
+    // search-keyword
+    if (params.search && params.keyword && params.keyword.length > 0) {
+      if (params.search === "id") {
+        qb.where("request_logs.id", Number(params.keyword));
+      } else if (params.search === "token_name") {
+        qb.where("request_logs.token_name", "like", `%${params.keyword}%`);
+      } else if (params.search === "query") {
+        qb.where("request_logs.query", "like", `%${params.keyword}%`);
+      } else {
+        throw new BadRequestException(SD("error.unknownSearchField")(params.search));
+      }
+    }
+
+    // orderBy
+    if (params.orderBy) {
+      // default orderBy
+      if (params.orderBy === "id-desc") {
+        qb.orderBy("request_logs.id", "desc");
+      } else {
+        exhaustive(params.orderBy);
+      }
+    }
+
+    const enhancers = this.createEnhancers({
+      A: (row) => ({
+        ...row,
+        // 서브셋별로 virtual 필드 계산로직 추가
+      }),
+    });
+
+    return this.executeSubsetQuery({
+      subset,
+      qb,
+      params,
+      enhancers,
+      debug: false,
+    });
+  }
+
+  @api({ httpMethod: "POST", clients: ["axios", "tanstack-mutation"] })
+  async save(spa: RequestLogSaveParams[]): Promise<number[]> {
+    const wdb = this.getPuri("w");
+
+    // register
+    spa.forEach((sp) => {
+      wdb.ubRegister("request_logs", sp);
+    });
+
+    // transaction
+    return wdb.transaction(async (trx) => {
+      const ids = await trx.ubUpsert("request_logs");
+
+      return ids;
+    });
+  }
+
+  @api({ httpMethod: "POST", clients: ["axios", "tanstack-mutation"] })
+  async del(ids: number[]): Promise<number> {
+    const wdb = this.getPuri("w");
+
+    // transaction
+    await wdb.transaction(async (trx) => {
+      return trx.table("request_logs").whereIn("request_logs.id", ids).delete();
+    });
+
+    return ids.length;
+  }
+}
+
+export const RequestLogModel = new RequestLogModelClass();

package/bundle/src/application/request-log/request-log.types.ts

@@ -0,0 +1,15 @@
+import type { z } from "zod";
+
+import { RequestLogBaseListParams, RequestLogBaseSchema } from "../sonamu.generated";
+
+// RequestLog - ListParams
+export const RequestLogListParams = RequestLogBaseListParams;
+export type RequestLogListParams = z.infer<typeof RequestLogListParams>;
+
+// RequestLog - SaveParams
+export const RequestLogSaveParams = RequestLogBaseSchema.partial({
+  id: true,
+  created_at: true,
+  token_name: true,
+});
+export type RequestLogSaveParams = z.infer<typeof RequestLogSaveParams>;

package/bundle/src/application/sonamu.generated.http

@@ -0,0 +1,187 @@
+# @generated
+# 직접 수정하지 마세요.
+
+GET {{baseUrl}}/api/token/findById
+	?subset=A
+	&id=0
+Content-Type: application/json
+
+###
+
+GET {{baseUrl}}/api/token/findMany
+	?subset=A
+	&rawParams[num]=24
+	&rawParams[page]=1
+	&rawParams[search]=id
+	&rawParams[keyword]=KEYWORD
+	&rawParams[orderBy]=id-desc
+	&rawParams[queryMode]=both
+	&rawParams[id]=0
+	&rawParams[sonamuFilter]=unknown-custom
+	&rawParams[token]=TOKEN
+Content-Type: application/json
+
+###
+
+POST {{baseUrl}}/api/token/save
+Content-Type: application/json
+
+{
+  "spa": [
+    {
+      "id": 0,
+      "created_at": "2000-01-01",
+      "token": "TOKEN",
+      "name": "NAME",
+      "refresh_token": null,
+      "expires_at": null,
+      "account_uuid": null,
+      "active": false
+    }
+  ]
+}
+
+###
+
+POST {{baseUrl}}/api/token/del
+Content-Type: application/json
+
+{
+  "ids": [
+    0
+  ]
+}
+
+###
+
+GET {{baseUrl}}/api/requestLog/findById
+	?subset=A
+	&id=0
+Content-Type: application/json
+
+###
+
+GET {{baseUrl}}/api/requestLog/findMany
+	?subset=A
+	&rawParams[num]=24
+	&rawParams[page]=1
+	&rawParams[search]=id
+	&rawParams[keyword]=KEYWORD
+	&rawParams[orderBy]=id-desc
+	&rawParams[queryMode]=both
+	&rawParams[id]=0
+	&rawParams[sonamuFilter]=unknown-custom
+	&rawParams[token_name]=TOKEN_NAME
+Content-Type: application/json
+
+###
+
+POST {{baseUrl}}/api/requestLog/save
+Content-Type: application/json
+
+{
+  "spa": [
+    {
+      "id": 0,
+      "created_at": "2000-01-01",
+      "token_name": "TOKEN_NAME",
+      "query": "QUERY",
+      "response": "RESPONSE",
+      "input_tokens": 0,
+      "output_tokens": 0,
+      "cache_read_tokens": 0,
+      "cache_creation_tokens": 0,
+      "duration_ms": 0
+    }
+  ]
+}
+
+###
+
+POST {{baseUrl}}/api/requestLog/del
+Content-Type: application/json
+
+{
+  "ids": [
+    0
+  ]
+}
+
+###
+
+POST {{baseUrl}}/api/qgrid/query
+Content-Type: application/json
+
+{
+  "prompt": "PROMPT",
+  "system": "SYSTEM",
+  "timeout": 0
+}
+
+###
+
+GET {{baseUrl}}/api/qgrid/stats
+	?
+Content-Type: application/json
+
+###
+
+POST {{baseUrl}}/api/qgrid/addToken
+Content-Type: application/json
+
+{
+  "token": "TOKEN",
+  "name": "NAME",
+  "refreshToken": "REFRESHTOKEN"
+}
+
+###
+
+POST {{baseUrl}}/api/qgrid/updateToken
+Content-Type: application/json
+
+{
+  "token": "TOKEN",
+  "name": "NAME",
+  "newToken": "NEWTOKEN",
+  "refreshToken": "REFRESHTOKEN"
+}
+
+###
+
+POST {{baseUrl}}/api/qgrid/removeToken
+Content-Type: application/json
+
+{
+  "token": "TOKEN"
+}
+
+###
+
+POST {{baseUrl}}/api/qgrid/toggleToken
+Content-Type: application/json
+
+{
+  "id": 0
+}
+
+###
+
+POST {{baseUrl}}/api/qgrid/oauthStart
+Content-Type: application/json
+
+{
+  "name": "NAME"
+}
+
+###
+
+GET {{baseUrl}}/api/qgrid/usage
+	?tokenName=TOKENNAME
+Content-Type: application/json
+
+###
+
+GET {{baseUrl}}/api/qgrid/health
+	?
+Content-Type: application/json

package/bundle/src/application/sonamu.generated.sso.ts

@@ -0,0 +1,66 @@
+/**
+ * @generated
+ * 직접 수정하지 마세요.
+ */
+import { PuriWrapper, DatabaseSchemaExtend, PuriLoaderQueries } from "sonamu";
+
+import {
+  RequestLogSubsetKey,
+  TokenSubsetKey,
+  RequestLogBaseSchema,
+  TokenBaseSchema,
+} from "./sonamu.generated";
+
+// SubsetQuery: RequestLog
+export const requestLogSubsetQueries = {
+  A: (qbWrapper: PuriWrapper<DatabaseSchemaExtend>) => {
+    return qbWrapper.from("request_logs").select({
+      id: "request_logs.id",
+      created_at: "request_logs.created_at",
+      token_name: "request_logs.token_name",
+      query: "request_logs.query",
+      response: "request_logs.response",
+      input_tokens: "request_logs.input_tokens",
+      output_tokens: "request_logs.output_tokens",
+      cache_read_tokens: "request_logs.cache_read_tokens",
+      cache_creation_tokens: "request_logs.cache_creation_tokens",
+      duration_ms: "request_logs.duration_ms",
+    });
+  },
+};
+
+// LoaderQuery: RequestLog
+export const requestLogLoaderQueries = {
+  A: [],
+} as const satisfies PuriLoaderQueries<RequestLogSubsetKey>;
+
+// SubsetQuery: Token
+export const tokenSubsetQueries = {
+  A: (qbWrapper: PuriWrapper<DatabaseSchemaExtend>) => {
+    return qbWrapper.from("tokens").select({
+      id: "tokens.id",
+      created_at: "tokens.created_at",
+      token: "tokens.token",
+      name: "tokens.name",
+      refresh_token: "tokens.refresh_token",
+      expires_at: "tokens.expires_at",
+      account_uuid: "tokens.account_uuid",
+      active: "tokens.active",
+    });
+  },
+};
+
+// LoaderQuery: Token
+export const tokenLoaderQueries = {
+  A: [],
+} as const satisfies PuriLoaderQueries<TokenSubsetKey>;
+
+// DatabaseSchema
+declare module "sonamu" {
+  export interface DatabaseSchemaExtend {
+    request_logs: RequestLogBaseSchema;
+    tokens: TokenBaseSchema;
+  }
+
+  export interface DatabaseForeignKeys {}
+}