@cartanova/qgrid-cli 1.9.0 → 2.0.1

package/bundle/src/migrations/20260520134908_alter_request_logs_add2_alter8.ts

@@ -0,0 +1,44 @@
+import { type Knex } from "knex";
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.alterTable("request_logs", (table) => {
+    // add
+    table.text("error_message").nullable();
+    table.text("status").notNullable().defaultTo("succeeded");
+    // alter column
+    table.integer("cache_creation_tokens").notNullable().defaultTo(knex.raw("0")).alter();
+    // alter column
+    table.integer("cache_read_tokens").notNullable().defaultTo(knex.raw("0")).alter();
+    // alter column
+    table.integer("duration_ms").notNullable().defaultTo(knex.raw("0")).alter();
+    // alter column
+    table.integer("input_tokens").notNullable().defaultTo(knex.raw("0")).alter();
+    // alter column
+    table.integer("output_tokens").notNullable().defaultTo(knex.raw("0")).alter();
+    // alter column
+    table.text("response").notNullable().defaultTo("").alter();
+    // alter column
+    table.string("token_name", 100).nullable().alter();
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable("request_logs", (table) => {
+    // rollback - add
+    table.dropColumns("error_message", "status");
+    // rollback - alter column
+    table.integer("cache_creation_tokens").notNullable().alter();
+    // rollback - alter column
+    table.integer("cache_read_tokens").notNullable().alter();
+    // rollback - alter column
+    table.integer("duration_ms").notNullable().alter();
+    // rollback - alter column
+    table.integer("input_tokens").notNullable().alter();
+    // rollback - alter column
+    table.integer("output_tokens").notNullable().alter();
+    // rollback - alter column
+    table.text("response").notNullable().alter();
+    // rollback - alter column
+    table.string("token_name", 100).notNullable().alter();
+  });
+}

package/bundle/src/migrations/20260520134909_alter_request_log_steps_add1_alter3.ts

@@ -0,0 +1,23 @@
+import { type Knex } from "knex";
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.alterTable("request_log_steps", (table) => {
+    // add
+    table.text("error").nullable();
+    // alter column
+    table.text("tool_args").nullable().alter();
+    // alter column
+    table.text("tool_result").nullable().alter();
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable("request_log_steps", (table) => {
+    // rollback - add
+    table.dropColumns("error");
+    // rollback - alter column
+    table.jsonb("tool_args").nullable().alter();
+    // rollback - alter column
+    table.jsonb("tool_result").nullable().alter();
+  });
+}

package/bundle/src/migrations/20260520141449_alter_request_logs_add1_alter1.ts

@@ -0,0 +1,15 @@
+import { type Knex } from "knex";
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.alterTable("request_logs", (table) => {
+    // add
+    table.integer("tool_call_count").notNullable().defaultTo(knex.raw("0"));
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable("request_logs", (table) => {
+    // rollback - add
+    table.dropColumns("tool_call_count");
+  });
+}

package/bundle/src/migrations/20260521134025_alter_request_log_steps_alter1.ts

@@ -0,0 +1,13 @@
+import { type Knex } from "knex";
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.raw(
+    `CREATE INDEX request_log_steps_request_log_id_index ON request_log_steps USING btree(request_log_id ASC NULLS LAST);`,
+  );
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable("request_log_steps", (table) => {
+    table.dropIndex(["request_log_id"], "request_log_steps_request_log_id_index");
+  });
+}

package/bundle/src/migrations/20260521134026_alter_request_log_steps_foreigns.ts

@@ -0,0 +1,17 @@
+import { type Knex } from "knex";
+
+export async function up(knex: Knex): Promise<void> {
+  return knex.schema.alterTable("request_log_steps", (table) => {
+    table
+      .foreign("request_log_id")
+      .references("request_logs.id")
+      .onUpdate("CASCADE")
+      .onDelete("CASCADE");
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  return knex.schema.alterTable("request_log_steps", (table) => {
+    table.dropForeign(["request_log_id"]);
+  });
+}

package/bundle/src/migrations/20260522181721_alter_request_log_steps_add2_alter1.ts

@@ -0,0 +1,16 @@
+import { type Knex } from "knex";
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.alterTable("request_log_steps", (table) => {
+    // add
+    table.text("reasoning_text").nullable();
+    table.integer("reasoning_tokens").nullable();
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable("request_log_steps", (table) => {
+    // rollback - add
+    table.dropColumns("reasoning_text", "reasoning_tokens");
+  });
+}

package/bundle/src/sonamu.config.ts

@@ -1,11 +1,19 @@
 import path from "path";
 
 import { getConsoleSink } from "@logtape/logtape";
+import { getLogger } from "@logtape/logtape";
 import { getPrettyFormatter } from "@logtape/pretty";
 import dotenv from "dotenv";
 import { CachePresets, defineConfig } from "sonamu";
 import { drivers as cacheDrivers, store } from "sonamu/cache";
 
+import { QgridDispatcher } from "./application/qgrid/qgrid.dispatcher";
+import { QgridFrame } from "./application/qgrid/qgrid.frame";
+import { TokenSubscriber } from "./application/qgrid/token-subscriber";
+import { ensureTokensTrigger } from "./application/qgrid/token-trigger-setup";
+import { TokenModel } from "./application/token/token.model";
+import { OpenAIDispatcher } from "./utils/providers/openai/openai-dispatcher";
+
 dotenv.config({ path: path.join(import.meta.dirname, "../.env") });
 
 const host = process.env.HOST ?? "localhost";
@@ -13,16 +21,16 @@ const port = Number(process.env.PORT ?? 44900);
 
 const connConfig = {
   host: process.env.QGRID_DB_HOST ?? "localhost",
-  port: Number(process.env.QGRID_DB_PORT ?? 44901),
+  port: Number(process.env.QGRID_DB_PORT ?? 5432),
   user: process.env.QGRID_DB_USER ?? "postgres",
   password: process.env.QGRID_DB_PASSWORD ?? "postgres",
   database: process.env.QGRID_DB_NAME ?? "qgrid",
 };
 
 export default defineConfig({
-  projectName: process.env.PROJECT_NAME ?? "SonamuProject",
+  projectName: process.env.PROJECT_NAME ?? "Qgrid",
   database: {
-    name: process.env.QGRID_DB_NAME ?? "qgrid",
+    name: "qgrid",
     defaultOptions: {
       connection: {
         ...connConfig,
@@ -33,20 +41,8 @@ export default defineConfig({
     environments: {
       fixture: {
         connection: {
-          host: process.env.DEV0_DB_HOST,
-          port: Number(process.env.DEV0_DB_PORT),
-          database: process.env.QGRID_DB_NAME + "_fixture",
-          user: process.env.DEV0_DB_USER,
-          password: process.env.DEV0_DB_PASSWORD,
-        },
-      },
-      test: {
-        connection: {
-          host: "0.0.0.0",
-          port: 54321,
-          database: "qgrid_test",
-          user: "postgres",
-          password: "postgres",
+          ...connConfig,
+          database: process.env.QGRID_DB_NAME,
         },
       },
     },
@@ -65,14 +61,6 @@ export default defineConfig({
   sync: {
     targets: ["web"],
   },
-  slackConfirm:
-    process.env.SLACK_BOT_TOKEN && process.env.SLACK_CHANNEL_ID
-      ? {
-          targets: ["development_master", "production_master"],
-          botToken: process.env.SLACK_BOT_TOKEN ?? "",
-          channelId: process.env.SLACK_CHANNEL_ID ?? "",
-        }
-      : undefined,
   test: {
     parallel: true,
     maxWorkers: 4,
@@ -102,6 +90,7 @@ export default defineConfig({
     plugins: {
       formbody: true,
       qs: true,
+      sse: true,
       multipart: { limits: { fileSize: 1024 * 1024 * 30 } },
       static: {
         root: path.join(import.meta.dirname, "/../", "public"),
@@ -114,9 +103,7 @@ export default defineConfig({
           if (!code || !state) {
             return reply.redirect("/?oauth=error&reason=missing_params");
           }
-          // Frame의 oauthCallback으로 위임
           try {
-            const { QgridFrame } = await import("./application/qgrid/qgrid.frame");
             await QgridFrame.handleOAuthCallback(code, state, reply);
           } catch (e) {
             return reply.redirect(
@@ -124,6 +111,9 @@ export default defineConfig({
             );
           }
         });
+
+        // OpenAI OAuth 는 codex app-server 가 자체 callback 서버를 올림
+        // handleOpenAICallback 불필요 — oauthCompleteOpenAI API 로 완료 확인
       },
     },
     apiConfig: {
@@ -178,55 +168,64 @@ export default defineConfig({
     },
     lifecycle: {
       onStart: async () => {
-        // DB 마이그레이션 자동 실행 (테이블 없으면 생성)
+        const log = getLogger(["qgrid", "startup"]);
+
         try {
-          const { TokenModel } = await import("./application/token/token.model");
           const knex = TokenModel.getDB("w");
           const migrationsDir = path.join(import.meta.dirname, "../src/migrations");
-          const [batch, log] = await knex.migrate.latest({
-            directory: migrationsDir,
-          });
-          if (log.length > 0) {
-            console.log(`✓ Migration: ${log.length} applied (batch ${batch})`);
-            log.forEach((name: string) => console.log(`  ✓ ${name}`));
+          const [batch, migrations] = await knex.migrate.latest({ directory: migrationsDir });
+          if (migrations.length > 0) {
+            log.info(`migration: ${migrations.length} applied (batch ${batch})`);
           }
         } catch (e) {
-          console.warn(`⚠ Migration skipped: ${(e as Error).message}`);
+          log.warn(`migration skipped: ${(e as Error).message}`);
         }
 
-        const { QgridDispatcher } = await import("./application/qgrid/qgrid.dispatcher");
-        const { ensureTokensTrigger } = await import("./application/qgrid/token-trigger-setup");
-        const { TokenSubscriber } = await import("./application/qgrid/token-subscriber");
-
         let triggerReady = true;
         try {
           await ensureTokensTrigger(connConfig);
         } catch (e) {
           triggerReady = false;
-          console.warn(
-            `⚠ Token trigger setup failed: ${(e as Error).message}. Continuing with LISTEN/reconcile.`,
-          );
+          log.warn(`trigger setup failed: ${(e as Error).message}`);
         }
 
         const subscriber = new TokenSubscriber(connConfig, QgridDispatcher);
         QgridDispatcher.subscriber = subscriber;
 
         const started = await subscriber.start();
-        const tokenInfo = started
-          ? `${QgridDispatcher.tokens.size} active tokens, LISTEN active`
-          : `degraded — token sync retry scheduled`;
-        const triggerInfo = triggerReady ? "" : ", trigger setup failed";
-        console.log(`🌲 Server listening on http://${host}:${port} (${tokenInfo}${triggerInfo})`);
+
+        try {
+          const openaiDispatcher = new OpenAIDispatcher();
+          await openaiDispatcher.start();
+          QgridDispatcher.openaiDispatcher = openaiDispatcher;
+        } catch (e) {
+          log.warn(`openai dispatcher failed: ${(e as Error).message}`);
+        }
+
+        const allTokens = [...QgridDispatcher.tokens.values()];
+        const anthropicCount = allTokens.filter((t) => t.provider === "anthropic").length;
+        const openaiReady = QgridDispatcher.openaiDispatcher?.readyWorkerCount ?? 0;
+        const openaiTotal = QgridDispatcher.openaiDispatcher?.workerCount ?? 0;
+
+        log.info(`listening on http://${host}:${port}`);
+        log.info(`anthropic: ${anthropicCount} tokens ready`);
+        log.info(`openai: ${openaiReady}/${openaiTotal} tokens ready`);
+        log.info(
+          `subscriber: ${started ? "LISTEN active" : "degraded"}${triggerReady ? "" : ", trigger failed"}`,
+        );
       },
       onShutdown: async () => {
-        const { QgridDispatcher } = await import("./application/qgrid/qgrid.dispatcher");
+        const log = getLogger(["qgrid", "startup"]);
+        if (QgridDispatcher.openaiDispatcher) {
+          await QgridDispatcher.openaiDispatcher.stop();
+        }
         if (QgridDispatcher.subscriber) {
           await QgridDispatcher.subscriber.stop();
         }
-        console.log("graceful shutdown");
+        log.info("graceful shutdown");
       },
       onError: (error, _request, reply) => {
-        console.error(error);
+        getLogger(["qgrid"]).error(`${error}`);
         reply.status(500).send({
           name: error.name,
           message: error.message,

package/bundle/src/typings/sonamu.d.ts

@@ -15,4 +15,4 @@ declare module "sonamu" {
   }
 }
 
-export {};
+export {}

package/bundle/src/utils/providers/common/credentials.ts

@@ -0,0 +1,26 @@
+import {
+  type AnthropicCredentials,
+  type OpenAICredentials,
+  type TokenCredentials,
+} from "../../../application/token/token.types";
+
+export function getAccessToken(creds: TokenCredentials): string {
+  return creds.accessToken;
+}
+
+export function getRefreshToken(creds: TokenCredentials): string | undefined {
+  return creds.refreshToken;
+}
+
+export function getExpiresAt(creds: TokenCredentials): number {
+  if ("expiresAt" in creds) return creds.expiresAt;
+  return creds.accessTokenExpiresAt;
+}
+
+export function isAnthropicCredentials(creds: TokenCredentials): creds is AnthropicCredentials {
+  return "accountUuid" in creds;
+}
+
+export function isOpenAICredentials(creds: TokenCredentials): creds is OpenAICredentials {
+  return "accountId" in creds;
+}

package/bundle/src/utils/providers/common/model-cost.ts

@@ -0,0 +1,65 @@
+/**
+ * 모델별 토큰 가격 테이블 + cost 계산.
+ *
+ * claude code 와 동일 패턴: 클라이언트에서 가격 테이블로 직접 계산.
+ * 가격 단위: USD per 1M tokens.
+ *
+ * OpenAI 모델 목록: codex app-server model/list RPC 로 실측 (2026-05-18)
+ *
+ * @see https://platform.openai.com/docs/pricing
+ * @see https://platform.claude.com/docs/en/about-claude/pricing
+ */
+
+export interface ModelCosts {
+  inputTokens: number;
+  outputTokens: number;
+  cachedInputTokens: number;
+}
+
+// ── OpenAI — codex app-server 에서 사용 가능한 모델 ─────────────────
+
+const OPENAI_COSTS: Record<string, ModelCosts> = {
+  "gpt-5.5": { inputTokens: 2, outputTokens: 8, cachedInputTokens: 0.5 },
+  "gpt-5.4": { inputTokens: 2, outputTokens: 8, cachedInputTokens: 0.5 },
+  "gpt-5.4-mini": { inputTokens: 0.4, outputTokens: 1.6, cachedInputTokens: 0.1 },
+  "gpt-5.3-codex": { inputTokens: 2, outputTokens: 8, cachedInputTokens: 0.5 },
+  "gpt-5.2": { inputTokens: 2, outputTokens: 8, cachedInputTokens: 0.5 },
+};
+
+// ── Anthropic ───────────────────────────────────────────────────────
+
+const ANTHROPIC_COSTS: Record<string, ModelCosts> = {
+  sonnet: { inputTokens: 3, outputTokens: 15, cachedInputTokens: 0.3 },
+  "claude-3-5-haiku": { inputTokens: 0.8, outputTokens: 4, cachedInputTokens: 0.08 },
+  "claude-haiku-4-5": { inputTokens: 1, outputTokens: 5, cachedInputTokens: 0.1 },
+  "claude-3-5-sonnet": { inputTokens: 3, outputTokens: 15, cachedInputTokens: 0.3 },
+  "claude-3-7-sonnet": { inputTokens: 3, outputTokens: 15, cachedInputTokens: 0.3 },
+  "claude-sonnet-4": { inputTokens: 3, outputTokens: 15, cachedInputTokens: 0.3 },
+  "claude-sonnet-4-5": { inputTokens: 3, outputTokens: 15, cachedInputTokens: 0.3 },
+  "claude-sonnet-4-6": { inputTokens: 3, outputTokens: 15, cachedInputTokens: 0.3 },
+  "claude-sonnet-4-7": { inputTokens: 3, outputTokens: 15, cachedInputTokens: 0.3 },
+  "claude-opus-4": { inputTokens: 15, outputTokens: 75, cachedInputTokens: 1.5 },
+  "claude-opus-4-1": { inputTokens: 15, outputTokens: 75, cachedInputTokens: 1.5 },
+  "claude-opus-4-5": { inputTokens: 5, outputTokens: 25, cachedInputTokens: 0.5 },
+  "claude-opus-4-6": { inputTokens: 5, outputTokens: 25, cachedInputTokens: 0.5 },
+  "claude-opus-4-7": { inputTokens: 5, outputTokens: 25, cachedInputTokens: 0.5 },
+};
+
+const DEFAULT_COSTS: ModelCosts = { inputTokens: 3, outputTokens: 15, cachedInputTokens: 0.3 };
+
+export function getModelCosts(model: string): ModelCosts {
+  return OPENAI_COSTS[model] ?? ANTHROPIC_COSTS[model] ?? DEFAULT_COSTS;
+}
+
+export function calculateCostUsd(
+  model: string,
+  usage: { inputTokens: number; outputTokens: number; cachedInputTokens?: number },
+): number {
+  const costs = getModelCosts(model);
+  const nonCachedInput = usage.inputTokens - (usage.cachedInputTokens ?? 0);
+  return (
+    (nonCachedInput / 1_000_000) * costs.inputTokens +
+    (usage.outputTokens / 1_000_000) * costs.outputTokens +
+    ((usage.cachedInputTokens ?? 0) / 1_000_000) * costs.cachedInputTokens
+  );
+}

package/bundle/src/utils/providers/common/provider-dispatcher.ts

@@ -0,0 +1,36 @@
+/**
+ * ProviderDispatcher — provider 별 LLM 요청 실행 인터페이스.
+ *
+ * MVP 에서는 stream() 만. getRateLimits(), listModels() 는 future.
+ */
+
+import { type JsonValue } from "../../../codex-protocol/serde_json/JsonValue";
+import { type TokenUsageBreakdown } from "../../../codex-protocol/v2/TokenUsageBreakdown";
+import { type UserInput } from "../../../codex-protocol/v2/UserInput";
+
+export interface GenerateRequest {
+  model: string;
+  input: Array<UserInput>;
+  systemPrompt?: string;
+  outputSchema?: JsonValue;
+  effort?: string;
+  verbosity?: string;
+  reasoningSummary?: string;
+  serviceTier?: string;
+  history?: Array<JsonValue>;
+  abortSignal?: AbortSignal;
+}
+
+export interface GenerateResult {
+  text: string;
+  tokenName: string;
+  usage: TokenUsageBreakdown;
+  durationMs: number;
+  model: string;
+}
+
+export interface ProviderDispatcher {
+  generate(req: GenerateRequest): Promise<GenerateResult>;
+  start(): Promise<void>;
+  stop(): Promise<void>;
+}

package/bundle/src/utils/providers/common/strictifier.ts

@@ -0,0 +1,128 @@
+/**
+ * JSON Schema → OpenAI strict JSON Schema 변환.
+ *
+ * OpenAI Responses API strict 모드 요구사항:
+ *  - 모든 object 에 additionalProperties: false
+ *  - 모든 object properties 를 required 에 포함
+ *  - optional 필드 → anyOf [original, { type: 'null' }] 로 required 유지
+ *  - recursive 처리 (nested objects, arrays, allOf/anyOf/oneOf)
+ */
+
+export type JsonSchema = Record<string, unknown>;
+
+export class StrictifierError extends Error {
+  constructor(
+    message: string,
+    public path: string,
+  ) {
+    super(`strictifier: ${message} (at ${path})`);
+    this.name = "StrictifierError";
+  }
+}
+
+export function strictify(schema: JsonSchema): JsonSchema {
+  return strictifyNode(schema, "$");
+}
+
+function strictifyNode(node: JsonSchema, path: string): JsonSchema {
+  if (typeof node !== "object" || node === null) return node;
+
+  const type = node.type as string | undefined;
+
+  if (type === "object" || node.properties) {
+    return strictifyObject(node, path);
+  }
+
+  if (type === "array") {
+    return strictifyArray(node, path);
+  }
+
+  if (node.anyOf) {
+    return {
+      ...node,
+      anyOf: (node.anyOf as JsonSchema[]).map((s, i) => strictifyNode(s, `${path}.anyOf[${i}]`)),
+    };
+  }
+
+  if (node.oneOf) {
+    return {
+      ...node,
+      oneOf: (node.oneOf as JsonSchema[]).map((s, i) => strictifyNode(s, `${path}.oneOf[${i}]`)),
+    };
+  }
+
+  if (node.allOf) {
+    return {
+      ...node,
+      allOf: (node.allOf as JsonSchema[]).map((s, i) => strictifyNode(s, `${path}.allOf[${i}]`)),
+    };
+  }
+
+  if (node.$ref) {
+    return { ...node };
+  }
+
+  return { ...node };
+}
+
+function strictifyObject(node: JsonSchema, path: string): JsonSchema {
+  const properties = node.properties as Record<string, JsonSchema> | undefined;
+  if (!properties) {
+    return { ...node, additionalProperties: false };
+  }
+
+  const existingRequired = new Set((node.required as string[] | undefined) ?? []);
+  const allKeys = Object.keys(properties);
+
+  const strictProps: Record<string, JsonSchema> = {};
+  for (const key of allKeys) {
+    const prop = properties[key]!;
+    const strictProp = strictifyNode(prop, `${path}.${key}`);
+
+    if (!existingRequired.has(key)) {
+      strictProps[key] = makeNullable(strictProp);
+    } else {
+      strictProps[key] = strictProp;
+    }
+  }
+
+  const result: JsonSchema = {
+    ...node,
+    type: "object",
+    properties: strictProps,
+    required: allKeys,
+    additionalProperties: false,
+  };
+
+  return result;
+}
+
+function strictifyArray(node: JsonSchema, path: string): JsonSchema {
+  const items = node.items as JsonSchema | undefined;
+  if (!items) return { ...node };
+
+  return {
+    ...node,
+    items: strictifyNode(items, `${path}.items`),
+  };
+}
+
+function makeNullable(schema: JsonSchema): JsonSchema {
+  if (schema.type === "null") return schema;
+
+  if (schema.anyOf) {
+    const variants = schema.anyOf as JsonSchema[];
+    const hasNull = variants.some((v) => v.type === "null");
+    if (hasNull) return schema;
+    return { anyOf: [...variants, { type: "null" }] };
+  }
+
+  if (schema.oneOf) {
+    const variants = schema.oneOf as JsonSchema[];
+    const hasNull = variants.some((v) => v.type === "null");
+    if (hasNull) return schema;
+    return { oneOf: [...variants, { type: "null" }] };
+  }
+
+  return { anyOf: [schema, { type: "null" }] };
+}

package/bundle/src/utils/providers/common/token-picker.ts

@@ -0,0 +1,18 @@
+/**
+ * TokenPicker — 토큰 선택 알고리즘 인터페이스 + RoundRobinPicker 구현.
+ */
+
+export interface TokenPicker<T extends { id: number }> {
+  pick(tokens: T[]): T | null;
+}
+
+export class RoundRobinPicker<T extends { id: number }> implements TokenPicker<T> {
+  private cursor = 0;
+
+  pick(tokens: T[]): T | null {
+    if (tokens.length === 0) return null;
+    const picked = tokens[this.cursor % tokens.length]!;
+    this.cursor++;
+    return picked;
+  }
+}