@cartanova/qgrid-cli 1.0.2 → 1.0.3

package/bundle/src/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/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/src/application/request-log/request-log.entity.json

@@ -0,0 +1,75 @@
+{
+  "id": "RequestLog",
+  "table": "request_logs",
+  "title": "RequestLog",
+  "cone": {
+    "note": "RequestLog 엔티티. 테스트 데이터 생성 시 각 필드는 실제 데이터와 유사한 형식으로 생성됩니다."
+  },
+  "props": [
+    {
+      "name": "id",
+      "type": "integer",
+      "desc": "ID",
+      "cone": {
+        "note": "정수 형식으로 생성됩니다.",
+        "fixtureGenerator": "faker.number.int({ \"min\": 1, \"max\": 1000 })"
+      }
+    },
+    {
+      "name": "created_at",
+      "type": "date",
+      "desc": "등록일시",
+      "dbDefault": "CURRENT_TIMESTAMP",
+      "cone": { "note": "날짜 형식으로 생성됩니다.", "fixtureGenerator": "faker.date.past()" }
+    },
+    {
+      "name": "token_name",
+      "toFilter": true,
+      "desc": "토큰 이름",
+      "type": "string",
+      "length": 100
+    },
+    { "name": "query", "type": "string", "desc": "prompt 전문" },
+    { "name": "response", "desc": "llm 응답 전문", "type": "string" },
+    { "name": "input_tokens", "type": "integer", "desc": "입력 토큰" },
+    { "name": "output_tokens", "type": "integer", "desc": "출력 토큰" },
+    { "name": "cache_read_tokens", "type": "integer", "desc": "캐시 읽기 토큰" },
+    { "name": "cache_creation_tokens", "type": "integer", "desc": "캐시 생성 토큰" },
+    { "name": "duration_ms", "type": "integer", "desc": "응답 소요시간(ms)" }
+  ],
+  "indexes": [],
+  "subsets": {
+    "A": {
+      "fields": [
+        "id",
+        "created_at",
+        "token_name",
+        "query",
+        "response",
+        "input_tokens",
+        "output_tokens",
+        "cache_read_tokens",
+        "cache_creation_tokens",
+        "duration_ms"
+      ],
+      "cone": { "note": "전체 필드 서브셋" }
+    }
+  },
+  "enums": {
+    "RequestLogOrderBy": {
+      "values": { "id-desc": "ID최신순" },
+      "cone": { "note": "가능한 값: id-desc", "values": { "id-desc": { "note": "ID최신순" } } }
+    },
+    "RequestLogSearchField": {
+      "values": { "id": "ID", "token_name": "토큰이름", "query": "쿼리" },
+      "cone": {
+        "note": "가능한 값: id, token_name, query",
+        "values": {
+          "id": { "note": "ID" },
+          "token_name": { "note": "토큰이름" },
+          "query": { "note": "쿼리" }
+        }
+      }
+    }
+  }
+}

package/bundle/src/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/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>;