@cartanova/qgrid-cli 1.9.0 → 2.0.1

package/README.md

@@ -1,6 +1,6 @@
 # @cartanova/qgrid-cli
 
-Qgrid 서버를 한 줄로 실행. Claude 구독 크레딧을 HTTP API로 제공하는 LLM 프록시.
+Qgrid 서버를 한 줄로 실행. OpenAI/Anthropic 구독 크레딧을 HTTP API + 대시보드로 제공하는 LLM 프록시.
 
 ## 설치
 
@@ -8,6 +8,21 @@ Qgrid 서버를 한 줄로 실행. Claude 구독 크레딧을 HTTP API로 제공
 npm i -g @cartanova/qgrid-cli
 ```
 
+## PostgreSQL 준비
+
+Qgrid는 OAuth 토큰과 request log를 저장하기 위해 PostgreSQL이 필요함.
+이미 접근 가능한 PostgreSQL이 있으면 `--db` 또는 `QGRID_DB_*` 환경변수로 연결하면 됨.
+로컬에 PostgreSQL이 없으면 Docker로 띄울 수 있음:
+
+```bash
+docker run --name qgrid-postgres \
+  -e POSTGRES_USER=postgres \
+  -e POSTGRES_PASSWORD=postgres \
+  -e POSTGRES_DB=qgrid \
+  -p 5432:5432 \
+  -d postgres:18
+```
+
 ## 사용법
 
 ```bash
@@ -18,7 +33,7 @@ qgrid --db postgres://user:password@host:port/dbname
 qgrid --db postgres://... -p 3000
 
 # 환경변수로 DB 설정 (플래그 생략 가능)
-export QGRID_DB_HOST=dev0.example.com
+export QGRID_DB_HOST=dev.example.com
 export QGRID_DB_PORT=5432
 export QGRID_DB_USER=postgres
 export QGRID_DB_PASSWORD=postgres
@@ -26,7 +41,11 @@ export QGRID_DB_NAME=qgrid
 qgrid
 ```
 
-서버가 뜨면 `http://localhost:44900`에서 대시보드 접속.
+서버가 뜨면 `http://localhost:44900`에서 대시보드 접속 → OAuth 로그인으로 토큰 등록.
+`-p, --port`를 지정하면 해당 포트로 접속.
+
+서버 포트는 기본값 `44900` 또는 `--port`로만 결정됨. `PORT` 환경변수는 CLI 서버 포트 입력으로 사용하지 않음.
+선택한 포트가 이미 사용 중이면 기존 프로세스를 종료하거나 다른 포트로 폴백하지 않고 에러와 함께 종료.
 
 Ctrl+C로 종료.
 
@@ -37,10 +56,14 @@ qgrid [options]
 
   --db <url>         PostgreSQL 연결 URL
   -p, --port <port>  서버 포트 (기본: 44900)
+  --skip-update      자동 업데이트 확인 생략
   -V, --version      버전 출력
   -h, --help         도움말
 ```
 
+CLI는 실행 시 npm의 최신 버전을 확인하고 major/minor 버전이 올라간 경우에만 자동 업데이트함.
+patch 버전 차이는 자동 업데이트 대상으로 보지 않음.
+
 ## 환경변수
 
 `--db` 플래그가 없으면 아래 환경변수에서 DB 접속 정보를 읽음:
@@ -48,89 +71,45 @@ qgrid [options]
 | 변수 | 기본값 |
 |------|--------|
 | `QGRID_DB_HOST` | `localhost` |
-| `QGRID_DB_PORT` | `44901` |
+| `QGRID_DB_PORT` | `5432` |
 | `QGRID_DB_USER` | `postgres` |
 | `QGRID_DB_PASSWORD` | `postgres` |
 | `QGRID_DB_NAME` | `qgrid` |
+| `QGRID_WORKERS_PER_TOKEN` | `3` (OpenAI 토큰당 codex worker 수, 최대 5) |
 
 ## 사전 요구사항
 
 - Node.js >= 20
-- [Claude CLI](https://www.npmjs.com/package/@anthropic-ai/claude-code) — `npm i -g @anthropic-ai/claude-code`
-- 접속 가능한 PostgreSQL
+- PostgreSQL
+- Docker (로컬 PostgreSQL을 컨테이너로 실행할 경우)
+- [Codex CLI](https://github.com/openai/codex) (OpenAI 모델 사용 시)
+- [Claude Code](https://www.anthropic.com/claude-code) (Anthropic 모델 사용 시)
 
 ## 동작 방식
 
-CLI는 Sonamu 기반 서버를 내장 번들로 포함하고 있음. 실행 시:
+CLI는 Sonamu 기반 서버를 내장 번들로 포함. 실행 시:
 
 1. DB 연결 확인
-2. Claude CLI 존재 확인
-3. `/tmp/qgrid/.claude/settings.json` 자동 생성 (thinking / git 가이드 off, session cleanup)
-4. 서버 시작 (API + 대시보드 웹 UI)
-5. `QgridDispatcher` 싱글턴이 DB 의 active 토큰을 로드
-6. 요청 도착 시 `claude -p` 프로세스를 새로 spawn → 응답 받고 종료 (fresh spawn 모델)
-
-Docker 불필요. Node.js + Claude CLI + PostgreSQL만 있으면 됨.
+2. 서버 시작 (API + 대시보드 웹 UI)
+3. DB의 등록된 토큰 로드
+4. **OpenAI 토큰**: 토큰당 codex app-server 프로세스 N개 spawn (기본 3). JSON-RPC로 통신. 병렬 요청 처리 + 큐잉.
+5. **Anthropic 토큰**: claude CLI를 통한 호출. OAuth 토큰 자동 refresh.
+6. 요청 도착 → idle worker에 라우팅 (round-robin) → 전부 busy면 큐 대기 (최대 60초)
 
-## End-to-end 예시
+Qgrid 앱 자체는 Docker에 의존하지 않지만 PostgreSQL은 필요함. 로컬 PostgreSQL이 없으면 Docker로 PostgreSQL을 띄우는 구성이 가장 간단함.
 
-서버를 띄운 뒤 SDK 또는 curl 로 호출:
+## SDK 연동
 
-### 1) 단순 텍스트 응답 — 논문 요약
+서버를 띄운 뒤 [`@cartanova/qgrid-ai-sdk`](../ai-sdk/README.md)로 호출:
 
 ```typescript
-import { queryQgrid } from "@cartanova/qgrid-sdk";
-
-const { data } = await queryQgrid({
-  system: `당신은 학술 논문 요약가입니다.
-- 입력은 논문 본문입니다.
-- 핵심 내용을 한 단락(3~5문장)으로 요약해주세요.`,
-  prompt: paperText,
-  model: "anthropic/claude-haiku-4.5",
-  projectName: "paper-digest",
-});
-// data: "이 연구는 ... 를 다룹니다. 저자들은 ... 를 제안하며 ..."
-```
+import { generateText } from "ai";
+import { qgrid } from "@cartanova/qgrid-ai-sdk";
 
-### 2) 구조화 응답 (Zod 스키마) — 논문 메타데이터 추출
-
-```typescript
-import { queryQgrid } from "@cartanova/qgrid-sdk";
-import { z } from "zod";
-
-const { data } = await queryQgrid({
-  system: `당신은 논문 분석가입니다.
-- 입력 본문에서 메타데이터와 핵심 내용을 추출해주세요.
-- title, authors 는 본문에 명시된 그대로 옮겨주세요.
-- keyFindings 는 결과 섹션에서 가장 중요한 3~5개를 골라주세요.`,
-  prompt: paperText,
-  model: "anthropic/claude-sonnet-4.6",
-  projectName: "paper-digest",
-  returnType: z.object({
-    title: z.string(),
-    authors: z.array(z.string()),
-    keyFindings: z.array(z.string()),
-  }),
+const { text } = await generateText({
+  model: qgrid("openai/gpt-5.4-mini"),
+  prompt: "서울 날씨 알려줘",
 });
-
-console.log(data.title, "—", data.authors.join(", "));
-console.log("핵심 발견:", data.keyFindings);
 ```
 
-스키마가 CLI 의 `--json-schema` 로 Anthropic API structured output tool 에 네이티브 전달 → **파싱 실패 0**.
-
-### 3) curl 로 직접 호출
-
-```bash
-curl -sS -X POST http://localhost:44900/api/qgrid/query \
-  -H "Content-Type: application/json" \
-  -d '{
-    "system": "논문 abstract 를 한 문장으로 요약해주세요.",
-    "prompt": "We propose a novel attention mechanism ...",
-    "model": "claude-haiku-4-5"
-  }'
-```
-
-> 서버 직접 호출 시 model 은 CLI 형식 (`claude-haiku-4-5`) 사용. SDK 는 `anthropic/claude-haiku-4.5` 형식을 자동 변환.
-
-자세한 SDK 옵션은 [`@cartanova/qgrid-sdk` README](https://www.npmjs.com/package/@cartanova/qgrid-sdk) 참조.
+자세한 사용법은 [`@cartanova/qgrid-ai-sdk` README](../ai-sdk/README.md) 참조.

package/bundle/dist/application/qgrid/oauth.js

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

package/bundle/dist/application/qgrid/qgrid-run-lifecycle.js

@@ -0,0 +1,137 @@
+import "../../_virtual/_rolldown/runtime.js";
+import { RequestLogModel } from "../request-log/request-log.model.js";
+import { getLogger } from "@logtape/logtape";
+//#region src/application/qgrid/qgrid-run-lifecycle.ts
+const logger = getLogger(["qgrid", "run-lifecycle"]);
+const STALE_RUN_THRESHOLD_MS = 1800 * 1e3;
+/**
+* history는 원본 그대로 저장하기보다는, run 분석에 필요한 user/assistant 정보만 필터링해서 저장
+*/
+function filterHistoryForStorage(rawHistory) {
+	if (!rawHistory) return void 0;
+	try {
+		const filtered = JSON.parse(rawHistory).filter((item) => {
+			if (!item || typeof item !== "object") return false;
+			const record = item;
+			return record.type === "message" && (record.role === "user" || record.role === "assistant");
+		});
+		return filtered.length > 0 ? filtered : void 0;
+	} catch {
+		return;
+	}
+}
+/**
+* logMode:"run" 시 query/stream 응답 전후에 호출.
+*
+* 1) beforeQuery: run 생성/계속 + tool result 완료 + stale cleanup
+* 2) afterQuery: generate step + tool-call step + finish/keep-open
+*/
+async function beforeQuery(args) {
+	await cleanupStaleRuns();
+	let requestLogId;
+	let stepIndex = 0;
+	if (args.runContext) {
+		requestLogId = args.runContext.requestLogId;
+		if (args.toolResults && args.toolResults.length > 0) await completeToolResults(requestLogId, args.toolResults);
+		stepIndex = await RequestLogModel.getNextStepIndex(requestLogId);
+	} else requestLogId = await RequestLogModel.createRun({
+		user_prompt: args.prompt,
+		system_prompt: args.system,
+		model_name: args.model,
+		effort: args.effort,
+		project_name: args.projectName
+	});
+	return {
+		requestLogId,
+		stepIndex
+	};
+}
+async function afterQuery(requestLogId, stepIndex, args, result) {
+	await RequestLogModel.appendStep(requestLogId, {
+		step_index: stepIndex,
+		type: "generate",
+		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,
+		finish_reason: result.finishReason
+	});
+	if (result.finishReason === "tool-calls") {
+		const toolCalls = result.content.filter((c) => c.type === "tool-call");
+		for (let i = 0; i < toolCalls.length; i++) {
+			const tc = toolCalls[i];
+			if (tc.type !== "tool-call") continue;
+			await RequestLogModel.appendStep(requestLogId, {
+				step_index: stepIndex,
+				type: "tool_call",
+				tool_call_index: i,
+				tool_call_id: tc.toolCallId,
+				tool_name: tc.toolName,
+				tool_args: tc.input
+			});
+		}
+		return { runContext: { requestLogId } };
+	}
+	const agg = await RequestLogModel.aggregateStepUsage(requestLogId);
+	await RequestLogModel.finishRun(requestLogId, {
+		status: "succeeded",
+		response: result.text,
+		token_name: result.tokenName,
+		input_tokens: agg.input_tokens,
+		output_tokens: agg.output_tokens,
+		cache_read_tokens: agg.cache_read_tokens,
+		cache_creation_tokens: agg.cache_creation_tokens,
+		duration_ms: agg.duration_ms,
+		history: filterHistoryForStorage(args.history)
+	});
+	return {};
+}
+async function finishRunWithError(requestLogId, errorMessage, args) {
+	try {
+		await RequestLogModel.finishRun(requestLogId, {
+			status: "error",
+			error_message: errorMessage,
+			history: args ? filterHistoryForStorage(args.history) : void 0
+		});
+	} catch (e) {
+		logger.error(`finishRunWithError failed: ${e.message}`);
+	}
+}
+async function finishRunAborted(requestLogId, args) {
+	try {
+		await RequestLogModel.finishRun(requestLogId, {
+			status: "aborted",
+			error_message: "client disconnected",
+			history: args ? filterHistoryForStorage(args.history) : void 0
+		});
+	} catch (e) {
+		logger.error(`finishRunAborted failed: ${e.message}`);
+	}
+}
+async function completeToolResults(requestLogId, toolResults) {
+	for (const tr of toolResults) try {
+		await RequestLogModel.completeToolCall(requestLogId, tr.toolCallId, {
+			tool_result: tr.isError ? void 0 : tr.output,
+			error: tr.isError ? tr.output : void 0
+		});
+	} catch (e) {
+		logger.error(`completeToolCall failed for ${tr.toolCallId}: ${e.message}`);
+	}
+}
+async function cleanupStaleRuns() {
+	try {
+		const staleIds = await RequestLogModel.findStaleRunningIds(STALE_RUN_THRESHOLD_MS);
+		for (const id of staleIds) await RequestLogModel.finishRun(id, {
+			status: "error",
+			error_message: "tool-call run: no follow-up within 30 minutes"
+		});
+		if (staleIds.length > 0) logger.info(`cleaned up ${staleIds.length} stale running request logs`);
+	} catch (e) {
+		logger.error(`stale cleanup failed: ${e.message}`);
+	}
+}
+//#endregion
+export { afterQuery, beforeQuery, finishRunAborted, finishRunWithError };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"qgrid-run-lifecycle.js","names":[],"sources":["../../../src/application/qgrid/qgrid-run-lifecycle.ts"],"sourcesContent":["import { getLogger } from \"@logtape/logtape\";\n\nimport { RequestLogModel } from \"../request-log/request-log.model\";\nimport {\n  type QgridRunContext,\n  type QgridToolResultInput,\n  type QueryInput,\n  type QueryOutput,\n} from \"./qgrid.types\";\n\nconst logger = getLogger([\"qgrid\", \"run-lifecycle\"]);\nconst STALE_RUN_THRESHOLD_MS = 30 * 60 * 1000;\n\n/**\n * history는 원본 그대로 저장하기보다는, run 분석에 필요한 user/assistant 정보만 필터링해서 저장\n */\nfunction filterHistoryForStorage(rawHistory: string | undefined): unknown {\n  if (!rawHistory) return undefined;\n  try {\n    const items = JSON.parse(rawHistory) as unknown[];\n    const filtered = items.filter((item) => {\n      if (!item || typeof item !== \"object\") return false;\n      const record = item as Record<string, unknown>;\n      return record.type === \"message\" && (record.role === \"user\" || record.role === \"assistant\");\n    });\n    return filtered.length > 0 ? filtered : undefined;\n  } catch {\n    return undefined;\n  }\n}\n\nexport type RunLifecycleResult = {\n  runContext?: QgridRunContext;\n};\n\n/**\n * logMode:\"run\" 시 query/stream 응답 전후에 호출.\n *\n * 1) beforeQuery: run 생성/계속 + tool result 완료 + stale cleanup\n * 2) afterQuery: generate step + tool-call step + finish/keep-open\n */\nexport async function beforeQuery(args: QueryInput): Promise<{\n  requestLogId: number;\n  stepIndex: number;\n}> {\n  await cleanupStaleRuns();\n\n  let requestLogId: number;\n  let stepIndex = 0;\n\n  if (args.runContext) {\n    requestLogId = args.runContext.requestLogId;\n\n    if (args.toolResults && args.toolResults.length > 0) {\n      await completeToolResults(requestLogId, args.toolResults);\n    }\n\n    stepIndex = await RequestLogModel.getNextStepIndex(requestLogId);\n  } else {\n    requestLogId = await RequestLogModel.createRun({\n      user_prompt: args.prompt,\n      system_prompt: args.system,\n      model_name: args.model,\n      effort: args.effort,\n      project_name: args.projectName,\n    });\n  }\n\n  return { requestLogId, stepIndex };\n}\n\nexport async function afterQuery(\n  requestLogId: number,\n  stepIndex: number,\n  args: QueryInput,\n  result: QueryOutput,\n): Promise<RunLifecycleResult> {\n  // generate step 기록\n  await RequestLogModel.appendStep(requestLogId, {\n    step_index: stepIndex,\n    type: \"generate\",\n    input_tokens: result.usage.input_tokens,\n    output_tokens: result.usage.output_tokens,\n    cache_read_tokens: result.usage.cache_read_input_tokens,\n    cache_creation_tokens: result.usage.cache_creation_input_tokens,\n    duration_ms: result.durationMs,\n    finish_reason: result.finishReason,\n  });\n\n  if (result.finishReason === \"tool-calls\") {\n    // tool-call step 즉시 기록 (result는 나중에 completeToolCall로 채움)\n    const toolCalls = result.content.filter((c) => c.type === \"tool-call\");\n    for (let i = 0; i < toolCalls.length; i++) {\n      const tc = toolCalls[i]!;\n      if (tc.type !== \"tool-call\") continue;\n      await RequestLogModel.appendStep(requestLogId, {\n        step_index: stepIndex,\n        type: \"tool_call\",\n        tool_call_index: i,\n        tool_call_id: tc.toolCallId,\n        tool_name: tc.toolName,\n        tool_args: tc.input,\n      });\n    }\n\n    return { runContext: { requestLogId } };\n  }\n\n  // finishReason === \"stop\" → run 종료 (전체 step usage 합산)\n  const agg = await RequestLogModel.aggregateStepUsage(requestLogId);\n  await RequestLogModel.finishRun(requestLogId, {\n    status: \"succeeded\",\n    response: result.text,\n    token_name: result.tokenName,\n    input_tokens: agg.input_tokens,\n    output_tokens: agg.output_tokens,\n    cache_read_tokens: agg.cache_read_tokens,\n    cache_creation_tokens: agg.cache_creation_tokens,\n    duration_ms: agg.duration_ms,\n    history: filterHistoryForStorage(args.history),\n  });\n\n  return {};\n}\n\nexport async function finishRunWithError(\n  requestLogId: number,\n  errorMessage: string,\n  args?: QueryInput,\n): Promise<void> {\n  try {\n    await RequestLogModel.finishRun(requestLogId, {\n      status: \"error\",\n      error_message: errorMessage,\n      history: args ? filterHistoryForStorage(args.history) : undefined,\n    });\n  } catch (e) {\n    logger.error(`finishRunWithError failed: ${(e as Error).message}`);\n  }\n}\n\nexport async function finishRunAborted(requestLogId: number, args?: QueryInput): Promise<void> {\n  try {\n    await RequestLogModel.finishRun(requestLogId, {\n      status: \"aborted\",\n      error_message: \"client disconnected\",\n      history: args ? filterHistoryForStorage(args.history) : undefined,\n    });\n  } catch (e) {\n    logger.error(`finishRunAborted failed: ${(e as Error).message}`);\n  }\n}\n\nasync function completeToolResults(\n  requestLogId: number,\n  toolResults: QgridToolResultInput[],\n): Promise<void> {\n  for (const tr of toolResults) {\n    try {\n      await RequestLogModel.completeToolCall(requestLogId, tr.toolCallId, {\n        tool_result: tr.isError ? undefined : tr.output,\n        error: tr.isError ? tr.output : undefined,\n      });\n    } catch (e) {\n      logger.error(`completeToolCall failed for ${tr.toolCallId}: ${(e as Error).message}`);\n    }\n  }\n}\n\nasync function cleanupStaleRuns(): Promise<void> {\n  try {\n    const staleIds = await RequestLogModel.findStaleRunningIds(STALE_RUN_THRESHOLD_MS);\n    for (const id of staleIds) {\n      await RequestLogModel.finishRun(id, {\n        status: \"error\",\n        error_message: \"tool-call run: no follow-up within 30 minutes\",\n      });\n    }\n    if (staleIds.length > 0) {\n      logger.info(`cleaned up ${staleIds.length} stale running request logs`);\n    }\n  } catch (e) {\n    logger.error(`stale cleanup failed: ${(e as Error).message}`);\n  }\n}\n"],"mappings":"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"}