@cartanova/qgrid-cli 1.9.0 → 2.0.0

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

@@ -1,6 +1,11 @@
 import "../../_virtual/_rolldown/runtime.js";
+import { calculateCostUsd } from "../../utils/providers/common/model-cost.js";
+import { getAccessToken, getExpiresAt, getRefreshToken } from "../../utils/providers/common/credentials.js";
+import { strictify } from "../../utils/providers/common/strictifier.js";
 import { ProcessError, QuotaError, TimeoutError, maskToken } from "./qgrid.types.js";
+import { applyToolCallEmulation, buildToolCallSchema } from "./tool-emulation.js";
 import { getLogger } from "@logtape/logtape";
+import assert from "node:assert";
 import { spawn } from "node:child_process";
 import { mkdirSync, writeFileSync } from "node:fs";
 //#region src/application/qgrid/qgrid.dispatcher.ts
@@ -33,6 +38,7 @@ var QgridDispatcherClass = class {
 	requestCounts = /* @__PURE__ */ new Map();
 	rrIndex = 0;
 	subscriber = null;
+	openaiDispatcher = null;
 	constructor() {
 		const settingsJson = JSON.stringify(QGRID_CLAUDE_SETTINGS, null, 2);
 		mkdirSync(`${CLAUDE_CWD}/.claude`, { recursive: true });
@@ -55,13 +61,14 @@ var QgridDispatcherClass = class {
 	}
 	getStats() {
 		return [...this.tokens.values()].map((r) => ({
-			token: r.token,
+			token: maskToken(getAccessToken(r.credentials)),
 			name: r.name,
+			provider: r.provider,
 			requests: this.countOf(r.name)
 		}));
 	}
-	selectToken() {
-		const rows = [...this.tokens.values()];
+	selectToken(provider = "anthropic") {
+		const rows = [...this.tokens.values()].filter((r) => r.provider === provider);
 		if (rows.length === 0) return null;
 		const minCount = Math.min(...rows.map((r) => this.countOf(r.name)));
 		const idle = rows.filter((r) => this.countOf(r.name) === minCount);
@@ -70,31 +77,124 @@ var QgridDispatcherClass = class {
 		return picked;
 	}
 	async query(input, timeoutMs) {
+		if (input.tools?.length && input.jsonSchema) throw new ProcessError("tools and jsonSchema cannot be used together");
+		const outputSchema = input.tools?.length ? buildToolCallSchema(input.tools) : input.jsonSchema ? JSON.parse(input.jsonSchema) : void 0;
+		if (input.model?.includes("/")) {
+			const [provider, model] = input.model.split("/", 2);
+			assert(model, "unknown model");
+			if (provider === "openai") {
+				if (!this.openaiDispatcher) throw new QuotaError("OpenAI dispatcher not initialized");
+				const result = await this.openaiDispatcher.generate({
+					model,
+					input: [{
+						type: "text",
+						text: input.prompt,
+						text_elements: []
+					}],
+					systemPrompt: input.system,
+					outputSchema: outputSchema ? strictify(outputSchema) : void 0,
+					effort: input.effort,
+					verbosity: input.verbosity,
+					reasoningSummary: input.reasoningSummary,
+					serviceTier: input.serviceTier,
+					history: input.history ? JSON.parse(input.history) : void 0
+				});
+				return applyToolCallEmulation({
+					text: result.text,
+					tokenName: result.tokenName,
+					model: result.model,
+					usage: {
+						input_tokens: result.usage.inputTokens,
+						output_tokens: result.usage.outputTokens,
+						cache_creation_input_tokens: 0,
+						cache_read_input_tokens: result.usage.cachedInputTokens
+					},
+					durationMs: result.durationMs,
+					costUsd: calculateCostUsd(result.model, {
+						inputTokens: result.usage.inputTokens,
+						outputTokens: result.usage.outputTokens,
+						cachedInputTokens: result.usage.cachedInputTokens
+					})
+				}, input.tools);
+			}
+		}
+		const executionInput = outputSchema && input.tools?.length ? {
+			...input,
+			jsonSchema: JSON.stringify(outputSchema)
+		} : input;
 		const electedToken = this.selectToken();
 		if (!electedToken) throw new QuotaError("No tokens available");
 		this.requestCounts.set(electedToken.name, this.countOf(electedToken.name) + 1);
-		let token = electedToken.token;
-		if (electedToken.expires_at && Number(electedToken.expires_at) - Date.now() < REFRESH_SAFETY_MS && electedToken.refresh_token) try {
+		let token = getAccessToken(electedToken.credentials);
+		const expiresAt = getExpiresAt(electedToken.credentials);
+		if (expiresAt && expiresAt - Date.now() < REFRESH_SAFETY_MS && getRefreshToken(electedToken.credentials)) try {
 			const { QgridFrame } = await import("./qgrid.frame.js");
-			token = await QgridFrame.refreshToken({
-				id: electedToken.id,
-				token: electedToken.token,
-				name: electedToken.name,
-				refresh_token: electedToken.refresh_token
-			});
+			token = await QgridFrame.refreshToken(electedToken);
 		} catch (e) {
 			logger.warn(`refresh failed for ${electedToken.name}: ${e.message}`);
 		}
 		logger.info(`→ ${electedToken.name} (model: ${input.model ?? DEFAULT_MODEL})`);
-		return {
-			...await executeClaude(input, token, timeoutMs ?? DEFAULT_TIMEOUT_MS),
+		return applyToolCallEmulation({
+			...await executeClaude(executionInput, token, timeoutMs ?? DEFAULT_TIMEOUT_MS),
 			tokenName: electedToken.name,
 			model: input.model ?? DEFAULT_MODEL
-		};
+		}, input.tools);
+	}
+	async queryStream(input, cb) {
+		if (!input.model?.startsWith("openai/")) {
+			const result = await this.query(input);
+			cb.onComplete(result);
+			return;
+		}
+		const [, model] = input.model.split("/", 2);
+		if (!model) throw new ProcessError("unknown model");
+		if (!this.openaiDispatcher) throw new QuotaError("OpenAI dispatcher not initialized");
+		const outputSchema = input.tools?.length ? buildToolCallSchema(input.tools) : input.jsonSchema ? JSON.parse(input.jsonSchema) : void 0;
+		await this.openaiDispatcher.generateStream({
+			model,
+			input: [{
+				type: "text",
+				text: input.prompt,
+				text_elements: []
+			}],
+			systemPrompt: input.system,
+			outputSchema: outputSchema ? strictify(outputSchema) : void 0,
+			effort: input.effort,
+			verbosity: input.verbosity,
+			reasoningSummary: input.reasoningSummary,
+			serviceTier: input.serviceTier,
+			history: input.history ? JSON.parse(input.history) : void 0
+		}, {
+			onDelta: cb.onDelta,
+			onThreadId: cb.onThreadId,
+			onTurnId: cb.onTurnId,
+			onComplete: (turnResult) => {
+				const applied = applyToolCallEmulation({
+					text: turnResult.text,
+					tokenName: turnResult.tokenName,
+					model: turnResult.model,
+					usage: {
+						input_tokens: turnResult.usage.inputTokens,
+						output_tokens: turnResult.usage.outputTokens,
+						cache_creation_input_tokens: 0,
+						cache_read_input_tokens: turnResult.usage.cachedInputTokens
+					},
+					durationMs: turnResult.durationMs,
+					costUsd: calculateCostUsd(turnResult.model, {
+						inputTokens: turnResult.usage.inputTokens,
+						outputTokens: turnResult.usage.outputTokens,
+						cachedInputTokens: turnResult.usage.cachedInputTokens
+					})
+				}, input.tools);
+				cb.onComplete(applied);
+			},
+			onError: cb.onError
+		});
 	}
 };
 async function executeClaude(input, token, timeoutMs) {
-	const model = input.model ?? DEFAULT_MODEL;
+	const rawModel = input.model ?? DEFAULT_MODEL;
+	const model = rawModel.includes("/") ? rawModel.split("/").pop() : rawModel;
 	const timeout = input.timeout ?? timeoutMs;
 	const useStructuredOutput = input.jsonSchema && input.jsonSchema.length > 0;
 	const args = [
@@ -217,4 +317,4 @@ const QgridDispatcher = new QgridDispatcherClass();
 //#endregion
 export { QgridDispatcher, QgridDispatcherClass };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"qgrid.dispatcher.js","names":[],"sources":["../../../src/application/qgrid/qgrid.dispatcher.ts"],"sourcesContent":["/**\n * QgridDispatcher — OAuth 토큰 선택 + claude CLI fresh spawn 디스패처 싱글턴.\n *\n * - 매 요청마다 새 claude CLI 프로세스 spawn → 응답 후 종료\n * - least-used round-robin 으로 토큰 선택\n * - 메모리 캐시 (Map<id, TokenSubsetA>) 는 TokenSubscriber 가 pg LISTEN/NOTIFY 로 갱신\n * - query 시 expires_at 비교 → 임박 시 preemptive refresh\n * - QuotaError 는 그대로 상위 전파 (자동 failover 없음, UI 에서 수동 토글)\n *\n * env allowlist: PATH, TMPDIR, CLAUDE_CODE_OAUTH_TOKEN, CLAUDE_CONFIG_DIR\n *   + CLAUDE_CODE_DISABLE_* + CLAUDE_CODE_ATTRIBUTION_HEADER\n */\nimport { spawn } from \"node:child_process\";\nimport { mkdirSync, writeFileSync } from \"node:fs\";\n\nimport { getLogger } from \"@logtape/logtape\";\n\nimport { type TokenSubsetA } from \"../sonamu.generated\";\nimport { type CliResult, type QueryInput, type TokenStats } from \"./qgrid.types\";\nimport { maskToken, ProcessError, QuotaError, TimeoutError } from \"./qgrid.types\";\nimport { type TokenSubscriber } from \"./token-subscriber\";\n\nconst logger = getLogger([\"qgrid\"]);\n\nconst DEFAULT_MODEL = \"sonnet\";\nconst DEFAULT_TIMEOUT_MS = 600_000;\nconst DEFAULT_EFFORT = \"high\";\n\n// claude CLI 의 cwd. 이 경로의 .claude/settings.json 이 project scope 로 로드되어\n// 혹시라도 있을 user scope (~/.claude/settings.json)를 덮어씀 (--setting-sources project 와 함께).\nconst CLAUDE_CWD = \"/tmp/qgrid\";\n\n// 글로벌 user config 격리 경로. (CC에서 환경변수로 읽는변수)\nconst CLAUDE_CONFIG_DIR = \"/tmp/qgrid-config\";\n\n// qgrid 전용 project/global settings — user scope 격리용\nconst QGRID_CLAUDE_SETTINGS = {\n  alwaysThinkingEnabled: false, // thinking block 차단\n  includeGitInstructions: false, // system prompt 의 git 가이드 제거\n  cleanupPeriodDays: 1,\n};\n\n// 토큰 만료 임박 임계값 — token.expiredAt이 1분 안에 만료된다면 query 시 체크하고 refresh.\nconst REFRESH_SAFETY_MS = 60_000;\n\nexport class QgridDispatcherClass {\n  tokens = new Map<number, TokenSubsetA>();\n\n  // key기반(tokenName) 누적 카운터. token 이 OAuth refresh 로 로테이트되도 tokenName 은 불변이라 카운터 유지됨\n  requestCounts = new Map<string, number>();\n  rrIndex = 0;\n\n  // sonamu.config onStart 에서 처리하는 변수\n  subscriber: TokenSubscriber | null = null;\n\n  constructor() {\n    const settingsJson = JSON.stringify(QGRID_CLAUDE_SETTINGS, null, 2);\n\n    mkdirSync(`${CLAUDE_CWD}/.claude`, { recursive: true });\n    writeFileSync(`${CLAUDE_CWD}/.claude/settings.json`, settingsJson);\n\n    mkdirSync(CLAUDE_CONFIG_DIR, { recursive: true });\n    writeFileSync(`${CLAUDE_CONFIG_DIR}/.claude.json`, \"{}\");\n    writeFileSync(`${CLAUDE_CONFIG_DIR}/settings.json`, settingsJson);\n  }\n\n  countOf(name: string): number {\n    return this.requestCounts.get(name) ?? 0;\n  }\n\n  // TokenSubscriber 콜백 — 캐시 mutation\n  upsertCache(id: number, row: TokenSubsetA): void {\n    this.tokens.set(id, row);\n  }\n\n  removeCache(id: number): void {\n    this.tokens.delete(id);\n  }\n\n  replaceCache(rows: TokenSubsetA[]): void {\n    this.tokens = new Map(rows.map((r) => [r.id, r]));\n  }\n\n  getStats(): TokenStats[] {\n    return [...this.tokens.values()].map((r) => ({\n      token: r.token,\n      name: r.name,\n      requests: this.countOf(r.name),\n    }));\n  }\n\n  selectToken(): TokenSubsetA | null {\n    const rows = [...this.tokens.values()];\n    if (rows.length === 0) return null;\n\n    const minCount = Math.min(...rows.map((r) => this.countOf(r.name)));\n    const idle = rows.filter((r) => this.countOf(r.name) === minCount);\n    const picked = idle[this.rrIndex % idle.length]!;\n    this.rrIndex++;\n    return picked;\n  }\n\n  async query(input: QueryInput, timeoutMs?: number): Promise<CliResult> {\n    const electedToken = this.selectToken();\n    if (!electedToken) throw new QuotaError(\"No tokens available\");\n\n    // await 전에 count 선반영. 병렬 요청이 동시에 도착해도 각자 다른 토큰을 고르도록.\n    this.requestCounts.set(electedToken.name, this.countOf(electedToken.name) + 1);\n\n    let token = electedToken.token;\n    // expires_at 임박이면 refresh.\n    // refresh 후 DB save → trigger NOTIFY → subscriber 가 받아 캐시 갱신 (다른 dispatcher 도 동기화)\n    if (\n      electedToken.expires_at &&\n      Number(electedToken.expires_at) - Date.now() < REFRESH_SAFETY_MS &&\n      electedToken.refresh_token\n    ) {\n      try {\n        const { QgridFrame } = await import(\"./qgrid.frame\");\n        token = await QgridFrame.refreshToken({\n          id: electedToken.id,\n          token: electedToken.token,\n          name: electedToken.name,\n          refresh_token: electedToken.refresh_token,\n        });\n      } catch (e) {\n        logger.warn(`refresh failed for ${electedToken.name}: ${(e as Error).message}`);\n        // refresh 실패 시 기존 token 으로 진행. executeClaude 가 401 받으면 caller 처리.\n      }\n    }\n\n    logger.info(`→ ${electedToken.name} (model: ${input.model ?? DEFAULT_MODEL})`);\n\n    const result = await executeClaude(input, token, timeoutMs ?? DEFAULT_TIMEOUT_MS);\n    return { ...result, tokenName: electedToken.name, model: input.model ?? DEFAULT_MODEL };\n  }\n}\n\nasync function executeClaude(\n  input: QueryInput,\n  token: string,\n  timeoutMs: number,\n): Promise<CliResult> {\n  const model = input.model ?? DEFAULT_MODEL;\n  const timeout = input.timeout ?? timeoutMs;\n  const useStructuredOutput = input.jsonSchema && input.jsonSchema.length > 0;\n\n  // --tools \"\" 로 모든 tool 을 기본 차단. structured output 쓰면 StructuredOutput 만 화이트리스트.\n  // --tools \"\" 는 반드시 뒤에 다른 플래그가 와야 CLI 파싱이 빈 문자열로 인식\n  const toolArgs = useStructuredOutput\n    ? [\"--tools\", \"\", \"--allowed-tools\", \"StructuredOutput\"]\n    : [\"--tools\", \"\"];\n\n  const args: string[] = [\n    \"-p\",\n    ...toolArgs,\n    \"--disallowedTools\",\n    // CC에서 자동 활성화되는 deferred 도구. 토큰 최적화를위해 차단\n    ...([\"Monitor\", \"PushNotification\", \"RemoteTrigger\"] as const),\n    \"--output-format\",\n    \"stream-json\",\n    \"--verbose\",\n    // --max-turns: structured output 은 tool_use + tool_result 로 2턴 소비\n    \"--max-turns\",\n    useStructuredOutput ? \"2\" : \"1\",\n    \"--permission-mode\",\n    \"bypassPermissions\",\n    \"--setting-sources\",\n    \"project\",\n    \"--model\",\n    model,\n    // --system-prompt는 반드시 명시해야함. 옵션 생략 시 CC가 default system prompt를 자동으로 주입함(23k)\n    \"--system-prompt\",\n    input.system ?? \"\",\n    \"--thinking\",\n    \"disabled\",\n    \"--effort\",\n    input.effort ?? DEFAULT_EFFORT,\n    \"--no-session-persistence\",\n    // 모든 skills 비활성화\n    \"--disable-slash-commands\",\n  ];\n  if (useStructuredOutput) {\n    args.push(\"--json-schema\", input.jsonSchema!);\n  }\n  args.push(input.prompt);\n\n  const env: NodeJS.ProcessEnv = {\n    PATH: process.env.PATH,\n    TMPDIR: process.env.TMPDIR,\n    CLAUDE_CODE_OAUTH_TOKEN: token,\n    // CLAUDE_CONFIG_DIR 환경변수로 주입\n    CLAUDE_CONFIG_DIR,\n    CLAUDE_CODE_DISABLE_AUTO_MEMORY: \"1\",\n    CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING: \"1\",\n    CLAUDE_CODE_DISABLE_1M_CONTEXT: \"1\",\n    CLAUDE_CODE_DISABLE_CLAUDE_MDS: \"1\",\n    CLAUDE_CODE_ATTRIBUTION_HEADER: \"0\",\n  };\n\n  return new Promise<CliResult>((resolve, reject) => {\n    const child = spawn(\"claude\", args, {\n      stdio: [\"ignore\", \"pipe\", \"ignore\"],\n      env,\n      // 격리 (두 단계):\n      // 1. CLAUDE_CWD — project scope 격리 (cwd 의 .claude/settings.json)\n      // 2. CLAUDE_CONFIG_DIR — user scope 격리 cwd 격리만으론 부족.\n      cwd: CLAUDE_CWD,\n    });\n\n    let buffer = \"\";\n    let settled = false;\n    const timer = setTimeout(() => {\n      if (settled) return;\n      settled = true;\n      child.kill();\n      reject(new TimeoutError(`Timeout after ${timeout / 1000}s (token: ${maskToken(token)})`));\n    }, timeout);\n\n    child.stdout?.on(\"data\", (d: Buffer) => {\n      if (settled) return;\n      buffer += d.toString();\n      const lines = buffer.split(\"\\n\");\n      buffer = lines.pop() ?? \"\";\n      for (const line of lines) {\n        if (!line.trim()) continue;\n        try {\n          const j = JSON.parse(line);\n          if (j.type === \"result\" && !settled) {\n            // --json-schema 사용 시 structured_output 에 파싱된 객체가 온다 → 우선 사용\n            let text: string;\n            if (j.structured_output !== undefined) {\n              text = JSON.stringify(j.structured_output);\n            } else {\n              text = (j.result ?? \"\")\n                .replace(/^```(?:json)?\\s*\\n?/i, \"\")\n                .replace(/\\n?```\\s*$/i, \"\");\n            }\n\n            if (text.startsWith(\"You've hit\")) {\n              settled = true;\n              clearTimeout(timer);\n              reject(new QuotaError(`Quota exhausted (token: ${maskToken(token)})`));\n              return;\n            }\n\n            const u = j.usage ?? {};\n            settled = true;\n            clearTimeout(timer);\n            resolve({\n              text,\n              usage: {\n                input_tokens: u.input_tokens ?? 0,\n                output_tokens: u.output_tokens ?? 0,\n                cache_creation_input_tokens: u.cache_creation_input_tokens ?? 0,\n                cache_read_input_tokens: u.cache_read_input_tokens ?? 0,\n              },\n              durationMs: j.duration_ms ?? 0,\n              costUsd: j.total_cost_usd ?? 0,\n            });\n          }\n        } catch {}\n      }\n    });\n\n    child.on(\"close\", () => {\n      if (settled) return;\n      settled = true;\n      clearTimeout(timer);\n      reject(new ProcessError(`CLI process closed without result (token: ${maskToken(token)})`));\n    });\n\n    child.on(\"error\", (err) => {\n      if (settled) return;\n      settled = true;\n      clearTimeout(timer);\n      reject(new ProcessError(`CLI process error: ${err.message} (token: ${maskToken(token)})`));\n    });\n  });\n}\n\nexport const QgridDispatcher = new QgridDispatcherClass();\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"qgrid.dispatcher.js","names":[],"sources":["../../../src/application/qgrid/qgrid.dispatcher.ts"],"sourcesContent":["import assert from \"node:assert\";\n/**\n * QgridDispatcher — OAuth 토큰 선택 + claude CLI fresh spawn 디스패처 싱글턴.\n *\n * - 매 요청마다 새 claude CLI 프로세스 spawn → 응답 후 종료\n * - least-used round-robin 으로 토큰 선택\n * - 메모리 캐시 (Map<id, TokenSubsetA>) 는 TokenSubscriber 가 pg LISTEN/NOTIFY 로 갱신\n * - query 시 expires_at 비교 → 임박 시 preemptive refresh\n * - QuotaError 는 그대로 상위 전파 (자동 failover 없음, UI 에서 수동 토글)\n *\n * env allowlist: PATH, TMPDIR, CLAUDE_CODE_OAUTH_TOKEN, CLAUDE_CONFIG_DIR\n *   + CLAUDE_CODE_DISABLE_* + CLAUDE_CODE_ATTRIBUTION_HEADER\n */\nimport { spawn } from \"node:child_process\";\nimport { mkdirSync, writeFileSync } from \"node:fs\";\n\nimport { getLogger } from \"@logtape/logtape\";\n\nimport { type JsonValue } from \"../../codex-protocol/serde_json/JsonValue\";\nimport {\n  getAccessToken,\n  getExpiresAt,\n  getRefreshToken,\n} from \"../../utils/providers/common/credentials\";\nimport { calculateCostUsd } from \"../../utils/providers/common/model-cost\";\nimport { strictify } from \"../../utils/providers/common/strictifier\";\nimport { type OpenAIDispatcher } from \"../../utils/providers/openai/openai-dispatcher\";\nimport { type TokenSubsetA } from \"../sonamu.generated\";\nimport { type QueryInput, type QueryOutput, type TokenStats } from \"./qgrid.types\";\nimport { maskToken, ProcessError, QuotaError, TimeoutError } from \"./qgrid.types\";\nimport { type TokenSubscriber } from \"./token-subscriber\";\nimport { applyToolCallEmulation, buildToolCallSchema } from \"./tool-emulation\";\n\nconst logger = getLogger([\"qgrid\"]);\n\nconst DEFAULT_MODEL = \"sonnet\";\nconst DEFAULT_TIMEOUT_MS = 600_000;\nconst DEFAULT_EFFORT = \"high\";\n\n// claude CLI 의 cwd. 이 경로의 .claude/settings.json 이 project scope 로 로드되어\n// 혹시라도 있을 user scope (~/.claude/settings.json)를 덮어씀 (--setting-sources project 와 함께).\nconst CLAUDE_CWD = \"/tmp/qgrid\";\n\n// 글로벌 user config 격리 경로. (CC에서 환경변수로 읽는변수)\nconst CLAUDE_CONFIG_DIR = \"/tmp/qgrid-config\";\n\n// qgrid 전용 project/global settings — user scope 격리용\nconst QGRID_CLAUDE_SETTINGS = {\n  alwaysThinkingEnabled: false, // thinking block 차단\n  includeGitInstructions: false, // system prompt 의 git 가이드 제거\n  cleanupPeriodDays: 1,\n};\n\n// 토큰 만료 임박 임계값 — token.expiredAt이 1분 안에 만료된다면 query 시 체크하고 refresh.\nconst REFRESH_SAFETY_MS = 60_000;\n\nexport class QgridDispatcherClass {\n  tokens = new Map<number, TokenSubsetA>();\n\n  // key기반(tokenName) 누적 카운터. token 이 OAuth refresh 로 로테이트되도 tokenName 은 불변이라 카운터 유지됨\n  requestCounts = new Map<string, number>();\n  rrIndex = 0;\n\n  // sonamu.config onStart 에서 처리하는 변수\n  subscriber: TokenSubscriber | null = null;\n  openaiDispatcher: OpenAIDispatcher | null = null;\n\n  constructor() {\n    const settingsJson = JSON.stringify(QGRID_CLAUDE_SETTINGS, null, 2);\n\n    mkdirSync(`${CLAUDE_CWD}/.claude`, { recursive: true });\n    writeFileSync(`${CLAUDE_CWD}/.claude/settings.json`, settingsJson);\n\n    mkdirSync(CLAUDE_CONFIG_DIR, { recursive: true });\n    writeFileSync(`${CLAUDE_CONFIG_DIR}/.claude.json`, \"{}\");\n    writeFileSync(`${CLAUDE_CONFIG_DIR}/settings.json`, settingsJson);\n  }\n\n  countOf(name: string): number {\n    return this.requestCounts.get(name) ?? 0;\n  }\n\n  // TokenSubscriber 콜백 — 캐시 mutation\n  upsertCache(id: number, row: TokenSubsetA): void {\n    this.tokens.set(id, row);\n  }\n\n  removeCache(id: number): void {\n    this.tokens.delete(id);\n  }\n\n  replaceCache(rows: TokenSubsetA[]): void {\n    this.tokens = new Map(rows.map((r) => [r.id, r]));\n  }\n\n  getStats(): TokenStats[] {\n    return [...this.tokens.values()].map((r) => ({\n      token: maskToken(getAccessToken(r.credentials)),\n      name: r.name,\n      provider: r.provider,\n      requests: this.countOf(r.name),\n    }));\n  }\n\n  selectToken(provider = \"anthropic\"): TokenSubsetA | null {\n    const rows = [...this.tokens.values()].filter((r) => r.provider === provider);\n    if (rows.length === 0) return null;\n\n    const minCount = Math.min(...rows.map((r) => this.countOf(r.name)));\n    const idle = rows.filter((r) => this.countOf(r.name) === minCount);\n    const picked = idle[this.rrIndex % idle.length]!;\n    this.rrIndex++;\n    return picked;\n  }\n\n  async query(input: QueryInput, timeoutMs?: number): Promise<QueryOutput> {\n    if (input.tools?.length && input.jsonSchema) {\n      throw new ProcessError(\"tools and jsonSchema cannot be used together\");\n    }\n\n    const outputSchema = input.tools?.length\n      ? buildToolCallSchema(input.tools)\n      : input.jsonSchema\n        ? (JSON.parse(input.jsonSchema) as JsonValue)\n        : undefined;\n\n    // provider prefix routing: 'openai/gpt-5.4' → OpenAIDispatcher\n    if (input.model?.includes(\"/\")) {\n      const [provider, model] = input.model.split(\"/\", 2);\n      assert(model, \"unknown model\");\n      if (provider === \"openai\") {\n        if (!this.openaiDispatcher) throw new QuotaError(\"OpenAI dispatcher not initialized\");\n        const result = await this.openaiDispatcher.generate({\n          model: model,\n          input: [{ type: \"text\" as const, text: input.prompt, text_elements: [] }],\n          systemPrompt: input.system,\n          outputSchema: outputSchema\n            ? (strictify(outputSchema as Parameters<typeof strictify>[0]) as JsonValue)\n            : undefined,\n          effort: input.effort,\n          verbosity: input.verbosity,\n          reasoningSummary: input.reasoningSummary,\n          serviceTier: input.serviceTier,\n          history: input.history ? JSON.parse(input.history) : undefined,\n        });\n\n        return applyToolCallEmulation(\n          {\n            text: result.text,\n            tokenName: result.tokenName,\n            model: result.model,\n            usage: {\n              input_tokens: result.usage.inputTokens,\n              output_tokens: result.usage.outputTokens,\n              cache_creation_input_tokens: 0,\n              cache_read_input_tokens: result.usage.cachedInputTokens,\n            },\n            durationMs: result.durationMs,\n            costUsd: calculateCostUsd(result.model, {\n              inputTokens: result.usage.inputTokens,\n              outputTokens: result.usage.outputTokens,\n              cachedInputTokens: result.usage.cachedInputTokens,\n            }),\n          },\n          input.tools,\n        );\n      }\n    }\n\n    const executionInput =\n      outputSchema && input.tools?.length\n        ? { ...input, jsonSchema: JSON.stringify(outputSchema) }\n        : input;\n\n    // Anthropic (기존 claude -p 경로)\n    const electedToken = this.selectToken();\n    if (!electedToken) throw new QuotaError(\"No tokens available\");\n\n    // await 전에 count 선반영. 병렬 요청이 동시에 도착해도 각자 다른 토큰을 고르도록.\n    this.requestCounts.set(electedToken.name, this.countOf(electedToken.name) + 1);\n\n    let token = getAccessToken(electedToken.credentials);\n    // expires_at 임박이면 preemptive refresh\n    const expiresAt = getExpiresAt(electedToken.credentials);\n    if (\n      expiresAt &&\n      expiresAt - Date.now() < REFRESH_SAFETY_MS &&\n      getRefreshToken(electedToken.credentials)\n    ) {\n      try {\n        const { QgridFrame } = await import(\"./qgrid.frame\");\n        token = await QgridFrame.refreshToken(electedToken);\n      } catch (e) {\n        logger.warn(`refresh failed for ${electedToken.name}: ${(e as Error).message}`);\n      }\n    }\n\n    logger.info(`→ ${electedToken.name} (model: ${input.model ?? DEFAULT_MODEL})`);\n\n    const result = await executeClaude(executionInput, token, timeoutMs ?? DEFAULT_TIMEOUT_MS);\n    return applyToolCallEmulation(\n      { ...result, tokenName: electedToken.name, model: input.model ?? DEFAULT_MODEL },\n      input.tools,\n    );\n  }\n\n  async queryStream(\n    input: QueryInput,\n    cb: {\n      onDelta: (text: string) => void;\n      onComplete: (result: QueryOutput) => void;\n      onError: (error: Error) => void;\n      onThreadId?: (threadId: string) => void;\n      onTurnId?: (turnId: string) => void;\n    },\n  ): Promise<void> {\n    if (!input.model?.startsWith(\"openai/\")) {\n      const result = await this.query(input);\n      cb.onComplete(result);\n      return;\n    }\n\n    const [, model] = input.model.split(\"/\", 2);\n    if (!model) throw new ProcessError(\"unknown model\");\n    if (!this.openaiDispatcher) throw new QuotaError(\"OpenAI dispatcher not initialized\");\n\n    const outputSchema = input.tools?.length\n      ? buildToolCallSchema(input.tools)\n      : input.jsonSchema\n        ? (JSON.parse(input.jsonSchema) as JsonValue)\n        : undefined;\n\n    await this.openaiDispatcher.generateStream(\n      {\n        model,\n        input: [{ type: \"text\" as const, text: input.prompt, text_elements: [] }],\n        systemPrompt: input.system,\n        outputSchema: outputSchema\n          ? (strictify(outputSchema as Parameters<typeof strictify>[0]) as JsonValue)\n          : undefined,\n        effort: input.effort,\n        verbosity: input.verbosity,\n        reasoningSummary: input.reasoningSummary,\n        serviceTier: input.serviceTier,\n        history: input.history ? JSON.parse(input.history) : undefined,\n      },\n      {\n        onDelta: cb.onDelta,\n        onThreadId: cb.onThreadId,\n        onTurnId: cb.onTurnId,\n        onComplete: (turnResult) => {\n          const applied = applyToolCallEmulation(\n            {\n              text: turnResult.text,\n              tokenName: (turnResult as unknown as { tokenName?: string }).tokenName,\n              model: turnResult.model,\n              usage: {\n                input_tokens: turnResult.usage.inputTokens,\n                output_tokens: turnResult.usage.outputTokens,\n                cache_creation_input_tokens: 0,\n                cache_read_input_tokens: turnResult.usage.cachedInputTokens,\n              },\n              durationMs: turnResult.durationMs,\n              costUsd: calculateCostUsd(turnResult.model, {\n                inputTokens: turnResult.usage.inputTokens,\n                outputTokens: turnResult.usage.outputTokens,\n                cachedInputTokens: turnResult.usage.cachedInputTokens,\n              }),\n            },\n            input.tools,\n          );\n          cb.onComplete(applied);\n        },\n        onError: cb.onError,\n      },\n    );\n  }\n}\n\nasync function executeClaude(\n  input: QueryInput,\n  token: string,\n  timeoutMs: number,\n): Promise<Omit<QueryOutput, \"content\" | \"finishReason\">> {\n  const rawModel = input.model ?? DEFAULT_MODEL;\n  const model = rawModel.includes(\"/\") ? rawModel.split(\"/\").pop()! : rawModel;\n  const timeout = input.timeout ?? timeoutMs;\n  const useStructuredOutput = input.jsonSchema && input.jsonSchema.length > 0;\n\n  // --tools \"\" 로 모든 tool 을 기본 차단. structured output 쓰면 StructuredOutput 만 화이트리스트.\n  // --tools \"\" 는 반드시 뒤에 다른 플래그가 와야 CLI 파싱이 빈 문자열로 인식\n  const toolArgs = useStructuredOutput\n    ? [\"--tools\", \"\", \"--allowed-tools\", \"StructuredOutput\"]\n    : [\"--tools\", \"\"];\n\n  const args: string[] = [\n    \"-p\",\n    ...toolArgs,\n    \"--disallowedTools\",\n    // CC에서 자동 활성화되는 deferred 도구. 토큰 최적화를위해 차단\n    ...([\"Monitor\", \"PushNotification\", \"RemoteTrigger\"] as const),\n    \"--output-format\",\n    \"stream-json\",\n    \"--verbose\",\n    // --max-turns: structured output 은 tool_use + tool_result 로 2턴 소비\n    \"--max-turns\",\n    useStructuredOutput ? \"2\" : \"1\",\n    \"--permission-mode\",\n    \"bypassPermissions\",\n    \"--setting-sources\",\n    \"project\",\n    \"--model\",\n    model,\n    // --system-prompt는 반드시 명시해야함. 옵션 생략 시 CC가 default system prompt를 자동으로 주입함(23k)\n    \"--system-prompt\",\n    input.system ?? \"\",\n    \"--thinking\",\n    \"disabled\",\n    \"--effort\",\n    input.effort ?? DEFAULT_EFFORT,\n    \"--no-session-persistence\",\n    // 모든 skills 비활성화\n    \"--disable-slash-commands\",\n  ];\n  if (useStructuredOutput) {\n    args.push(\"--json-schema\", input.jsonSchema!);\n  }\n  args.push(input.prompt);\n\n  const env: NodeJS.ProcessEnv = {\n    PATH: process.env.PATH,\n    TMPDIR: process.env.TMPDIR,\n    CLAUDE_CODE_OAUTH_TOKEN: token,\n    // CLAUDE_CONFIG_DIR 환경변수로 주입\n    CLAUDE_CONFIG_DIR,\n    CLAUDE_CODE_DISABLE_AUTO_MEMORY: \"1\",\n    CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING: \"1\",\n    CLAUDE_CODE_DISABLE_1M_CONTEXT: \"1\",\n    CLAUDE_CODE_DISABLE_CLAUDE_MDS: \"1\",\n    CLAUDE_CODE_ATTRIBUTION_HEADER: \"0\",\n  };\n\n  return new Promise<Omit<QueryOutput, \"content\" | \"finishReason\">>((resolve, reject) => {\n    const child = spawn(\"claude\", args, {\n      stdio: [\"ignore\", \"pipe\", \"ignore\"],\n      env,\n      // 격리 (두 단계):\n      // 1. CLAUDE_CWD — project scope 격리 (cwd 의 .claude/settings.json)\n      // 2. CLAUDE_CONFIG_DIR — user scope 격리 cwd 격리만으론 부족.\n      cwd: CLAUDE_CWD,\n    });\n\n    let buffer = \"\";\n    let settled = false;\n    const timer = setTimeout(() => {\n      if (settled) return;\n      settled = true;\n      child.kill();\n      reject(new TimeoutError(`Timeout after ${timeout / 1000}s (token: ${maskToken(token)})`));\n    }, timeout);\n\n    child.stdout?.on(\"data\", (d: Buffer) => {\n      if (settled) return;\n      buffer += d.toString();\n      const lines = buffer.split(\"\\n\");\n      buffer = lines.pop() ?? \"\";\n      for (const line of lines) {\n        if (!line.trim()) continue;\n        try {\n          const j = JSON.parse(line);\n          if (j.type === \"result\" && !settled) {\n            // --json-schema 사용 시 structured_output 에 파싱된 객체가 온다 → 우선 사용\n            let text: string;\n            if (j.structured_output !== undefined) {\n              text = JSON.stringify(j.structured_output);\n            } else {\n              text = (j.result ?? \"\")\n                .replace(/^```(?:json)?\\s*\\n?/i, \"\")\n                .replace(/\\n?```\\s*$/i, \"\");\n            }\n\n            if (text.startsWith(\"You've hit\")) {\n              settled = true;\n              clearTimeout(timer);\n              reject(new QuotaError(`Quota exhausted (token: ${maskToken(token)})`));\n              return;\n            }\n\n            const u = j.usage ?? {};\n            settled = true;\n            clearTimeout(timer);\n            resolve({\n              text,\n              usage: {\n                input_tokens: u.input_tokens ?? 0,\n                output_tokens: u.output_tokens ?? 0,\n                cache_creation_input_tokens: u.cache_creation_input_tokens ?? 0,\n                cache_read_input_tokens: u.cache_read_input_tokens ?? 0,\n              },\n              durationMs: j.duration_ms ?? 0,\n              costUsd: j.total_cost_usd ?? 0,\n            });\n          }\n        } catch {}\n      }\n    });\n\n    child.on(\"close\", () => {\n      if (settled) return;\n      settled = true;\n      clearTimeout(timer);\n      reject(new ProcessError(`CLI process closed without result (token: ${maskToken(token)})`));\n    });\n\n    child.on(\"error\", (err) => {\n      if (settled) return;\n      settled = true;\n      clearTimeout(timer);\n      reject(new ProcessError(`CLI process error: ${err.message} (token: ${maskToken(token)})`));\n    });\n  });\n}\n\nexport const QgridDispatcher = new QgridDispatcherClass();\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAiCA,MAAM,SAAS,UAAU,CAAC,QAAQ,CAAC;AAEnC,MAAM,gBAAgB;AACtB,MAAM,qBAAqB;AAC3B,MAAM,iBAAiB;AAIvB,MAAM,aAAa;AAGnB,MAAM,oBAAoB;AAG1B,MAAM,wBAAwB;CAC5B,uBAAuB;CACvB,wBAAwB;CACxB,mBAAmB;CACpB;AAGD,MAAM,oBAAoB;AAE1B,IAAa,uBAAb,MAAkC;CAChC,yBAAS,IAAI,KAA2B;CAGxC,gCAAgB,IAAI,KAAqB;CACzC,UAAU;CAGV,aAAqC;CACrC,mBAA4C;CAE5C,cAAc;EACZ,MAAM,eAAe,KAAK,UAAU,uBAAuB,MAAM,EAAE;AAEnE,YAAU,GAAG,WAAW,WAAW,EAAE,WAAW,MAAM,CAAC;AACvD,gBAAc,GAAG,WAAW,yBAAyB,aAAa;AAElE,YAAU,mBAAmB,EAAE,WAAW,MAAM,CAAC;AACjD,gBAAc,GAAG,kBAAkB,gBAAgB,KAAK;AACxD,gBAAc,GAAG,kBAAkB,iBAAiB,aAAa;;CAGnE,QAAQ,MAAsB;AAC5B,SAAO,KAAK,cAAc,IAAI,KAAK,IAAI;;CAIzC,YAAY,IAAY,KAAyB;AAC/C,OAAK,OAAO,IAAI,IAAI,IAAI;;CAG1B,YAAY,IAAkB;AAC5B,OAAK,OAAO,OAAO,GAAG;;CAGxB,aAAa,MAA4B;AACvC,OAAK,SAAS,IAAI,IAAI,KAAK,KAAK,MAAM,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC;;CAGnD,WAAyB;AACvB,SAAO,CAAC,GAAG,KAAK,OAAO,QAAQ,CAAC,CAAC,KAAK,OAAO;GAC3C,OAAO,UAAU,eAAe,EAAE,YAAY,CAAC;GAC/C,MAAM,EAAE;GACR,UAAU,EAAE;GACZ,UAAU,KAAK,QAAQ,EAAE,KAAK;GAC/B,EAAE;;CAGL,YAAY,WAAW,aAAkC;EACvD,MAAM,OAAO,CAAC,GAAG,KAAK,OAAO,QAAQ,CAAC,CAAC,QAAQ,MAAM,EAAE,aAAa,SAAS;AAC7E,MAAI,KAAK,WAAW,EAAG,QAAO;EAE9B,MAAM,WAAW,KAAK,IAAI,GAAG,KAAK,KAAK,MAAM,KAAK,QAAQ,EAAE,KAAK,CAAC,CAAC;EACnE,MAAM,OAAO,KAAK,QAAQ,MAAM,KAAK,QAAQ,EAAE,KAAK,KAAK,SAAS;EAClE,MAAM,SAAS,KAAK,KAAK,UAAU,KAAK;AACxC,OAAK;AACL,SAAO;;CAGT,MAAM,MAAM,OAAmB,WAA0C;AACvE,MAAI,MAAM,OAAO,UAAU,MAAM,WAC/B,OAAM,IAAI,aAAa,+CAA+C;EAGxE,MAAM,eAAe,MAAM,OAAO,SAC9B,oBAAoB,MAAM,MAAM,GAChC,MAAM,aACH,KAAK,MAAM,MAAM,WAAW,GAC7B;AAGN,MAAI,MAAM,OAAO,SAAS,IAAI,EAAE;GAC9B,MAAM,CAAC,UAAU,SAAS,MAAM,MAAM,MAAM,KAAK,EAAE;AACnD,UAAO,OAAO,gBAAgB;AAC9B,OAAI,aAAa,UAAU;AACzB,QAAI,CAAC,KAAK,iBAAkB,OAAM,IAAI,WAAW,oCAAoC;IACrF,MAAM,SAAS,MAAM,KAAK,iBAAiB,SAAS;KAC3C;KACP,OAAO,CAAC;MAAE,MAAM;MAAiB,MAAM,MAAM;MAAQ,eAAe,EAAE;MAAE,CAAC;KACzE,cAAc,MAAM;KACpB,cAAc,eACT,UAAU,aAAgD,GAC3D;KACJ,QAAQ,MAAM;KACd,WAAW,MAAM;KACjB,kBAAkB,MAAM;KACxB,aAAa,MAAM;KACnB,SAAS,MAAM,UAAU,KAAK,MAAM,MAAM,QAAQ,GAAG;KACtD,CAAC;AAEF,WAAO,uBACL;KACE,MAAM,OAAO;KACb,WAAW,OAAO;KAClB,OAAO,OAAO;KACd,OAAO;MACL,cAAc,OAAO,MAAM;MAC3B,eAAe,OAAO,MAAM;MAC5B,6BAA6B;MAC7B,yBAAyB,OAAO,MAAM;MACvC;KACD,YAAY,OAAO;KACnB,SAAS,iBAAiB,OAAO,OAAO;MACtC,aAAa,OAAO,MAAM;MAC1B,cAAc,OAAO,MAAM;MAC3B,mBAAmB,OAAO,MAAM;MACjC,CAAC;KACH,EACD,MAAM,MACP;;;EAIL,MAAM,iBACJ,gBAAgB,MAAM,OAAO,SACzB;GAAE,GAAG;GAAO,YAAY,KAAK,UAAU,aAAa;GAAE,GACtD;EAGN,MAAM,eAAe,KAAK,aAAa;AACvC,MAAI,CAAC,aAAc,OAAM,IAAI,WAAW,sBAAsB;AAG9D,OAAK,cAAc,IAAI,aAAa,MAAM,KAAK,QAAQ,aAAa,KAAK,GAAG,EAAE;EAE9E,IAAI,QAAQ,eAAe,aAAa,YAAY;EAEpD,MAAM,YAAY,aAAa,aAAa,YAAY;AACxD,MACE,aACA,YAAY,KAAK,KAAK,GAAG,qBACzB,gBAAgB,aAAa,YAAY,CAEzC,KAAI;GACF,MAAM,EAAE,eAAe,MAAM,OAAO;AACpC,WAAQ,MAAM,WAAW,aAAa,aAAa;WAC5C,GAAG;AACV,UAAO,KAAK,sBAAsB,aAAa,KAAK,IAAK,EAAY,UAAU;;AAInF,SAAO,KAAK,KAAK,aAAa,KAAK,WAAW,MAAM,SAAS,cAAc,GAAG;AAG9E,SAAO,uBACL;GAAE,GAFW,MAAM,cAAc,gBAAgB,OAAO,aAAa,mBAAmB;GAE3E,WAAW,aAAa;GAAM,OAAO,MAAM,SAAS;GAAe,EAChF,MAAM,MACP;;CAGH,MAAM,YACJ,OACA,IAOe;AACf,MAAI,CAAC,MAAM,OAAO,WAAW,UAAU,EAAE;GACvC,MAAM,SAAS,MAAM,KAAK,MAAM,MAAM;AACtC,MAAG,WAAW,OAAO;AACrB;;EAGF,MAAM,GAAG,SAAS,MAAM,MAAM,MAAM,KAAK,EAAE;AAC3C,MAAI,CAAC,MAAO,OAAM,IAAI,aAAa,gBAAgB;AACnD,MAAI,CAAC,KAAK,iBAAkB,OAAM,IAAI,WAAW,oCAAoC;EAErF,MAAM,eAAe,MAAM,OAAO,SAC9B,oBAAoB,MAAM,MAAM,GAChC,MAAM,aACH,KAAK,MAAM,MAAM,WAAW,GAC7B;AAEN,QAAM,KAAK,iBAAiB,eAC1B;GACE;GACA,OAAO,CAAC;IAAE,MAAM;IAAiB,MAAM,MAAM;IAAQ,eAAe,EAAE;IAAE,CAAC;GACzE,cAAc,MAAM;GACpB,cAAc,eACT,UAAU,aAAgD,GAC3D;GACJ,QAAQ,MAAM;GACd,WAAW,MAAM;GACjB,kBAAkB,MAAM;GACxB,aAAa,MAAM;GACnB,SAAS,MAAM,UAAU,KAAK,MAAM,MAAM,QAAQ,GAAG;GACtD,EACD;GACE,SAAS,GAAG;GACZ,YAAY,GAAG;GACf,UAAU,GAAG;GACb,aAAa,eAAe;IAC1B,MAAM,UAAU,uBACd;KACE,MAAM,WAAW;KACjB,WAAY,WAAiD;KAC7D,OAAO,WAAW;KAClB,OAAO;MACL,cAAc,WAAW,MAAM;MAC/B,eAAe,WAAW,MAAM;MAChC,6BAA6B;MAC7B,yBAAyB,WAAW,MAAM;MAC3C;KACD,YAAY,WAAW;KACvB,SAAS,iBAAiB,WAAW,OAAO;MAC1C,aAAa,WAAW,MAAM;MAC9B,cAAc,WAAW,MAAM;MAC/B,mBAAmB,WAAW,MAAM;MACrC,CAAC;KACH,EACD,MAAM,MACP;AACD,OAAG,WAAW,QAAQ;;GAExB,SAAS,GAAG;GACb,CACF;;;AAIL,eAAe,cACb,OACA,OACA,WACwD;CACxD,MAAM,WAAW,MAAM,SAAS;CAChC,MAAM,QAAQ,SAAS,SAAS,IAAI,GAAG,SAAS,MAAM,IAAI,CAAC,KAAK,GAAI;CACpE,MAAM,UAAU,MAAM,WAAW;CACjC,MAAM,sBAAsB,MAAM,cAAc,MAAM,WAAW,SAAS;CAQ1E,MAAM,OAAiB;EACrB;EACA,GANe,sBACb;GAAC;GAAW;GAAI;GAAmB;GAAmB,GACtD,CAAC,WAAW,GAAG;EAKjB;EAEA,GAAI;GAAC;GAAW;GAAoB;GAAgB;EACpD;EACA;EACA;EAEA;EACA,sBAAsB,MAAM;EAC5B;EACA;EACA;EACA;EACA;EACA;EAEA;EACA,MAAM,UAAU;EAChB;EACA;EACA;EACA,MAAM,UAAU;EAChB;EAEA;EACD;AACD,KAAI,oBACF,MAAK,KAAK,iBAAiB,MAAM,WAAY;AAE/C,MAAK,KAAK,MAAM,OAAO;CAEvB,MAAM,MAAyB;EAC7B,MAAM,QAAQ,IAAI;EAClB,QAAQ,QAAQ,IAAI;EACpB,yBAAyB;EAEzB;EACA,iCAAiC;EACjC,uCAAuC;EACvC,gCAAgC;EAChC,gCAAgC;EAChC,gCAAgC;EACjC;AAED,QAAO,IAAI,SAAwD,SAAS,WAAW;EACrF,MAAM,QAAQ,MAAM,UAAU,MAAM;GAClC,OAAO;IAAC;IAAU;IAAQ;IAAS;GACnC;GAIA,KAAK;GACN,CAAC;EAEF,IAAI,SAAS;EACb,IAAI,UAAU;EACd,MAAM,QAAQ,iBAAiB;AAC7B,OAAI,QAAS;AACb,aAAU;AACV,SAAM,MAAM;AACZ,UAAO,IAAI,aAAa,iBAAiB,UAAU,IAAK,YAAY,UAAU,MAAM,CAAC,GAAG,CAAC;KACxF,QAAQ;AAEX,QAAM,QAAQ,GAAG,SAAS,MAAc;AACtC,OAAI,QAAS;AACb,aAAU,EAAE,UAAU;GACtB,MAAM,QAAQ,OAAO,MAAM,KAAK;AAChC,YAAS,MAAM,KAAK,IAAI;AACxB,QAAK,MAAM,QAAQ,OAAO;AACxB,QAAI,CAAC,KAAK,MAAM,CAAE;AAClB,QAAI;KACF,MAAM,IAAI,KAAK,MAAM,KAAK;AAC1B,SAAI,EAAE,SAAS,YAAY,CAAC,SAAS;MAEnC,IAAI;AACJ,UAAI,EAAE,sBAAsB,OAC1B,QAAO,KAAK,UAAU,EAAE,kBAAkB;UAE1C,SAAQ,EAAE,UAAU,IACjB,QAAQ,wBAAwB,GAAG,CACnC,QAAQ,eAAe,GAAG;AAG/B,UAAI,KAAK,WAAW,aAAa,EAAE;AACjC,iBAAU;AACV,oBAAa,MAAM;AACnB,cAAO,IAAI,WAAW,2BAA2B,UAAU,MAAM,CAAC,GAAG,CAAC;AACtE;;MAGF,MAAM,IAAI,EAAE,SAAS,EAAE;AACvB,gBAAU;AACV,mBAAa,MAAM;AACnB,cAAQ;OACN;OACA,OAAO;QACL,cAAc,EAAE,gBAAgB;QAChC,eAAe,EAAE,iBAAiB;QAClC,6BAA6B,EAAE,+BAA+B;QAC9D,yBAAyB,EAAE,2BAA2B;QACvD;OACD,YAAY,EAAE,eAAe;OAC7B,SAAS,EAAE,kBAAkB;OAC9B,CAAC;;YAEE;;IAEV;AAEF,QAAM,GAAG,eAAe;AACtB,OAAI,QAAS;AACb,aAAU;AACV,gBAAa,MAAM;AACnB,UAAO,IAAI,aAAa,6CAA6C,UAAU,MAAM,CAAC,GAAG,CAAC;IAC1F;AAEF,QAAM,GAAG,UAAU,QAAQ;AACzB,OAAI,QAAS;AACb,aAAU;AACV,gBAAa,MAAM;AACnB,UAAO,IAAI,aAAa,sBAAsB,IAAI,QAAQ,WAAW,UAAU,MAAM,CAAC,GAAG,CAAC;IAC1F;GACF;;AAGJ,MAAa,kBAAkB,IAAI,sBAAsB"}