@cartanova/qgrid-cli 0.1.1 → 1.0.1

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

@@ -0,0 +1,79 @@
+import "../../_virtual/_rolldown/runtime.js";
+import { z } from "zod";
+//#region src/application/qgrid/qgrid.types.ts
+const QueryInput = z.object({
+	system: z.string().optional(),
+	prompt: z.string(),
+	timeout: z.number().optional()
+});
+const CliResult = z.object({
+	text: z.string(),
+	usage: z.object({
+		input_tokens: z.number(),
+		output_tokens: z.number(),
+		cache_creation_input_tokens: z.number(),
+		cache_read_input_tokens: z.number()
+	}),
+	durationMs: z.number(),
+	costUsd: z.number()
+});
+const PoolConfig = z.object({
+	tokens: z.array(z.string()),
+	size: z.number().optional(),
+	model: z.string().optional(),
+	timeout: z.number().optional(),
+	cwd: z.string().optional(),
+	maxCalls: z.number().optional()
+});
+const AddTokenInput = z.object({
+	token: z.string(),
+	name: z.string()
+});
+const RemoveTokenInput = z.object({ token: z.string() });
+const TokenStats = z.object({
+	token: z.string(),
+	name: z.string(),
+	requests: z.number(),
+	active: z.boolean()
+});
+const OAuthStartResult = z.object({ authUrl: z.string() });
+const RateLimit = z.object({
+	utilization: z.number().nullable(),
+	resets_at: z.string().nullable()
+}).nullable();
+const UsageResponse = z.object({
+	error: z.string().optional(),
+	five_hour: RateLimit.optional(),
+	seven_day: RateLimit.optional(),
+	seven_day_opus: RateLimit.optional(),
+	seven_day_sonnet: RateLimit.optional(),
+	seven_day_oauth_apps: RateLimit.optional(),
+	seven_day_cowork: RateLimit.optional(),
+	extra_usage: z.object({
+		is_enabled: z.boolean(),
+		monthly_limit: z.number().nullable(),
+		used_credits: z.number().nullable(),
+		utilization: z.number().nullable()
+	}).nullable().optional()
+});
+const HealthResponse = z.object({
+	status: z.string(),
+	workers: z.number(),
+	activeTokens: z.number()
+});
+var QuotaError = class extends Error {
+	code = "QUOTA_EXHAUSTED";
+};
+var TimeoutError = class extends Error {
+	code = "TIMEOUT";
+};
+var ProcessError = class extends Error {
+	code = "PROCESS_ERROR";
+};
+function maskToken(token) {
+	return token.length > 4 ? `...${token.slice(-4)}` : token;
+}
+//#endregion
+export { AddTokenInput, CliResult, HealthResponse, OAuthStartResult, PoolConfig, ProcessError, QueryInput, QuotaError, RemoveTokenInput, TimeoutError, TokenStats, UsageResponse, maskToken };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicWdyaWQudHlwZXMuanMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2FwcGxpY2F0aW9uL3FncmlkL3FncmlkLnR5cGVzLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IHogfSBmcm9tIFwiem9kXCI7XG5cbi8vIOKUgOKUgOKUgCBRdWVyeSDilIDilIDilIBcblxuZXhwb3J0IGNvbnN0IFF1ZXJ5SW5wdXQgPSB6Lm9iamVjdCh7XG4gIHN5c3RlbTogei5zdHJpbmcoKS5vcHRpb25hbCgpLFxuICBwcm9tcHQ6IHouc3RyaW5nKCksXG4gIHRpbWVvdXQ6IHoubnVtYmVyKCkub3B0aW9uYWwoKSxcbn0pO1xuZXhwb3J0IHR5cGUgUXVlcnlJbnB1dCA9IHouaW5mZXI8dHlwZW9mIFF1ZXJ5SW5wdXQ+O1xuXG5leHBvcnQgY29uc3QgQ2xpUmVzdWx0ID0gei5vYmplY3Qoe1xuICB0ZXh0OiB6LnN0cmluZygpLFxuICB1c2FnZTogei5vYmplY3Qoe1xuICAgIGlucHV0X3Rva2Vuczogei5udW1iZXIoKSxcbiAgICBvdXRwdXRfdG9rZW5zOiB6Lm51bWJlcigpLFxuICAgIGNhY2hlX2NyZWF0aW9uX2lucHV0X3Rva2Vuczogei5udW1iZXIoKSxcbiAgICBjYWNoZV9yZWFkX2lucHV0X3Rva2Vuczogei5udW1iZXIoKSxcbiAgfSksXG4gIGR1cmF0aW9uTXM6IHoubnVtYmVyKCksXG4gIGNvc3RVc2Q6IHoubnVtYmVyKCksXG59KTtcbmV4cG9ydCB0eXBlIENsaVJlc3VsdCA9IHouaW5mZXI8dHlwZW9mIENsaVJlc3VsdD47XG5cbi8vIOKUgOKUgOKUgCBQb29sIENvbmZpZyDilIDilIDilIBcblxuZXhwb3J0IGNvbnN0IFBvb2xDb25maWcgPSB6Lm9iamVjdCh7XG4gIHRva2Vuczogei5hcnJheSh6LnN0cmluZygpKSxcbiAgc2l6ZTogei5udW1iZXIoKS5vcHRpb25hbCgpLFxuICBtb2RlbDogei5zdHJpbmcoKS5vcHRpb25hbCgpLFxuICB0aW1lb3V0OiB6Lm51bWJlcigpLm9wdGlvbmFsKCksXG4gIGN3ZDogei5zdHJpbmcoKS5vcHRpb25hbCgpLFxuICBtYXhDYWxsczogei5udW1iZXIoKS5vcHRpb25hbCgpLFxufSk7XG5leHBvcnQgdHlwZSBQb29sQ29uZmlnID0gei5pbmZlcjx0eXBlb2YgUG9vbENvbmZpZz47XG5cbi8vIOKUgOKUgOKUgCBUb2tlbiBNYW5hZ2VtZW50IOKUgOKUgOKUgFxuXG5leHBvcnQgY29uc3QgQWRkVG9rZW5JbnB1dCA9IHoub2JqZWN0KHtcbiAgdG9rZW46IHouc3RyaW5nKCksXG4gIG5hbWU6IHouc3RyaW5nKCksXG59KTtcbmV4cG9ydCB0eXBlIEFkZFRva2VuSW5wdXQgPSB6LmluZmVyPHR5cGVvZiBBZGRUb2tlbklucHV0PjtcblxuZXhwb3J0IGNvbnN0IFJlbW92ZVRva2VuSW5wdXQgPSB6Lm9iamVjdCh7XG4gIHRva2VuOiB6LnN0cmluZygpLFxufSk7XG5leHBvcnQgdHlwZSBSZW1vdmVUb2tlbklucHV0ID0gei5pbmZlcjx0eXBlb2YgUmVtb3ZlVG9rZW5JbnB1dD47XG5cbmV4cG9ydCBjb25zdCBUb2tlblN0YXRzID0gei5vYmplY3Qoe1xuICB0b2tlbjogei5zdHJpbmcoKSxcbiAgbmFtZTogei5zdHJpbmcoKSxcbiAgcmVxdWVzdHM6IHoubnVtYmVyKCksXG4gIGFjdGl2ZTogei5ib29sZWFuKCksXG59KTtcbmV4cG9ydCB0eXBlIFRva2VuU3RhdHMgPSB6LmluZmVyPHR5cGVvZiBUb2tlblN0YXRzPjtcblxuLy8g4pSA4pSA4pSAIE9BdXRoIOKUgOKUgOKUgFxuXG5leHBvcnQgY29uc3QgT0F1dGhTdGFydFJlc3VsdCA9IHoub2JqZWN0KHtcbiAgYXV0aFVybDogei5zdHJpbmcoKSxcbn0pO1xuZXhwb3J0IHR5cGUgT0F1dGhTdGFydFJlc3VsdCA9IHouaW5mZXI8dHlwZW9mIE9BdXRoU3RhcnRSZXN1bHQ+O1xuXG5jb25zdCBSYXRlTGltaXQgPSB6XG4gIC5vYmplY3Qoe1xuICAgIHV0aWxpemF0aW9uOiB6Lm51bWJlcigpLm51bGxhYmxlKCksXG4gICAgcmVzZXRzX2F0OiB6LnN0cmluZygpLm51bGxhYmxlKCksXG4gIH0pXG4gIC5udWxsYWJsZSgpO1xuXG5leHBvcnQgY29uc3QgVXNhZ2VSZXNwb25zZSA9IHoub2JqZWN0KHtcbiAgZXJyb3I6IHouc3RyaW5nKCkub3B0aW9uYWwoKSxcbiAgZml2ZV9ob3VyOiBSYXRlTGltaXQub3B0aW9uYWwoKSxcbiAgc2V2ZW5fZGF5OiBSYXRlTGltaXQub3B0aW9uYWwoKSxcbiAgc2V2ZW5fZGF5X29wdXM6IFJhdGVMaW1pdC5vcHRpb25hbCgpLFxuICBzZXZlbl9kYXlfc29ubmV0OiBSYXRlTGltaXQub3B0aW9uYWwoKSxcbiAgc2V2ZW5fZGF5X29hdXRoX2FwcHM6IFJhdGVMaW1pdC5vcHRpb25hbCgpLFxuICBzZXZlbl9kYXlfY293b3JrOiBSYXRlTGltaXQub3B0aW9uYWwoKSxcbiAgZXh0cmFfdXNhZ2U6IHpcbiAgICAub2JqZWN0KHtcbiAgICAgIGlzX2VuYWJsZWQ6IHouYm9vbGVhbigpLFxuICAgICAgbW9udGhseV9saW1pdDogei5udW1iZXIoKS5udWxsYWJsZSgpLFxuICAgICAgdXNlZF9jcmVkaXRzOiB6Lm51bWJlcigpLm51bGxhYmxlKCksXG4gICAgICB1dGlsaXphdGlvbjogei5udW1iZXIoKS5udWxsYWJsZSgpLFxuICAgIH0pXG4gICAgLm51bGxhYmxlKClcbiAgICAub3B0aW9uYWwoKSxcbn0pO1xuZXhwb3J0IHR5cGUgVXNhZ2VSZXNwb25zZSA9IHouaW5mZXI8dHlwZW9mIFVzYWdlUmVzcG9uc2U+O1xuXG4vLyDilIDilIDilIAgSGVhbHRoIOKUgOKUgOKUgFxuXG5leHBvcnQgY29uc3QgSGVhbHRoUmVzcG9uc2UgPSB6Lm9iamVjdCh7XG4gIHN0YXR1czogei5zdHJpbmcoKSxcbiAgd29ya2Vyczogei5udW1iZXIoKSxcbiAgYWN0aXZlVG9rZW5zOiB6Lm51bWJlcigpLFxufSk7XG5leHBvcnQgdHlwZSBIZWFsdGhSZXNwb25zZSA9IHouaW5mZXI8dHlwZW9mIEhlYWx0aFJlc3BvbnNlPjtcblxuLy8g4pSA4pSA4pSAIEVycm9ycyDilIDilIDilIBcblxuZXhwb3J0IGNsYXNzIFF1b3RhRXJyb3IgZXh0ZW5kcyBFcnJvciB7XG4gIHJlYWRvbmx5IGNvZGUgPSBcIlFVT1RBX0VYSEFVU1RFRFwiIGFzIGNvbnN0O1xufVxuZXhwb3J0IGNsYXNzIFRpbWVvdXRFcnJvciBleHRlbmRzIEVycm9yIHtcbiAgcmVhZG9ubHkgY29kZSA9IFwiVElNRU9VVFwiIGFzIGNvbnN0O1xufVxuZXhwb3J0IGNsYXNzIFByb2Nlc3NFcnJvciBleHRlbmRzIEVycm9yIHtcbiAgcmVhZG9ubHkgY29kZSA9IFwiUFJPQ0VTU19FUlJPUlwiIGFzIGNvbnN0O1xufVxuXG4vLyDilIDilIDilIAgVXRpbHMg4pSA4pSA4pSAXG5cbmV4cG9ydCBmdW5jdGlvbiBtYXNrVG9rZW4odG9rZW46IHN0cmluZyk6IHN0cmluZyB7XG4gIHJldHVybiB0b2tlbi5sZW5ndGggPiA0ID8gYC4uLiR7dG9rZW4uc2xpY2UoLTQpfWAgOiB0b2tlbjtcbn1cbiJdLCJtYXBwaW5ncyI6Ijs7O0FBSUEsTUFBYSxhQUFhLEVBQUUsT0FBTztDQUNqQyxRQUFRLEVBQUUsUUFBUSxDQUFDLFVBQVU7Q0FDN0IsUUFBUSxFQUFFLFFBQVE7Q0FDbEIsU0FBUyxFQUFFLFFBQVEsQ0FBQyxVQUFVO0NBQy9CLENBQUM7QUFHRixNQUFhLFlBQVksRUFBRSxPQUFPO0NBQ2hDLE1BQU0sRUFBRSxRQUFRO0NBQ2hCLE9BQU8sRUFBRSxPQUFPO0VBQ2QsY0FBYyxFQUFFLFFBQVE7RUFDeEIsZUFBZSxFQUFFLFFBQVE7RUFDekIsNkJBQTZCLEVBQUUsUUFBUTtFQUN2Qyx5QkFBeUIsRUFBRSxRQUFRO0VBQ3BDLENBQUM7Q0FDRixZQUFZLEVBQUUsUUFBUTtDQUN0QixTQUFTLEVBQUUsUUFBUTtDQUNwQixDQUFDO0FBS0YsTUFBYSxhQUFhLEVBQUUsT0FBTztDQUNqQyxRQUFRLEVBQUUsTUFBTSxFQUFFLFFBQVEsQ0FBQztDQUMzQixNQUFNLEVBQUUsUUFBUSxDQUFDLFVBQVU7Q0FDM0IsT0FBTyxFQUFFLFFBQVEsQ0FBQyxVQUFVO0NBQzVCLFNBQVMsRUFBRSxRQUFRLENBQUMsVUFBVTtDQUM5QixLQUFLLEVBQUUsUUFBUSxDQUFDLFVBQVU7Q0FDMUIsVUFBVSxFQUFFLFFBQVEsQ0FBQyxVQUFVO0NBQ2hDLENBQUM7QUFLRixNQUFhLGdCQUFnQixFQUFFLE9BQU87Q0FDcEMsT0FBTyxFQUFFLFFBQVE7Q0FDakIsTUFBTSxFQUFFLFFBQVE7Q0FDakIsQ0FBQztBQUdGLE1BQWEsbUJBQW1CLEVBQUUsT0FBTyxFQUN2QyxPQUFPLEVBQUUsUUFBUSxFQUNsQixDQUFDO0FBR0YsTUFBYSxhQUFhLEVBQUUsT0FBTztDQUNqQyxPQUFPLEVBQUUsUUFBUTtDQUNqQixNQUFNLEVBQUUsUUFBUTtDQUNoQixVQUFVLEVBQUUsUUFBUTtDQUNwQixRQUFRLEVBQUUsU0FBUztDQUNwQixDQUFDO0FBS0YsTUFBYSxtQkFBbUIsRUFBRSxPQUFPLEVBQ3ZDLFNBQVMsRUFBRSxRQUFRLEVBQ3BCLENBQUM7QUFHRixNQUFNLFlBQVksRUFDZixPQUFPO0NBQ04sYUFBYSxFQUFFLFFBQVEsQ0FBQyxVQUFVO0NBQ2xDLFdBQVcsRUFBRSxRQUFRLENBQUMsVUFBVTtDQUNqQyxDQUFDLENBQ0QsVUFBVTtBQUViLE1BQWEsZ0JBQWdCLEVBQUUsT0FBTztDQUNwQyxPQUFPLEVBQUUsUUFBUSxDQUFDLFVBQVU7Q0FDNUIsV0FBVyxVQUFVLFVBQVU7Q0FDL0IsV0FBVyxVQUFVLFVBQVU7Q0FDL0IsZ0JBQWdCLFVBQVUsVUFBVTtDQUNwQyxrQkFBa0IsVUFBVSxVQUFVO0NBQ3RDLHNCQUFzQixVQUFVLFVBQVU7Q0FDMUMsa0JBQWtCLFVBQVUsVUFBVTtDQUN0QyxhQUFhLEVBQ1YsT0FBTztFQUNOLFlBQVksRUFBRSxTQUFTO0VBQ3ZCLGVBQWUsRUFBRSxRQUFRLENBQUMsVUFBVTtFQUNwQyxjQUFjLEVBQUUsUUFBUSxDQUFDLFVBQVU7RUFDbkMsYUFBYSxFQUFFLFFBQVEsQ0FBQyxVQUFVO0VBQ25DLENBQUMsQ0FDRCxVQUFVLENBQ1YsVUFBVTtDQUNkLENBQUM7QUFLRixNQUFhLGlCQUFpQixFQUFFLE9BQU87Q0FDckMsUUFBUSxFQUFFLFFBQVE7Q0FDbEIsU0FBUyxFQUFFLFFBQVE7Q0FDbkIsY0FBYyxFQUFFLFFBQVE7Q0FDekIsQ0FBQztBQUtGLElBQWEsYUFBYixjQUFnQyxNQUFNO0NBQ3BDLE9BQWdCOztBQUVsQixJQUFhLGVBQWIsY0FBa0MsTUFBTTtDQUN0QyxPQUFnQjs7QUFFbEIsSUFBYSxlQUFiLGNBQWtDLE1BQU07Q0FDdEMsT0FBZ0I7O0FBS2xCLFNBQWdCLFVBQVUsT0FBdUI7QUFDL0MsUUFBTyxNQUFNLFNBQVMsSUFBSSxNQUFNLE1BQU0sTUFBTSxHQUFHLEtBQUsifQ==

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

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

package/bundle/dist/application/queries.generated.js

@@ -0,0 +1,31 @@
+import "../_virtual/_rolldown/runtime.js";
+//#region src/application/queries.generated.ts
+function createSSRQuery(modelName, methodName, params, serviceKey) {
+	return {
+		modelName,
+		methodName,
+		params,
+		serviceKey,
+		__brand: "SSRQuery"
+	};
+}
+let TokenService;
+(function(_TokenService) {
+	_TokenService.getToken = (subset, id) => createSSRQuery("TokenModel", "findById", [subset, id], ["Token", "getToken"]);
+	_TokenService.getTokens = (subset, rawParams) => createSSRQuery("TokenModel", "findMany", [subset, rawParams], ["Token", "getTokens"]);
+})(TokenService || (TokenService = {}));
+let RequestLogService;
+(function(_RequestLogService) {
+	_RequestLogService.getRequestLog = (subset, id) => createSSRQuery("RequestLogModel", "findById", [subset, id], ["RequestLog", "getRequestLog"]);
+	_RequestLogService.getRequestLogs = (subset, rawParams) => createSSRQuery("RequestLogModel", "findMany", [subset, rawParams], ["RequestLog", "getRequestLogs"]);
+})(RequestLogService || (RequestLogService = {}));
+let QgridService;
+(function(_QgridService) {
+	_QgridService.stats = () => createSSRQuery("QgridFrame", "stats", [], ["Qgrid", "stats"]);
+	_QgridService.usage = (tokenName) => createSSRQuery("QgridFrame", "usage", [tokenName], ["Qgrid", "usage"]);
+	_QgridService.health = () => createSSRQuery("QgridFrame", "health", [], ["Qgrid", "health"]);
+})(QgridService || (QgridService = {}));
+//#endregion
+export { QgridService, RequestLogService, TokenService };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicXVlcmllcy5nZW5lcmF0ZWQuanMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vc3JjL2FwcGxpY2F0aW9uL3F1ZXJpZXMuZ2VuZXJhdGVkLnRzIl0sInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGdlbmVyYXRlZFxuICog7KeB7KCRIOyImOygle2VmOyngCDrp4jshLjsmpQuXG4gKi9cbi8qIG94bGludC1kaXNhYmxlICovXG5cbmltcG9ydCB0eXBlIHsgU1NSUXVlcnkgfSBmcm9tIFwic29uYW11L3NzclwiO1xuXG4vLyBTU1JRdWVyeSDtl6ztjbwg7ZWo7IiYXG5mdW5jdGlvbiBjcmVhdGVTU1JRdWVyeShcbiAgbW9kZWxOYW1lOiBzdHJpbmcsXG4gIG1ldGhvZE5hbWU6IHN0cmluZyxcbiAgcGFyYW1zOiBhbnlbXSxcbiAgc2VydmljZUtleTogW3N0cmluZywgc3RyaW5nXSxcbik6IFNTUlF1ZXJ5IHtcbiAgcmV0dXJuIHsgbW9kZWxOYW1lLCBtZXRob2ROYW1lLCBwYXJhbXMsIHNlcnZpY2VLZXksIF9fYnJhbmQ6IFwiU1NSUXVlcnlcIiB9IGFzIFNTUlF1ZXJ5O1xufVxuXG5pbXBvcnQgeyBSZXF1ZXN0TG9nTGlzdFBhcmFtcyB9IGZyb20gXCIuL3JlcXVlc3QtbG9nL3JlcXVlc3QtbG9nLnR5cGVzXCI7XG5pbXBvcnQgeyBUb2tlblN1YnNldEtleSwgUmVxdWVzdExvZ1N1YnNldEtleSB9IGZyb20gXCIuL3NvbmFtdS5nZW5lcmF0ZWRcIjtcbmltcG9ydCB7IFRva2VuTGlzdFBhcmFtcyB9IGZyb20gXCIuL3Rva2VuL3Rva2VuLnR5cGVzXCI7XG5cbmV4cG9ydCBuYW1lc3BhY2UgVG9rZW5TZXJ2aWNlIHtcbiAgZXhwb3J0IGNvbnN0IGdldFRva2VuID0gPFQgZXh0ZW5kcyBUb2tlblN1YnNldEtleT4oc3Vic2V0OiBULCBpZDogbnVtYmVyKTogU1NSUXVlcnkgPT5cbiAgICBjcmVhdGVTU1JRdWVyeShcIlRva2VuTW9kZWxcIiwgXCJmaW5kQnlJZFwiLCBbc3Vic2V0LCBpZF0sIFtcIlRva2VuXCIsIFwiZ2V0VG9rZW5cIl0pO1xuXG4gIGV4cG9ydCBjb25zdCBnZXRUb2tlbnMgPSA8VCBleHRlbmRzIFRva2VuU3Vic2V0S2V5LCBMUCBleHRlbmRzIFRva2VuTGlzdFBhcmFtcz4oXG4gICAgc3Vic2V0OiBULFxuICAgIHJhd1BhcmFtcz86IExQLFxuICApOiBTU1JRdWVyeSA9PlxuICAgIGNyZWF0ZVNTUlF1ZXJ5KFwiVG9rZW5Nb2RlbFwiLCBcImZpbmRNYW55XCIsIFtzdWJzZXQsIHJhd1BhcmFtc10sIFtcIlRva2VuXCIsIFwiZ2V0VG9rZW5zXCJdKTtcbn1cblxuZXhwb3J0IG5hbWVzcGFjZSBSZXF1ZXN0TG9nU2VydmljZSB7XG4gIGV4cG9ydCBjb25zdCBnZXRSZXF1ZXN0TG9nID0gPFQgZXh0ZW5kcyBSZXF1ZXN0TG9nU3Vic2V0S2V5PihzdWJzZXQ6IFQsIGlkOiBudW1iZXIpOiBTU1JRdWVyeSA9PlxuICAgIGNyZWF0ZVNTUlF1ZXJ5KFwiUmVxdWVzdExvZ01vZGVsXCIsIFwiZmluZEJ5SWRcIiwgW3N1YnNldCwgaWRdLCBbXCJSZXF1ZXN0TG9nXCIsIFwiZ2V0UmVxdWVzdExvZ1wiXSk7XG5cbiAgZXhwb3J0IGNvbnN0IGdldFJlcXVlc3RMb2dzID0gPFQgZXh0ZW5kcyBSZXF1ZXN0TG9nU3Vic2V0S2V5LCBMUCBleHRlbmRzIFJlcXVlc3RMb2dMaXN0UGFyYW1zPihcbiAgICBzdWJzZXQ6IFQsXG4gICAgcmF3UGFyYW1zPzogTFAsXG4gICk6IFNTUlF1ZXJ5ID0+XG4gICAgY3JlYXRlU1NSUXVlcnkoXG4gICAgICBcIlJlcXVlc3RMb2dNb2RlbFwiLFxuICAgICAgXCJmaW5kTWFueVwiLFxuICAgICAgW3N1YnNldCwgcmF3UGFyYW1zXSxcbiAgICAgIFtcIlJlcXVlc3RMb2dcIiwgXCJnZXRSZXF1ZXN0TG9nc1wiXSxcbiAgICApO1xufVxuXG5leHBvcnQgbmFtZXNwYWNlIFFncmlkU2VydmljZSB7XG4gIGV4cG9ydCBjb25zdCBzdGF0cyA9ICgpOiBTU1JRdWVyeSA9PlxuICAgIGNyZWF0ZVNTUlF1ZXJ5KFwiUWdyaWRGcmFtZVwiLCBcInN0YXRzXCIsIFtdLCBbXCJRZ3JpZFwiLCBcInN0YXRzXCJdKTtcblxuICBleHBvcnQgY29uc3QgdXNhZ2UgPSAodG9rZW5OYW1lPzogc3RyaW5nKTogU1NSUXVlcnkgPT5cbiAgICBjcmVhdGVTU1JRdWVyeShcIlFncmlkRnJhbWVcIiwgXCJ1c2FnZVwiLCBbdG9rZW5OYW1lXSwgW1wiUWdyaWRcIiwgXCJ1c2FnZVwiXSk7XG5cbiAgZXhwb3J0IGNvbnN0IGhlYWx0aCA9ICgpOiBTU1JRdWVyeSA9PlxuICAgIGNyZWF0ZVNTUlF1ZXJ5KFwiUWdyaWRGcmFtZVwiLCBcImhlYWx0aFwiLCBbXSwgW1wiUWdyaWRcIiwgXCJoZWFsdGhcIl0pO1xufVxuIl0sIm1hcHBpbmdzIjoiOztBQVNBLFNBQVMsZUFDUCxXQUNBLFlBQ0EsUUFDQSxZQUNVO0FBQ1YsUUFBTztFQUFFO0VBQVc7RUFBWTtFQUFRO0VBQVksU0FBUztFQUFZOztBQU9wRSxJQUFBOztBQUNRLGVBQUEsWUFBc0MsUUFBVyxPQUM1RCxlQUFlLGNBQWMsWUFBWSxDQUFDLFFBQVEsR0FBRyxFQUFFLENBQUMsU0FBUyxXQUFXLENBQUM7QUFFbEUsZUFBQSxhQUNYLFFBQ0EsY0FFQSxlQUFlLGNBQWMsWUFBWSxDQUFDLFFBQVEsVUFBVSxFQUFFLENBQUMsU0FBUyxZQUFZLENBQUM7dUNBQ3hGO0FBRU0sSUFBQTs7QUFDUSxvQkFBQSxpQkFBZ0QsUUFBVyxPQUN0RSxlQUFlLG1CQUFtQixZQUFZLENBQUMsUUFBUSxHQUFHLEVBQUUsQ0FBQyxjQUFjLGdCQUFnQixDQUFDO0FBRWpGLG9CQUFBLGtCQUNYLFFBQ0EsY0FFQSxlQUNFLG1CQUNBLFlBQ0EsQ0FBQyxRQUFRLFVBQVUsRUFDbkIsQ0FBQyxjQUFjLGlCQUFpQixDQUNqQztpREFDSjtBQUVNLElBQUE7O0FBQ1EsZUFBQSxjQUNYLGVBQWUsY0FBYyxTQUFTLEVBQUUsRUFBRSxDQUFDLFNBQVMsUUFBUSxDQUFDO0FBRWxELGVBQUEsU0FBUyxjQUNwQixlQUFlLGNBQWMsU0FBUyxDQUFDLFVBQVUsRUFBRSxDQUFDLFNBQVMsUUFBUSxDQUFDO0FBRTNELGVBQUEsZUFDWCxlQUFlLGNBQWMsVUFBVSxFQUFFLEVBQUUsQ0FBQyxTQUFTLFNBQVMsQ0FBQzt1Q0FDbEUifQ==

package/bundle/dist/application/request-log/request-log.model.js

@@ -0,0 +1,113 @@
+import "../../_virtual/_rolldown/runtime.js";
+import { SD } from "../../i18n/sd.generated.js";
+import { requestLogLoaderQueries, requestLogSubsetQueries } from "../sonamu.generated.sso.js";
+import { __decorateMetadata } from "../../_virtual/_@oxc-project_runtime@0.122.0/helpers/decorateMetadata.js";
+import { __decorate } from "../../_virtual/_@oxc-project_runtime@0.122.0/helpers/decorate.js";
+import { BadRequestException, BaseModelClass, NotFoundException, api, asArray, exhaustive } from "sonamu";
+//#region src/application/request-log/request-log.model.ts
+var RequestLogModelClass = class extends BaseModelClass {
+	constructor() {
+		super("RequestLog", requestLogSubsetQueries, requestLogLoaderQueries);
+	}
+	async findById(subset, id) {
+		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(subset, listParams) {
+		const { rows } = await this.findMany(subset, {
+			...listParams,
+			num: 1,
+			page: 1
+		});
+		return rows[0] ?? null;
+	}
+	async findMany(subset, rawParams) {
+		const params = {
+			num: 24,
+			page: 1,
+			search: "id",
+			orderBy: "id-desc",
+			...rawParams
+		};
+		const { qb, onSubset: _ } = this.getSubsetQueries(subset);
+		if (params.id) qb.whereIn("request_logs.id", asArray(params.id));
+		if (params.token_name) qb.where("request_logs.token_name", params.token_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 throw new BadRequestException(SD("error.unknownSearchField")(params.search));
+		if (params.orderBy) if (params.orderBy === "id-desc") qb.orderBy("request_logs.id", "desc");
+		else exhaustive(params.orderBy);
+		const enhancers = this.createEnhancers({ A: (row) => ({ ...row }) });
+		return this.executeSubsetQuery({
+			subset,
+			qb,
+			params,
+			enhancers,
+			debug: false
+		});
+	}
+	async save(spa) {
+		const wdb = this.getPuri("w");
+		spa.forEach((sp) => {
+			wdb.ubRegister("request_logs", sp);
+		});
+		return wdb.transaction(async (trx) => {
+			return await trx.ubUpsert("request_logs");
+		});
+	}
+	async del(ids) {
+		await this.getPuri("w").transaction(async (trx) => {
+			return trx.table("request_logs").whereIn("request_logs.id", ids).delete();
+		});
+		return ids.length;
+	}
+};
+__decorate([
+	api({
+		httpMethod: "GET",
+		clients: ["axios", "tanstack-query"],
+		resourceName: "RequestLog"
+	}),
+	__decorateMetadata("design:type", Function),
+	__decorateMetadata("design:paramtypes", [Object, Number]),
+	__decorateMetadata("design:returntype", Promise)
+], RequestLogModelClass.prototype, "findById", null);
+__decorate([
+	api({
+		httpMethod: "GET",
+		clients: ["axios", "tanstack-query"],
+		resourceName: "RequestLogs"
+	}),
+	__decorateMetadata("design:type", Function),
+	__decorateMetadata("design:paramtypes", [Object, Object]),
+	__decorateMetadata("design:returntype", Promise)
+], RequestLogModelClass.prototype, "findMany", null);
+__decorate([
+	api({
+		httpMethod: "POST",
+		clients: ["axios", "tanstack-mutation"]
+	}),
+	__decorateMetadata("design:type", Function),
+	__decorateMetadata("design:paramtypes", [Array]),
+	__decorateMetadata("design:returntype", Promise)
+], RequestLogModelClass.prototype, "save", null);
+__decorate([
+	api({
+		httpMethod: "POST",
+		clients: ["axios", "tanstack-mutation"]
+	}),
+	__decorateMetadata("design:type", Function),
+	__decorateMetadata("design:paramtypes", [Array]),
+	__decorateMetadata("design:returntype", Promise)
+], RequestLogModelClass.prototype, "del", null);
+const RequestLogModel = new RequestLogModelClass();
+//#endregion
+export { RequestLogModel };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"request-log.model.js","names":[],"sources":["../../../src/application/request-log/request-log.model.ts"],"sourcesContent":["import {\n  api,\n  asArray,\n  BadRequestException,\n  BaseModelClass,\n  exhaustive,\n  type ListResult,\n  NotFoundException,\n} from \"sonamu\";\n\nimport { SD } from \"../../i18n/sd.generated\";\nimport type { RequestLogSubsetKey, RequestLogSubsetMapping } from \"../sonamu.generated\";\nimport { requestLogLoaderQueries, requestLogSubsetQueries } from \"../sonamu.generated.sso\";\nimport type { RequestLogListParams, RequestLogSaveParams } from \"./request-log.types\";\n\n/*\n  RequestLog Model\n*/\nclass RequestLogModelClass extends BaseModelClass<\n  RequestLogSubsetKey,\n  RequestLogSubsetMapping,\n  typeof requestLogSubsetQueries,\n  typeof requestLogLoaderQueries\n> {\n  constructor() {\n    super(\"RequestLog\", requestLogSubsetQueries, requestLogLoaderQueries);\n  }\n\n  @api({ httpMethod: \"GET\", clients: [\"axios\", \"tanstack-query\"], resourceName: \"RequestLog\" })\n  async findById<T extends RequestLogSubsetKey>(\n    subset: T,\n    id: number,\n  ): Promise<RequestLogSubsetMapping[T]> {\n    const { rows } = await this.findMany(subset, {\n      id,\n      num: 1,\n      page: 1,\n    });\n    if (!rows[0]) {\n      throw new NotFoundException(SD(\"error.entityNotFound\")(\"RequestLog\", id));\n    }\n\n    return rows[0];\n  }\n\n  async findOne<T extends RequestLogSubsetKey>(\n    subset: T,\n    listParams: RequestLogListParams,\n  ): Promise<RequestLogSubsetMapping[T] | null> {\n    const { rows } = await this.findMany(subset, {\n      ...listParams,\n      num: 1,\n      page: 1,\n    });\n\n    return rows[0] ?? null;\n  }\n\n  @api({ httpMethod: \"GET\", clients: [\"axios\", \"tanstack-query\"], resourceName: \"RequestLogs\" })\n  async findMany<T extends RequestLogSubsetKey, LP extends RequestLogListParams>(\n    subset: T,\n    rawParams?: LP,\n  ): Promise<ListResult<LP, RequestLogSubsetMapping[T]>> {\n    // params with defaults\n    const params = {\n      num: 24,\n      page: 1,\n      search: \"id\" as const,\n      orderBy: \"id-desc\" as const,\n      ...rawParams,\n    } satisfies RequestLogListParams;\n\n    // build queries\n    const { qb, onSubset: _ } = this.getSubsetQueries(subset);\n\n    // id\n    if (params.id) {\n      qb.whereIn(\"request_logs.id\", asArray(params.id));\n    }\n\n    // token_name filter (toFilter)\n    if (params.token_name) {\n      qb.where(\"request_logs.token_name\", params.token_name);\n    }\n\n    // search-keyword\n    if (params.search && params.keyword && params.keyword.length > 0) {\n      if (params.search === \"id\") {\n        qb.where(\"request_logs.id\", Number(params.keyword));\n      } else if (params.search === \"token_name\") {\n        qb.where(\"request_logs.token_name\", \"like\", `%${params.keyword}%`);\n      } else if (params.search === \"query\") {\n        qb.where(\"request_logs.query\", \"like\", `%${params.keyword}%`);\n      } else {\n        throw new BadRequestException(SD(\"error.unknownSearchField\")(params.search));\n      }\n    }\n\n    // orderBy\n    if (params.orderBy) {\n      // default orderBy\n      if (params.orderBy === \"id-desc\") {\n        qb.orderBy(\"request_logs.id\", \"desc\");\n      } else {\n        exhaustive(params.orderBy);\n      }\n    }\n\n    const enhancers = this.createEnhancers({\n      A: (row) => ({\n        ...row,\n        // 서브셋별로 virtual 필드 계산로직 추가\n      }),\n    });\n\n    return this.executeSubsetQuery({\n      subset,\n      qb,\n      params,\n      enhancers,\n      debug: false,\n    });\n  }\n\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async save(spa: RequestLogSaveParams[]): Promise<number[]> {\n    const wdb = this.getPuri(\"w\");\n\n    // register\n    spa.forEach((sp) => {\n      wdb.ubRegister(\"request_logs\", sp);\n    });\n\n    // transaction\n    return wdb.transaction(async (trx) => {\n      const ids = await trx.ubUpsert(\"request_logs\");\n\n      return ids;\n    });\n  }\n\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async del(ids: number[]): Promise<number> {\n    const wdb = this.getPuri(\"w\");\n\n    // transaction\n    await wdb.transaction(async (trx) => {\n      return trx.table(\"request_logs\").whereIn(\"request_logs.id\", ids).delete();\n    });\n\n    return ids.length;\n  }\n}\n\nexport const RequestLogModel = new RequestLogModelClass();\n"],"mappings":";;;;;;;AAkBA,IAAM,uBAAN,cAAmC,eAKjC;CACA,cAAc;AACZ,QAAM,cAAc,yBAAyB,wBAAwB;;CAGvE,MACM,SACJ,QACA,IACqC;EACrC,MAAM,EAAE,SAAS,MAAM,KAAK,SAAS,QAAQ;GAC3C;GACA,KAAK;GACL,MAAM;GACP,CAAC;AACF,MAAI,CAAC,KAAK,GACR,OAAM,IAAI,kBAAkB,GAAG,uBAAuB,CAAC,cAAc,GAAG,CAAC;AAG3E,SAAO,KAAK;;CAGd,MAAM,QACJ,QACA,YAC4C;EAC5C,MAAM,EAAE,SAAS,MAAM,KAAK,SAAS,QAAQ;GAC3C,GAAG;GACH,KAAK;GACL,MAAM;GACP,CAAC;AAEF,SAAO,KAAK,MAAM;;CAGpB,MACM,SACJ,QACA,WACqD;EAErD,MAAM,SAAS;GACb,KAAK;GACL,MAAM;GACN,QAAQ;GACR,SAAS;GACT,GAAG;GACJ;EAGD,MAAM,EAAE,IAAI,UAAU,MAAM,KAAK,iBAAiB,OAAO;AAGzD,MAAI,OAAO,GACT,IAAG,QAAQ,mBAAmB,QAAQ,OAAO,GAAG,CAAC;AAInD,MAAI,OAAO,WACT,IAAG,MAAM,2BAA2B,OAAO,WAAW;AAIxD,MAAI,OAAO,UAAU,OAAO,WAAW,OAAO,QAAQ,SAAS,EAC7D,KAAI,OAAO,WAAW,KACpB,IAAG,MAAM,mBAAmB,OAAO,OAAO,QAAQ,CAAC;WAC1C,OAAO,WAAW,aAC3B,IAAG,MAAM,2BAA2B,QAAQ,IAAI,OAAO,QAAQ,GAAG;WACzD,OAAO,WAAW,QAC3B,IAAG,MAAM,sBAAsB,QAAQ,IAAI,OAAO,QAAQ,GAAG;MAE7D,OAAM,IAAI,oBAAoB,GAAG,2BAA2B,CAAC,OAAO,OAAO,CAAC;AAKhF,MAAI,OAAO,QAET,KAAI,OAAO,YAAY,UACrB,IAAG,QAAQ,mBAAmB,OAAO;MAErC,YAAW,OAAO,QAAQ;EAI9B,MAAM,YAAY,KAAK,gBAAgB,EACrC,IAAI,SAAS,EACX,GAAG,KAEJ,GACF,CAAC;AAEF,SAAO,KAAK,mBAAmB;GAC7B;GACA;GACA;GACA;GACA,OAAO;GACR,CAAC;;CAGJ,MACM,KAAK,KAAgD;EACzD,MAAM,MAAM,KAAK,QAAQ,IAAI;AAG7B,MAAI,SAAS,OAAO;AAClB,OAAI,WAAW,gBAAgB,GAAG;IAClC;AAGF,SAAO,IAAI,YAAY,OAAO,QAAQ;AAGpC,UAFY,MAAM,IAAI,SAAS,eAAe;IAG9C;;CAGJ,MACM,IAAI,KAAgC;AAIxC,QAHY,KAAK,QAAQ,IAAI,CAGnB,YAAY,OAAO,QAAQ;AACnC,UAAO,IAAI,MAAM,eAAe,CAAC,QAAQ,mBAAmB,IAAI,CAAC,QAAQ;IACzE;AAEF,SAAO,IAAI;;;;CA1HZ,IAAI;EAAE,YAAY;EAAO,SAAS,CAAC,SAAS,iBAAiB;EAAE,cAAc;EAAc,CAAC;;;;;;CA8B5F,IAAI;EAAE,YAAY;EAAO,SAAS,CAAC,SAAS,iBAAiB;EAAE,cAAc;EAAe,CAAC;;;;;;CAkE7F,IAAI;EAAE,YAAY;EAAQ,SAAS,CAAC,SAAS,oBAAoB;EAAE,CAAC;;;;;;CAiBpE,IAAI;EAAE,YAAY;EAAQ,SAAS,CAAC,SAAS,oBAAoB;EAAE,CAAC;;;;;AAavE,MAAa,kBAAkB,IAAI,sBAAsB"}

package/bundle/dist/application/request-log/request-log.types.js

@@ -0,0 +1,13 @@
+import "../../_virtual/_rolldown/runtime.js";
+import { RequestLogBaseListParams, RequestLogBaseSchema } from "../sonamu.generated.js";
+//#region src/application/request-log/request-log.types.ts
+const RequestLogListParams = RequestLogBaseListParams;
+const RequestLogSaveParams = RequestLogBaseSchema.partial({
+	id: true,
+	created_at: true,
+	token_name: true
+});
+//#endregion
+export { RequestLogListParams, RequestLogSaveParams };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVxdWVzdC1sb2cudHlwZXMuanMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2FwcGxpY2F0aW9uL3JlcXVlc3QtbG9nL3JlcXVlc3QtbG9nLnR5cGVzLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgeiB9IGZyb20gXCJ6b2RcIjtcblxuaW1wb3J0IHsgUmVxdWVzdExvZ0Jhc2VMaXN0UGFyYW1zLCBSZXF1ZXN0TG9nQmFzZVNjaGVtYSB9IGZyb20gXCIuLi9zb25hbXUuZ2VuZXJhdGVkXCI7XG5cbi8vIFJlcXVlc3RMb2cgLSBMaXN0UGFyYW1zXG5leHBvcnQgY29uc3QgUmVxdWVzdExvZ0xpc3RQYXJhbXMgPSBSZXF1ZXN0TG9nQmFzZUxpc3RQYXJhbXM7XG5leHBvcnQgdHlwZSBSZXF1ZXN0TG9nTGlzdFBhcmFtcyA9IHouaW5mZXI8dHlwZW9mIFJlcXVlc3RMb2dMaXN0UGFyYW1zPjtcblxuLy8gUmVxdWVzdExvZyAtIFNhdmVQYXJhbXNcbmV4cG9ydCBjb25zdCBSZXF1ZXN0TG9nU2F2ZVBhcmFtcyA9IFJlcXVlc3RMb2dCYXNlU2NoZW1hLnBhcnRpYWwoe1xuICBpZDogdHJ1ZSxcbiAgY3JlYXRlZF9hdDogdHJ1ZSxcbiAgdG9rZW5fbmFtZTogdHJ1ZSxcbn0pO1xuZXhwb3J0IHR5cGUgUmVxdWVzdExvZ1NhdmVQYXJhbXMgPSB6LmluZmVyPHR5cGVvZiBSZXF1ZXN0TG9nU2F2ZVBhcmFtcz47XG4iXSwibWFwcGluZ3MiOiI7OztBQUtBLE1BQWEsdUJBQXVCO0FBSXBDLE1BQWEsdUJBQXVCLHFCQUFxQixRQUFRO0NBQy9ELElBQUk7Q0FDSixZQUFZO0NBQ1osWUFBWTtDQUNiLENBQUMifQ==

package/bundle/dist/application/sonamu.generated.js

@@ -0,0 +1,99 @@
+import "../_virtual/_rolldown/runtime.js";
+import { z } from "zod";
+import { SonamuQueryMode, zArrayable } from "sonamu";
+//#region src/application/sonamu.generated.ts
+/**
+* @generated
+* 직접 수정하지 마세요.
+*/
+const RequestLogOrderBy = z.enum(["id-desc"]).describe("RequestLogOrderBy");
+const RequestLogOrderByLabel = { "id-desc": "ID최신순" };
+const RequestLogSearchField = z.enum([
+	"id",
+	"token_name",
+	"query"
+]).describe("RequestLogSearchField");
+const RequestLogSearchFieldLabel = {
+	id: "ID",
+	token_name: "토큰이름",
+	query: "쿼리"
+};
+const TokenOrderBy = z.enum(["id-desc"]).describe("TokenOrderBy");
+const TokenOrderByLabel = { "id-desc": "ID최신순" };
+const TokenSearchField = z.enum(["id", "name"]).describe("TokenSearchField");
+const TokenSearchFieldLabel = {
+	id: "ID",
+	name: "이름"
+};
+const RequestLogBaseSchema = z.object({
+	id: z.int(),
+	created_at: z.date(),
+	token_name: z.string().max(100),
+	query: z.string(),
+	response: z.string(),
+	input_tokens: z.int(),
+	output_tokens: z.int(),
+	cache_read_tokens: z.int(),
+	cache_creation_tokens: z.int(),
+	duration_ms: z.int()
+});
+const TokenBaseSchema = z.object({
+	id: z.int(),
+	created_at: z.date(),
+	token: z.string(),
+	name: z.string(),
+	refresh_token: z.string().nullable(),
+	expires_at: z.bigint().nullable(),
+	account_uuid: z.string().nullable(),
+	active: z.boolean()
+});
+const RequestLogBaseListParams = z.object({
+	num: z.number().int().nonnegative(),
+	page: z.number().int().min(1),
+	search: RequestLogSearchField,
+	keyword: z.string(),
+	orderBy: RequestLogOrderBy,
+	queryMode: SonamuQueryMode,
+	id: zArrayable(z.number().int().positive()),
+	sonamuFilter: z.custom(),
+	token_name: z.string().max(100)
+}).partial();
+const TokenBaseListParams = z.object({
+	num: z.number().int().nonnegative(),
+	page: z.number().int().min(1),
+	search: TokenSearchField,
+	keyword: z.string(),
+	orderBy: TokenOrderBy,
+	queryMode: SonamuQueryMode,
+	id: zArrayable(z.number().int().positive()),
+	sonamuFilter: z.custom(),
+	token: z.string()
+}).partial();
+const RequestLogSubsetA = z.object({
+	id: z.int(),
+	created_at: z.date(),
+	token_name: z.string().max(100),
+	query: z.string(),
+	response: z.string(),
+	input_tokens: z.int(),
+	output_tokens: z.int(),
+	cache_read_tokens: z.int(),
+	cache_creation_tokens: z.int(),
+	duration_ms: z.int()
+});
+const RequestLogSubsetKey = z.enum(["A"]);
+const TokenSubsetA = z.object({
+	id: z.int(),
+	created_at: z.date(),
+	token: z.string(),
+	name: z.string(),
+	refresh_token: z.string().nullable(),
+	expires_at: z.bigint().nullable(),
+	account_uuid: z.string().nullable(),
+	active: z.boolean()
+});
+const TokenSubsetKey = z.enum(["A"]);
+//#endregion
+export { RequestLogBaseListParams, RequestLogBaseSchema, RequestLogOrderBy, RequestLogOrderByLabel, RequestLogSearchField, RequestLogSearchFieldLabel, RequestLogSubsetA, RequestLogSubsetKey, TokenBaseListParams, TokenBaseSchema, TokenOrderBy, TokenOrderByLabel, TokenSearchField, TokenSearchFieldLabel, TokenSubsetA, TokenSubsetKey };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"sonamu.generated.js","names":[],"sources":["../../src/application/sonamu.generated.ts"],"sourcesContent":["/**\n * @generated\n * 직접 수정하지 마세요.\n */\n/* oxlint-disable */\n\nimport { zArrayable, SonamuQueryMode, ApplySonamuFilter } from \"sonamu\";\nimport { z } from \"zod\";\n\n// Enums: RequestLog\nexport const RequestLogOrderBy = z.enum([\"id-desc\"]).describe(\"RequestLogOrderBy\");\nexport type RequestLogOrderBy = z.infer<typeof RequestLogOrderBy>;\nexport const RequestLogOrderByLabel = { \"id-desc\": \"ID최신순\" };\nexport const RequestLogSearchField = z\n  .enum([\"id\", \"token_name\", \"query\"])\n  .describe(\"RequestLogSearchField\");\nexport type RequestLogSearchField = z.infer<typeof RequestLogSearchField>;\nexport const RequestLogSearchFieldLabel = { id: \"ID\", token_name: \"토큰이름\", query: \"쿼리\" };\n\n// Enums: Token\nexport const TokenOrderBy = z.enum([\"id-desc\"]).describe(\"TokenOrderBy\");\nexport type TokenOrderBy = z.infer<typeof TokenOrderBy>;\nexport const TokenOrderByLabel = { \"id-desc\": \"ID최신순\" };\nexport const TokenSearchField = z.enum([\"id\", \"name\"]).describe(\"TokenSearchField\");\nexport type TokenSearchField = z.infer<typeof TokenSearchField>;\nexport const TokenSearchFieldLabel = { id: \"ID\", name: \"이름\" };\n\n// BaseSchema: RequestLog\nexport const RequestLogBaseSchema = z.object({\n  id: z.int(),\n  created_at: z.date(),\n  token_name: z.string().max(100),\n  query: z.string(),\n  response: z.string(),\n  input_tokens: z.int(),\n  output_tokens: z.int(),\n  cache_read_tokens: z.int(),\n  cache_creation_tokens: z.int(),\n  duration_ms: z.int(),\n});\nexport type RequestLogBaseSchema = z.infer<typeof RequestLogBaseSchema> & {\n  readonly __hasDefault__: readonly [\"created_at\", \"id\"];\n};\n\n// BaseSchema: Token\nexport const TokenBaseSchema = z.object({\n  id: z.int(),\n  created_at: z.date(),\n  token: z.string(),\n  name: z.string(),\n  refresh_token: z.string().nullable(),\n  expires_at: z.bigint().nullable(),\n  account_uuid: z.string().nullable(),\n  active: z.boolean(),\n});\nexport type TokenBaseSchema = z.infer<typeof TokenBaseSchema> & {\n  readonly __hasDefault__: readonly [\n    \"created_at\",\n    \"refresh_token\",\n    \"expires_at\",\n    \"account_uuid\",\n    \"active\",\n    \"id\",\n  ];\n};\n\n// BaseListParams: RequestLog\nexport const RequestLogBaseListParams = z\n  .object({\n    num: z.number().int().nonnegative(),\n    page: z.number().int().min(1),\n    search: RequestLogSearchField,\n    keyword: z.string(),\n    orderBy: RequestLogOrderBy,\n    queryMode: SonamuQueryMode,\n    id: zArrayable(z.number().int().positive()),\n    sonamuFilter: z.custom<ApplySonamuFilter<RequestLogBaseSchema, never, never>>(),\n    token_name: z.string().max(100),\n  })\n  .partial();\nexport type RequestLogBaseListParams = z.infer<typeof RequestLogBaseListParams>;\n\n// BaseListParams: Token\nexport const TokenBaseListParams = z\n  .object({\n    num: z.number().int().nonnegative(),\n    page: z.number().int().min(1),\n    search: TokenSearchField,\n    keyword: z.string(),\n    orderBy: TokenOrderBy,\n    queryMode: SonamuQueryMode,\n    id: zArrayable(z.number().int().positive()),\n    sonamuFilter: z.custom<ApplySonamuFilter<TokenBaseSchema, never, never>>(),\n    token: z.string(),\n  })\n  .partial();\nexport type TokenBaseListParams = z.infer<typeof TokenBaseListParams>;\n\n// Subsets: RequestLog\nexport const RequestLogSubsetA = z.object({\n  id: z.int(),\n  created_at: z.date(),\n  token_name: z.string().max(100),\n  query: z.string(),\n  response: z.string(),\n  input_tokens: z.int(),\n  output_tokens: z.int(),\n  cache_read_tokens: z.int(),\n  cache_creation_tokens: z.int(),\n  duration_ms: z.int(),\n});\nexport type RequestLogSubsetA = z.infer<typeof RequestLogSubsetA>;\nexport type RequestLogSubsetMapping = {\n  A: RequestLogSubsetA;\n};\nexport const RequestLogSubsetKey = z.enum([\"A\"]);\nexport type RequestLogSubsetKey = z.infer<typeof RequestLogSubsetKey>;\n\n// Subsets: Token\nexport const TokenSubsetA = z.object({\n  id: z.int(),\n  created_at: z.date(),\n  token: z.string(),\n  name: z.string(),\n  refresh_token: z.string().nullable(),\n  expires_at: z.bigint().nullable(),\n  account_uuid: z.string().nullable(),\n  active: z.boolean(),\n});\nexport type TokenSubsetA = z.infer<typeof TokenSubsetA>;\nexport type TokenSubsetMapping = {\n  A: TokenSubsetA;\n};\nexport const TokenSubsetKey = z.enum([\"A\"]);\nexport type TokenSubsetKey = z.infer<typeof TokenSubsetKey>;\n"],"mappings":"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"}

package/bundle/dist/application/sonamu.generated.sso.js

@@ -0,0 +1,34 @@
+import "../_virtual/_rolldown/runtime.js";
+//#region src/application/sonamu.generated.sso.ts
+const requestLogSubsetQueries = { A: (qbWrapper) => {
+	return qbWrapper.from("request_logs").select({
+		id: "request_logs.id",
+		created_at: "request_logs.created_at",
+		token_name: "request_logs.token_name",
+		query: "request_logs.query",
+		response: "request_logs.response",
+		input_tokens: "request_logs.input_tokens",
+		output_tokens: "request_logs.output_tokens",
+		cache_read_tokens: "request_logs.cache_read_tokens",
+		cache_creation_tokens: "request_logs.cache_creation_tokens",
+		duration_ms: "request_logs.duration_ms"
+	});
+} };
+const requestLogLoaderQueries = { A: [] };
+const tokenSubsetQueries = { A: (qbWrapper) => {
+	return qbWrapper.from("tokens").select({
+		id: "tokens.id",
+		created_at: "tokens.created_at",
+		token: "tokens.token",
+		name: "tokens.name",
+		refresh_token: "tokens.refresh_token",
+		expires_at: "tokens.expires_at",
+		account_uuid: "tokens.account_uuid",
+		active: "tokens.active"
+	});
+} };
+const tokenLoaderQueries = { A: [] };
+//#endregion
+export { requestLogLoaderQueries, requestLogSubsetQueries, tokenLoaderQueries, tokenSubsetQueries };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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