@cartanova/qgrid-cli 1.5.6 → 1.6.1

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

@@ -0,0 +1,184 @@
+/**
+ * QgridDispatcher — OAuth 토큰 선택 + claude CLI fresh spawn 디스패처 싱글턴.
+ *
+ * - 매 요청마다 새 claude CLI 프로세스 spawn → 응답 후 종료
+ * - system 은 --append-system-prompt 로 분리 전달 (user turn 오염 방지)
+ * - least-used round-robin 으로 토큰 선택
+ * - QuotaError 는 그대로 상위 전파 (자동 failover 없음, UI 에서 수동 토글)
+ *
+ * env allowlist: PATH, TMPDIR, CLAUDE_CODE_OAUTH_TOKEN + CLAUDE_CODE_DISABLE_*
+ */
+import { spawn } from "node:child_process";
+import { mkdirSync } from "node:fs";
+
+import { type CliResult, type QueryInput, type TokenStats } from "./qgrid.types";
+import { maskToken, ProcessError, QuotaError, TimeoutError } from "./qgrid.types";
+
+const DEFAULT_MODEL = "sonnet";
+const DEFAULT_TIMEOUT_MS = 600_000;
+
+class QgridDispatcherClass {
+  tokens = new Map<string, string>();
+  requestCounts = new Map<string, number>();
+  rrIndex = 0;
+
+  constructor() {
+    mkdirSync("/tmp/qgrid", { recursive: true });
+  }
+
+  getStats(): TokenStats[] {
+    return [...this.tokens.entries()].map(([token, name]) => ({
+      token,
+      name,
+      requests: this.requestCounts.get(token) ?? 0,
+    }));
+  }
+
+  selectToken(): { token: string; name: string } | null {
+    const entries = [...this.tokens.entries()];
+    if (entries.length === 0) return null;
+
+    const minCount = Math.min(...entries.map(([t]) => this.requestCounts.get(t) ?? 0));
+    const idle = entries.filter(([t]) => (this.requestCounts.get(t) ?? 0) === minCount);
+    const picked = idle[this.rrIndex % idle.length]!;
+    this.rrIndex++;
+    return { token: picked[0], name: picked[1] };
+  }
+
+  async query(input: QueryInput, timeoutMs?: number): Promise<CliResult> {
+    const sel = this.selectToken();
+    if (!sel) throw new QuotaError("No tokens available");
+
+    // await 전에 count 선반영. 병렬 요청이 동시에 도착해도 각자 다른 토큰을 고르도록.
+    this.requestCounts.set(sel.token, (this.requestCounts.get(sel.token) ?? 0) + 1);
+
+    console.log(`[qgrid] → ${sel.name} (model: ${input.model ?? DEFAULT_MODEL})`);
+
+    const result = await executeClaude(input, sel.token, timeoutMs ?? DEFAULT_TIMEOUT_MS);
+    return { ...result, tokenName: sel.name, model: input.model ?? DEFAULT_MODEL };
+  }
+
+  addToken(token: string, name: string): void {
+    if (this.tokens.has(token)) return;
+    this.tokens.set(token, name);
+    this.requestCounts.set(token, 0);
+  }
+
+  removeToken(token: string): void {
+    this.tokens.delete(token);
+    this.requestCounts.delete(token);
+  }
+
+  hasToken(token: string): boolean {
+    return this.tokens.has(token);
+  }
+}
+
+async function executeClaude(
+  input: QueryInput,
+  token: string,
+  timeoutMs: number,
+): Promise<CliResult> {
+  const model = input.model ?? DEFAULT_MODEL;
+  const timeout = input.timeout ?? timeoutMs;
+
+  const args: string[] = [
+    "-p",
+    "--output-format",
+    "stream-json",
+    "--verbose",
+    "--max-turns",
+    "1",
+    "--permission-mode",
+    "bypassPermissions",
+    "--setting-sources",
+    "project",
+    "--model",
+    model,
+  ];
+  if (input.system) {
+    args.push("--append-system-prompt", input.system);
+  }
+  args.push(input.prompt);
+
+  const env: NodeJS.ProcessEnv = {
+    PATH: process.env.PATH,
+    TMPDIR: process.env.TMPDIR,
+    CLAUDE_CODE_OAUTH_TOKEN: token,
+    CLAUDE_CODE_DISABLE_AUTO_MEMORY: "1",
+    CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING: "1",
+    CLAUDE_CODE_DISABLE_1M_CONTEXT: "1",
+  };
+
+  return new Promise<CliResult>((resolve, reject) => {
+    const child = spawn("claude", args, {
+      stdio: ["ignore", "pipe", "ignore"],
+      env,
+      cwd: "/tmp/qgrid",
+    });
+
+    let buffer = "";
+    let settled = false;
+    const timer = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      child.kill();
+      reject(new TimeoutError(`Timeout after ${timeout / 1000}s (token: ${maskToken(token)})`));
+    }, timeout);
+
+    child.stdout?.on("data", (d: Buffer) => {
+      if (settled) return;
+      buffer += d.toString();
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const j = JSON.parse(line);
+          if (j.type === "result" && !settled) {
+            let text: string = j.result ?? "";
+            text = text.replace(/^```(?:json)?\s*\n?/i, "").replace(/\n?```\s*$/i, "");
+
+            if (text.startsWith("You've hit")) {
+              settled = true;
+              clearTimeout(timer);
+              reject(new QuotaError(`Quota exhausted (token: ${maskToken(token)})`));
+              return;
+            }
+
+            const u = j.usage ?? {};
+            settled = true;
+            clearTimeout(timer);
+            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,
+            });
+          }
+        } catch {}
+      }
+    });
+
+    child.on("close", () => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      reject(new ProcessError(`CLI process closed without result (token: ${maskToken(token)})`));
+    });
+
+    child.on("error", (err) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      reject(new ProcessError(`CLI process error: ${err.message} (token: ${maskToken(token)})`));
+    });
+  });
+}
+
+export const QgridDispatcher = new QgridDispatcherClass();

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

@@ -11,7 +11,7 @@ import {
   generatePKCE,
   refreshAccessToken,
 } from "./oauth";
-import { type ClaudePool, getPool } from "./pool";
+import { QgridDispatcher } from "./qgrid.dispatcher";
 import {
   type CliResult,
   type HealthResponse,
@@ -20,7 +20,6 @@ import {
   type UsageResponse,
 } from "./qgrid.types";
 
-// PKCE 세션 메모리 저장 (state → { codeVerifier, name, redirectUri })
 const pendingOAuth = new Map<string, { codeVerifier: string; name: string; redirectUri: string }>();
 
 class QgridFrameClass extends BaseFrameClass {
@@ -29,15 +28,22 @@ class QgridFrameClass extends BaseFrameClass {
   }
 
   @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);
+  async query(
+    prompt: string,
+    system?: string,
+    timeout?: number,
+    model?: string,
+    projectName?: string,
+  ): Promise<CliResult> {
+    const result = await QgridDispatcher.query({ system, prompt, model }, timeout);
 
-    // 로그 기록 실패해도 쿼리 결과는 반환
     RequestLogModel.save([
       {
-        token_name: pool.getLastUsedWorkerName(),
-        query: system ? `[System]\n${system}\n\n[User]\n${prompt}` : prompt,
+        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,
@@ -53,7 +59,7 @@ class QgridFrameClass extends BaseFrameClass {
 
   @api({ httpMethod: "GET", clients: ["axios", "tanstack-query"] })
   async stats(): Promise<TokenStats[]> {
-    return getPool().getStats();
+    return QgridDispatcher.getStats();
   }
 
   @api({ httpMethod: "GET", clients: ["axios", "tanstack-query"] })
@@ -61,6 +67,11 @@ class QgridFrameClass extends BaseFrameClass {
     return { usd: await RequestLogModel.totalCost({ token_name: tokenName }) };
   }
 
+  @api({ httpMethod: "GET", clients: ["axios", "tanstack-query"] })
+  async projectNames(): Promise<{ names: string[] }> {
+    return { names: await RequestLogModel.distinctProjectNames() };
+  }
+
   @api({ httpMethod: "POST", clients: ["axios", "tanstack-mutation"] })
   async addToken(token: string, name: string, refreshToken?: string): Promise<{ added: boolean }> {
     await TokenModel.save([
@@ -70,7 +81,7 @@ class QgridFrameClass extends BaseFrameClass {
         ...(refreshToken && refreshToken.length > 0 ? { refresh_token: refreshToken } : {}),
       },
     ]);
-    getPool().createWorkers(token, name);
+    QgridDispatcher.addToken(token, name);
     return { added: true };
   }
 
@@ -81,7 +92,6 @@ class QgridFrameClass extends BaseFrameClass {
     newToken?: string,
     refreshToken?: string,
   ): Promise<{ updated: boolean }> {
-    const pool = getPool();
     const entry = await TokenModel.findByToken("A", token);
     if (!entry) return { updated: false };
 
@@ -97,52 +107,44 @@ class QgridFrameClass extends BaseFrameClass {
     ]);
 
     if (hasNewToken) {
-      pool.destroyWorkers(token);
-      pool.createWorkers(newToken, name ?? entry.name);
+      QgridDispatcher.removeToken(token);
+      QgridDispatcher.addToken(newToken, name ?? entry.name);
     }
     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 };
+    if (!QgridDispatcher.hasToken(token)) return { removed: false };
 
     const entry = await TokenModel.findByToken("A", token);
     if (entry) await TokenModel.del([entry.id]);
-    pool.destroyWorkers(token);
+    QgridDispatcher.removeToken(token);
     return { removed: true };
   }
 
   /**
-   *
    * @param id token_id
-   * 토큰 활성화/비활성화 토글 (pool 워커 생성/제거 & DB의 active 필드 업데이트)
-   *
+   * 토큰 활성화/비활성화 토글 (dispatcher 등록/제거 & 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, entry.name);
+      QgridDispatcher.addToken(entry.token, entry.name);
     } else {
-      // 워커 제거
-      pool.destroyWorkers(entry.token);
+      QgridDispatcher.removeToken(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();
@@ -151,16 +153,13 @@ class QgridFrameClass extends BaseFrameClass {
     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");
@@ -175,16 +174,14 @@ class QgridFrameClass extends BaseFrameClass {
         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]);
+        if (oldEntries.length > 0) {
+          for (const old of oldEntries) QgridDispatcher.removeToken(old.token);
+          await TokenModel.del(oldEntries.map((o) => o.id));
         }
       }
 
-      // 새 토큰 저장 + pool에 등록
       await TokenModel.save([
         {
           token: tokens.accessToken,
@@ -194,7 +191,7 @@ class QgridFrameClass extends BaseFrameClass {
           account_uuid: tokens.accountUuid,
         },
       ]);
-      pool.createWorkers(tokens.accessToken, pending.name);
+      QgridDispatcher.addToken(tokens.accessToken, pending.name);
 
       return reply.redirect(`/?oauth=success&name=${encodeURIComponent(pending.name)}`);
     } catch (e) {
@@ -202,10 +199,8 @@ class QgridFrameClass extends BaseFrameClass {
     }
   }
 
-  // 토큰 사용량 조회 (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)
@@ -213,26 +208,23 @@ class QgridFrameClass extends BaseFrameClass {
 
     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);
+        accessToken = await this.refreshToken(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);
+        accessToken = await this.refreshToken(entry);
         return await fetchUsage(accessToken);
       } catch (e) {
         console.warn(`[usage] refresh failed for ${entry.name}: ${(e as Error).message}`);
@@ -243,7 +235,7 @@ class QgridFrameClass extends BaseFrameClass {
     return result;
   }
 
-  async refreshToken(pool: ClaudePool, token: RefreshTokenParams): Promise<string> {
+  async refreshToken(token: RefreshTokenParams): Promise<string> {
     if (!token.refresh_token) throw new Error("No refresh token");
     const refreshed = await refreshAccessToken(token.refresh_token);
     await TokenModel.save([
@@ -255,19 +247,14 @@ class QgridFrameClass extends BaseFrameClass {
         name: token.name ?? "",
       },
     ]);
-    pool.destroyWorkers(token.token);
-    pool.createWorkers(refreshed.accessToken, token.name);
+    QgridDispatcher.removeToken(token.token);
+    QgridDispatcher.addToken(refreshed.accessToken, token.name);
     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,
-    };
+    return { status: "ok", activeTokens: QgridDispatcher.tokens.size };
   }
 }
 

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

@@ -5,12 +5,15 @@ import { z } from "zod";
 export const QueryInput = z.object({
   system: z.string().optional(),
   prompt: z.string(),
+  model: z.string().optional(),
   timeout: z.number().optional(),
 });
 export type QueryInput = z.infer<typeof QueryInput>;
 
 export const CliResult = z.object({
   text: z.string(),
+  tokenName: z.string().optional(),
+  model: z.string().optional(),
   usage: z.object({
     input_tokens: z.number(),
     output_tokens: z.number(),
@@ -22,18 +25,6 @@ export const CliResult = z.object({
 });
 export type CliResult = z.infer<typeof CliResult>;
 
-// ─── Pool Config ───
-
-export const PoolConfig = z.object({
-  tokens: z.array(z.object({ token: z.string(), name: 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({
@@ -51,7 +42,6 @@ export const TokenStats = z.object({
   token: z.string(),
   name: z.string(),
   requests: z.number(),
-  active: z.boolean(),
 });
 export type TokenStats = z.infer<typeof TokenStats>;
 
@@ -93,7 +83,6 @@ export type UsageResponse = z.infer<typeof UsageResponse>;
 
 export const HealthResponse = z.object({
   status: z.string(),
-  workers: z.number(),
   activeTokens: z.number(),
 });
 export type HealthResponse = z.infer<typeof HealthResponse>;

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

@@ -55,6 +55,9 @@ export namespace QgridService {
   export const totalCost = (tokenName?: string): SSRQuery =>
     createSSRQuery("QgridFrame", "totalCost", [tokenName], ["Qgrid", "totalCost"]);
 
+  export const projectNames = (): SSRQuery =>
+    createSSRQuery("QgridFrame", "projectNames", [], ["Qgrid", "projectNames"]);
+
   export const usage = (tokenName?: string): SSRQuery =>
     createSSRQuery("QgridFrame", "usage", [tokenName], ["Qgrid", "usage"]);
 

package/bundle/src/application/request-log/request-log.entity.json

@@ -15,12 +15,7 @@
         "fixtureGenerator": "faker.number.int({ \"min\": 1, \"max\": 1000 })"
       }
     },
-    {
-      "name": "created_at",
-      "desc": "등록일시",
-      "dbDefault": "CURRENT_TIMESTAMP",
-      "type": "date"
-    },
+    { "name": "created_at", "desc": "등록일시", "dbDefault": "CURRENT_TIMESTAMP", "type": "date" },
     {
       "name": "token_name",
       "toFilter": true,
@@ -28,19 +23,31 @@
       "type": "string",
       "length": 100
     },
-    { "name": "query", "type": "string", "desc": "prompt 전문" },
+    {
+      "name": "project_name",
+      "toFilter": true,
+      "desc": "프로젝트 이름",
+      "type": "string",
+      "length": 50,
+      "nullable": true
+    },
+    {
+      "name": "model_name",
+      "toFilter": true,
+      "desc": "모델 이름",
+      "type": "string",
+      "length": 50,
+      "nullable": true
+    },
+    { "name": "user_prompt", "type": "string", "nullable": true, "desc": "사용자 프롬프트" },
+    { "name": "system_prompt", "type": "string", "nullable": true, "desc": "시스템 프롬프트" },
     { "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)" },
-    {
-      "name": "cost_usd",
-      "type": "integer",
-      "nullable": true,
-      "desc": "API 비용"
-    }
+    { "name": "cost_usd", "type": "integer", "nullable": true, "desc": "API 비용" }
   ],
   "indexes": [
     {
@@ -48,6 +55,12 @@
       "name": "request_logs_token_name_index",
       "columns": [{ "name": "token_name" }],
       "using": "btree"
+    },
+    {
+      "type": "index",
+      "name": "request_logs_project_name_index",
+      "columns": [{ "name": "project_name" }],
+      "using": "btree"
     }
   ],
   "subsets": {
@@ -56,7 +69,10 @@
         "id",
         "created_at",
         "token_name",
-        "query",
+        "project_name",
+        "model_name",
+        "user_prompt",
+        "system_prompt",
         "response",
         "input_tokens",
         "output_tokens",
@@ -74,13 +90,13 @@
       "cone": { "note": "가능한 값: id-desc", "values": { "id-desc": { "note": "ID최신순" } } }
     },
     "RequestLogSearchField": {
-      "values": { "id": "ID", "token_name": "토큰이름", "query": "쿼리" },
+      "values": { "id": "ID", "token_name": "토큰이름", "user_prompt": "사용자 프롬프트" },
       "cone": {
-        "note": "가능한 값: id, token_name, query",
+        "note": "가능한 값: id, token_name, user_prompt",
         "values": {
           "id": { "note": "ID" },
           "token_name": { "note": "토큰이름" },
-          "query": { "note": "쿼리" }
+          "user_prompt": { "note": "사용자 프롬프트" }
         }
       }
     }

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

@@ -82,13 +82,25 @@ class RequestLogModelClass extends BaseModelClass<
       qb.where("request_logs.token_name", "like", `${params.token_name}-%`);
     }
 
+    if (params.project_name_is_null) {
+      qb.where("request_logs.project_name", null);
+    } else if (params.project_name_is_not_null) {
+      qb.where("request_logs.project_name", "!=", null);
+    } else if (params.project_name) {
+      qb.where("request_logs.project_name", params.project_name);
+    }
+
+    if (params.model_name) {
+      qb.where("request_logs.model_name", params.model_name);
+    }
+
     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 if (params.search === "user_prompt") {
+        qb.where("request_logs.user_prompt", "like", `%${params.keyword}%`);
       } else {
         throw new BadRequestException(SD("error.unknownSearchField")(params.search));
       }
@@ -148,6 +160,18 @@ class RequestLogModelClass extends BaseModelClass<
     return Number(row?.sum ?? 0) / MICRO_USD;
   }
 
+  async distinctProjectNames(): Promise<string[]> {
+    const { rows } = await this.findMany("A", {
+      project_name_is_not_null: true,
+      num: 10_000,
+      page: 1,
+      queryMode: "list",
+    });
+    return [
+      ...new Set(rows.map((r) => r.project_name).filter((n): n is string => n !== null)),
+    ].toSorted();
+  }
+
   @api({ httpMethod: "POST", clients: ["axios", "tanstack-mutation"] })
   async del(ids: number[]): Promise<number> {
     const wdb = this.getPuri("w");

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

@@ -1,9 +1,13 @@
-import type { z } from "zod";
+import { z } from "zod";
 
 import { RequestLogBaseListParams, RequestLogBaseSchema } from "../sonamu.generated";
 
 // RequestLog - ListParams
-export const RequestLogListParams = RequestLogBaseListParams;
+// project_name NULL 분기: IS NULL만 조회(unassigned 필터) 또는 IS NOT NULL만(distinct 조회).
+export const RequestLogListParams = RequestLogBaseListParams.extend({
+  project_name_is_null: z.boolean().optional(),
+  project_name_is_not_null: z.boolean().optional(),
+});
 export type RequestLogListParams = z.infer<typeof RequestLogListParams>;
 
 // RequestLog - SaveParams