@cartanova/qgrid-cli 2.9.1 → 2.9.4

package/bundle/dist/application/token/token.model.js

@@ -198,9 +198,8 @@ var TokenModelClass = class extends BaseModelClass {
 		}]);
 	}
 	/**
-	* 인증 사망을 한 번만 기록하고, 다른 활성 토큰이 있으면 라우팅에서도 제외한다.
-	* 마지막 활성 토큰은 systemic 장애 안전판 때문에 active 상태를 유지하되 재로그인
-	* 필요 상태는 기록한다. `marked`가 공유 DB 인스턴스들의 알림 발송 게이트다.
+	* Record confirmed expiry and remove the token from routing atomically.
+	* The last active token is also deactivated; its notification is urgent.
 	*/
 	async markReauthRequired(id, expectedCredentials) {
 		return this.getPuri("w").transaction(async (trx) => {
@@ -211,38 +210,44 @@ var TokenModelClass = class extends BaseModelClass {
 			}).where("id", id).forUpdate().first();
 			if (!token || token.reauth_required) return {
 				marked: false,
-				keptAsLastActive: false,
+				wasLastActive: false,
 				staleCredentials: false
 			};
 			if (!isDeepStrictEqual(token.credentials, expectedCredentials)) return {
 				marked: false,
-				keptAsLastActive: false,
+				wasLastActive: false,
 				staleCredentials: true
 			};
 			await trx.knex.raw("SELECT pg_advisory_xact_lock(?, hashtext(?))", [TOKEN_AUTH_DEATH_LOCK_CLASS_ID, token.provider]);
-			const marked = (await trx.knex.raw(`UPDATE tokens
+			const marked = (await trx.knex.raw(`WITH previous AS (
+           SELECT active AND NOT EXISTS (
+             SELECT 1 FROM tokens peer
+             WHERE peer.provider = tokens.provider AND peer.active
+               AND NOT peer.reauth_required AND peer.id <> tokens.id
+           ) AS was_last_active FROM tokens WHERE id = ?
+         )
+         UPDATE tokens
          SET reauth_required = true,
-             active = CASE
-               WHEN active AND (SELECT count(*) FROM tokens peer
-                 WHERE peer.provider = tokens.provider AND peer.active) > 1
-               THEN false
-               ELSE active
-             END
+             active = false
          WHERE id = ? AND reauth_required = false
-         RETURNING active`, [id])).rows[0];
+         RETURNING (SELECT was_last_active FROM previous) AS was_last_active`, [id, id])).rows[0];
 			if (!marked) return {
 				marked: false,
-				keptAsLastActive: false,
+				wasLastActive: false,
 				staleCredentials: false
 			};
-			if (marked.active) logger.error(`refusing to auto-deactivate token ${id}: last active provider token — systemic refresh failure suspected, keeping the pool non-empty`);
+			if (marked.was_last_active) logger.error(`deactivated expired token ${id}: no usable provider tokens remain`);
 			return {
 				marked: true,
-				keptAsLastActive: marked.active,
+				wasLastActive: marked.was_last_active,
 				staleCredentials: false
 			};
 		});
 	}
+	/** Repair rows retained by the former last-active exception before pool reconciliation. */
+	async deactivateExpiredTokens() {
+		await this.getPuri("w").table("tokens").where("reauth_required", true).where("active", true).update({ active: false });
+	}
 	async reorder(ids) {
 		await this.getPuri("w").transaction(async (trx) => {
 			for (let i = 0; i < ids.length; i++) await trx.table("tokens").where("id", ids[i]).update({ ord: i });
@@ -298,4 +303,4 @@ const TokenModel = new TokenModelClass();
 //#endregion
 export { TokenModel };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"token.model.js","names":[],"sources":["../../../src/application/token/token.model.ts"],"sourcesContent":["import { isDeepStrictEqual } from \"node:util\";\n\nimport { getLogger } from \"@logtape/logtape\";\nimport {\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 TokenSubsetKey, type TokenSubsetMapping } from \"../sonamu.generated\";\nimport { tokenLoaderQueries, tokenSubsetQueries } from \"../sonamu.generated.sso\";\nimport { type TokenCredentials, type TokenListParams, type TokenSaveParams } from \"./token.types\";\n\nconst logger = getLogger([\"qgrid\", \"token\"]);\n\nconst DEFAULT_QUOTA_THRESHOLD = 80;\nconst DEFAULT_WEIGHT = 1;\nconst TOKEN_AUTH_DEATH_LOCK_CLASS_ID = 719;\n\nexport type TokenUpdateFields = {\n  name?: string;\n  quota_threshold?: number | null;\n  weight?: number;\n  keepalive_enabled?: boolean;\n};\n\nfunction applyCreateDefaults(sp: TokenSaveParams): TokenSaveParams {\n  if (sp.id !== undefined) return sp;\n  return {\n    ...sp,\n    ...(sp.quota_threshold === undefined ? { quota_threshold: DEFAULT_QUOTA_THRESHOLD } : {}),\n    ...(sp.weight === undefined ? { weight: DEFAULT_WEIGHT } : {}),\n  };\n}\n\nclass TokenModelClass extends BaseModelClass<\n  TokenSubsetKey,\n  TokenSubsetMapping,\n  typeof tokenSubsetQueries,\n  typeof tokenLoaderQueries\n> {\n  constructor() {\n    super(\"Token\", tokenSubsetQueries, tokenLoaderQueries);\n  }\n\n  @api({ httpMethod: \"GET\", clients: [\"axios\", \"tanstack-query\"], resourceName: \"Token\" })\n  async findById<T extends TokenSubsetKey>(subset: T, id: number): Promise<TokenSubsetMapping[T]> {\n    const { rows } = await this.findMany(subset, { id, num: 1, page: 1 });\n    if (!rows[0]) {\n      throw new NotFoundException(SD(\"error.entityNotFound\")(\"Token\", id));\n    }\n    return rows[0];\n  }\n\n  async findOne<T extends TokenSubsetKey>(\n    subset: T,\n    listParams: TokenListParams,\n  ): Promise<TokenSubsetMapping[T] | null> {\n    const { rows } = await this.findMany(subset, { ...listParams, num: 1, page: 1 });\n    return rows[0] ?? null;\n  }\n\n  @api({ httpMethod: \"GET\", clients: [\"axios\", \"tanstack-query\"], resourceName: \"Tokens\" })\n  async findMany<T extends TokenSubsetKey, LP extends TokenListParams>(\n    subset: T,\n    rawParams?: LP,\n  ): Promise<ListResult<LP, TokenSubsetMapping[T]>> {\n    const params = {\n      num: 24,\n      page: 1,\n      search: \"id\" as const,\n      orderBy: \"ord-asc\" as const,\n      ...rawParams,\n    } satisfies TokenListParams;\n\n    const { qb, onSubset: _ } = this.getSubsetQueries(subset);\n\n    if (params.id) {\n      qb.whereIn(\"tokens.id\", asArray(params.id));\n    }\n\n    if (params.search && params.keyword && params.keyword.length > 0) {\n      if (params.search === \"id\") {\n        qb.where(\"tokens.id\", Number(params.keyword));\n      } else if (params.search === \"name\") {\n        qb.where(\"tokens.name\", \"like\", `%${params.keyword}%`);\n      } else {\n        throw new BadRequestException(SD(\"error.unknownSearchField\")(params.search));\n      }\n    }\n\n    if (params.orderBy) {\n      if (params.orderBy === \"id-desc\") {\n        qb.orderBy(\"tokens.id\", \"desc\");\n      } else if (params.orderBy === \"ord-asc\") {\n        qb.orderBy(\"tokens.ord\", \"asc\");\n        qb.orderBy(\"tokens.id\", \"asc\");\n      } else {\n        exhaustive(params.orderBy);\n      }\n    }\n\n    const enhancers = this.createEnhancers({\n      A: (row) => ({ ...row }),\n    });\n\n    return this.executeSubsetQuery({ subset, qb, params, enhancers, debug: false });\n  }\n\n  async findByAccountIdentifier<T extends TokenSubsetKey>(\n    subset: T,\n    provider: string,\n    accountId: string,\n  ): Promise<TokenSubsetMapping[T][]> {\n    const { qb } = this.getSubsetQueries(subset);\n    qb.where(\"tokens.provider\", provider);\n    const jsonKey = provider === \"anthropic\" ? \"accountUuid\" : \"accountId\";\n    qb.whereRaw(`tokens.credentials->>'${jsonKey}' = ?`, [accountId]);\n    const enhancers = this.createEnhancers({ A: (row) => ({ ...row }) });\n    const result = await this.executeSubsetQuery({\n      subset,\n      qb,\n      params: { num: 100, page: 1 },\n      enhancers,\n      debug: false,\n    });\n    return result.rows;\n  }\n\n  async findActiveByProvider<T extends TokenSubsetKey>(\n    subset: T,\n    provider: string,\n  ): Promise<TokenSubsetMapping[T][]> {\n    const { qb } = this.getSubsetQueries(subset);\n    qb.where(\"tokens.active\", true);\n    qb.where(\"tokens.provider\", provider);\n    const enhancers = this.createEnhancers({ A: (row) => ({ ...row }) });\n    const result = await this.executeSubsetQuery({\n      subset,\n      qb,\n      params: { num: 100, page: 1 },\n      enhancers,\n      debug: false,\n    });\n    return result.rows;\n  }\n\n  async findActiveByProviderAndName<T extends TokenSubsetKey>(\n    subset: T,\n    provider: string,\n    name: string,\n  ): Promise<TokenSubsetMapping[T] | undefined> {\n    const { qb } = this.getSubsetQueries(subset);\n    qb.where(\"tokens.active\", true);\n    qb.where(\"tokens.provider\", provider);\n    qb.where(\"tokens.name\", name);\n    const enhancers = this.createEnhancers({ A: (row) => ({ ...row }) });\n    const result = await this.executeSubsetQuery({\n      subset,\n      qb,\n      params: { num: 1, page: 1 },\n      enhancers,\n      debug: false,\n    });\n    return result.rows[0];\n  }\n\n  /** 실제 인증 만료가 확인돼 재로그인이 필요한 토큰들. 수동 비활성화는 제외한다. */\n  async findReauthRequired<T extends TokenSubsetKey>(subset: T): Promise<TokenSubsetMapping[T][]> {\n    const { qb } = this.getSubsetQueries(subset);\n    qb.where(\"tokens.reauth_required\", true);\n    qb.orderBy(\"tokens.name\", \"asc\");\n    const enhancers = this.createEnhancers({ A: (row) => ({ ...row }) });\n    const result = await this.executeSubsetQuery({\n      subset,\n      qb,\n      params: { num: 100, page: 1 },\n      enhancers,\n      debug: false,\n    });\n    return result.rows;\n  }\n\n  async findActive<T extends TokenSubsetKey>(subset: T): Promise<TokenSubsetMapping[T][]> {\n    const { qb } = this.getSubsetQueries(subset);\n    qb.where(\"tokens.active\", true);\n    const enhancers = this.createEnhancers({ A: (row) => ({ ...row }) });\n    const result = await this.executeSubsetQuery({\n      subset,\n      qb,\n      params: { num: 100, page: 1 },\n      enhancers,\n      debug: false,\n    });\n    return result.rows;\n  }\n\n  async save(spa: TokenSaveParams[]): Promise<number[]> {\n    const wdb = this.getPuri(\"w\");\n    spa.forEach((sp) => {\n      wdb.ubRegister(\"tokens\", applyCreateDefaults(sp));\n    });\n    return wdb.transaction(async (trx) => {\n      return trx.ubUpsert(\"tokens\");\n    });\n  }\n\n  async updateFields(id: number, fields: TokenUpdateFields): Promise<number> {\n    const wdb = this.getPuri(\"w\");\n    return wdb.transaction((trx) => trx.table(\"tokens\").where(\"id\", id).update(fields));\n  }\n\n  async toggleActive(id: number): Promise<{ active: boolean; reauthRequired: boolean } | null> {\n    const wdb = this.getPuri(\"w\");\n    return wdb.transaction(async (trx) => {\n      const token = await trx\n        .from(\"tokens\")\n        .select({ active: \"active\", reauth_required: \"reauth_required\" })\n        .where(\"id\", id)\n        .forUpdate()\n        .first();\n      if (!token) return null;\n      if (!token.active && token.reauth_required) {\n        return { active: false, reauthRequired: true };\n      }\n\n      const active = !token.active;\n      await trx.from(\"tokens\").where(\"id\", id).update({ active });\n      return { active, reauthRequired: false };\n    });\n  }\n\n  /**\n   * 같은 계정의 기존 토큰을 지우고 새로 저장한다(로그인·재로그인 공통 경로).\n   *\n   * provider 응답에 계정 식별자가 없으면 dedup 자체가 불가능하므로 경고만 남기고\n   * 중복 제거 없이 저장한다(죽은 row 가 남는다).\n   */\n  async replaceByAccount(\n    provider: string,\n    accountId: string | undefined,\n    saveParams: TokenSaveParams,\n  ): Promise<void> {\n    let keepaliveEnabled = saveParams.keepalive_enabled;\n    if (accountId) {\n      const oldEntries = await this.findByAccountIdentifier(\"A\", provider, accountId);\n      if (keepaliveEnabled === undefined && oldEntries.length > 0) {\n        keepaliveEnabled = oldEntries.some((entry) => entry.keepalive_enabled);\n      }\n      if (oldEntries.length > 0) await this.del(oldEntries.map((o) => o.id));\n    } else {\n      logger.warn(\n        `${provider} login without account identifier: dedup skipped for ${saveParams.name ?? \"unnamed\"}`,\n      );\n    }\n\n    await this.save([\n      keepaliveEnabled === undefined\n        ? saveParams\n        : { ...saveParams, keepalive_enabled: keepaliveEnabled },\n    ]);\n  }\n\n  /**\n   * 인증 사망을 한 번만 기록하고, 다른 활성 토큰이 있으면 라우팅에서도 제외한다.\n   * 마지막 활성 토큰은 systemic 장애 안전판 때문에 active 상태를 유지하되 재로그인\n   * 필요 상태는 기록한다. `marked`가 공유 DB 인스턴스들의 알림 발송 게이트다.\n   */\n  async markReauthRequired(\n    id: number,\n    expectedCredentials: TokenCredentials,\n  ): Promise<{ marked: boolean; keptAsLastActive: boolean; staleCredentials: boolean }> {\n    const wdb = this.getPuri(\"w\");\n    return wdb.transaction(async (trx) => {\n      const token = await trx\n        .from(\"tokens\")\n        .select({\n          provider: \"provider\",\n          credentials: \"credentials\",\n          reauth_required: \"reauth_required\",\n        })\n        .where(\"id\", id)\n        .forUpdate()\n        .first();\n      if (!token || token.reauth_required) {\n        return { marked: false, keptAsLastActive: false, staleCredentials: false };\n      }\n      if (!isDeepStrictEqual(token.credentials, expectedCredentials)) {\n        return { marked: false, keptAsLastActive: false, staleCredentials: true };\n      }\n\n      await trx.knex.raw(\"SELECT pg_advisory_xact_lock(?, hashtext(?))\", [\n        TOKEN_AUTH_DEATH_LOCK_CLASS_ID,\n        token.provider,\n      ]);\n      const updated = await trx.knex.raw<{ rows: { active: boolean }[] }>(\n        `UPDATE tokens\n         SET reauth_required = true,\n             active = CASE\n               WHEN active AND (SELECT count(*) FROM tokens peer\n                 WHERE peer.provider = tokens.provider AND peer.active) > 1\n               THEN false\n               ELSE active\n             END\n         WHERE id = ? AND reauth_required = false\n         RETURNING active`,\n        [id],\n      );\n      const marked = updated.rows[0];\n      if (!marked) return { marked: false, keptAsLastActive: false, staleCredentials: false };\n\n      if (marked.active) {\n        logger.error(\n          `refusing to auto-deactivate token ${id}: last active provider token — ` +\n            `systemic refresh failure suspected, keeping the pool non-empty`,\n        );\n      }\n      return { marked: true, keptAsLastActive: marked.active, staleCredentials: false };\n    });\n  }\n\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async reorder(ids: number[]): Promise<{ done: boolean }> {\n    const wdb = this.getPuri(\"w\");\n    await wdb.transaction(async (trx) => {\n      for (let i = 0; i < ids.length; i++) {\n        await trx.table(\"tokens\").where(\"id\", ids[i]!).update({ ord: i });\n      }\n    });\n    return { done: true };\n  }\n\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async del(ids: number[]): Promise<number> {\n    const wdb = this.getPuri(\"w\");\n    await wdb.transaction(async (trx) => {\n      return trx.table(\"tokens\").whereIn(\"tokens.id\", ids).delete();\n    });\n    return ids.length;\n  }\n}\n\nexport const TokenModel = new TokenModelClass();\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"token.model.js","names":[],"sources":["../../../src/application/token/token.model.ts"],"sourcesContent":["import { isDeepStrictEqual } from \"node:util\";\n\nimport { getLogger } from \"@logtape/logtape\";\nimport {\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 TokenSubsetKey, type TokenSubsetMapping } from \"../sonamu.generated\";\nimport { tokenLoaderQueries, tokenSubsetQueries } from \"../sonamu.generated.sso\";\nimport { type TokenCredentials, type TokenListParams, type TokenSaveParams } from \"./token.types\";\n\nconst logger = getLogger([\"qgrid\", \"token\"]);\n\nconst DEFAULT_QUOTA_THRESHOLD = 80;\nconst DEFAULT_WEIGHT = 1;\nconst TOKEN_AUTH_DEATH_LOCK_CLASS_ID = 719;\n\nexport type TokenUpdateFields = {\n  name?: string;\n  quota_threshold?: number | null;\n  weight?: number;\n  keepalive_enabled?: boolean;\n};\n\nfunction applyCreateDefaults(sp: TokenSaveParams): TokenSaveParams {\n  if (sp.id !== undefined) return sp;\n  return {\n    ...sp,\n    ...(sp.quota_threshold === undefined ? { quota_threshold: DEFAULT_QUOTA_THRESHOLD } : {}),\n    ...(sp.weight === undefined ? { weight: DEFAULT_WEIGHT } : {}),\n  };\n}\n\nclass TokenModelClass extends BaseModelClass<\n  TokenSubsetKey,\n  TokenSubsetMapping,\n  typeof tokenSubsetQueries,\n  typeof tokenLoaderQueries\n> {\n  constructor() {\n    super(\"Token\", tokenSubsetQueries, tokenLoaderQueries);\n  }\n\n  @api({ httpMethod: \"GET\", clients: [\"axios\", \"tanstack-query\"], resourceName: \"Token\" })\n  async findById<T extends TokenSubsetKey>(subset: T, id: number): Promise<TokenSubsetMapping[T]> {\n    const { rows } = await this.findMany(subset, { id, num: 1, page: 1 });\n    if (!rows[0]) {\n      throw new NotFoundException(SD(\"error.entityNotFound\")(\"Token\", id));\n    }\n    return rows[0];\n  }\n\n  async findOne<T extends TokenSubsetKey>(\n    subset: T,\n    listParams: TokenListParams,\n  ): Promise<TokenSubsetMapping[T] | null> {\n    const { rows } = await this.findMany(subset, { ...listParams, num: 1, page: 1 });\n    return rows[0] ?? null;\n  }\n\n  @api({ httpMethod: \"GET\", clients: [\"axios\", \"tanstack-query\"], resourceName: \"Tokens\" })\n  async findMany<T extends TokenSubsetKey, LP extends TokenListParams>(\n    subset: T,\n    rawParams?: LP,\n  ): Promise<ListResult<LP, TokenSubsetMapping[T]>> {\n    const params = {\n      num: 24,\n      page: 1,\n      search: \"id\" as const,\n      orderBy: \"ord-asc\" as const,\n      ...rawParams,\n    } satisfies TokenListParams;\n\n    const { qb, onSubset: _ } = this.getSubsetQueries(subset);\n\n    if (params.id) {\n      qb.whereIn(\"tokens.id\", asArray(params.id));\n    }\n\n    if (params.search && params.keyword && params.keyword.length > 0) {\n      if (params.search === \"id\") {\n        qb.where(\"tokens.id\", Number(params.keyword));\n      } else if (params.search === \"name\") {\n        qb.where(\"tokens.name\", \"like\", `%${params.keyword}%`);\n      } else {\n        throw new BadRequestException(SD(\"error.unknownSearchField\")(params.search));\n      }\n    }\n\n    if (params.orderBy) {\n      if (params.orderBy === \"id-desc\") {\n        qb.orderBy(\"tokens.id\", \"desc\");\n      } else if (params.orderBy === \"ord-asc\") {\n        qb.orderBy(\"tokens.ord\", \"asc\");\n        qb.orderBy(\"tokens.id\", \"asc\");\n      } else {\n        exhaustive(params.orderBy);\n      }\n    }\n\n    const enhancers = this.createEnhancers({\n      A: (row) => ({ ...row }),\n    });\n\n    return this.executeSubsetQuery({ subset, qb, params, enhancers, debug: false });\n  }\n\n  async findByAccountIdentifier<T extends TokenSubsetKey>(\n    subset: T,\n    provider: string,\n    accountId: string,\n  ): Promise<TokenSubsetMapping[T][]> {\n    const { qb } = this.getSubsetQueries(subset);\n    qb.where(\"tokens.provider\", provider);\n    const jsonKey = provider === \"anthropic\" ? \"accountUuid\" : \"accountId\";\n    qb.whereRaw(`tokens.credentials->>'${jsonKey}' = ?`, [accountId]);\n    const enhancers = this.createEnhancers({ A: (row) => ({ ...row }) });\n    const result = await this.executeSubsetQuery({\n      subset,\n      qb,\n      params: { num: 100, page: 1 },\n      enhancers,\n      debug: false,\n    });\n    return result.rows;\n  }\n\n  async findActiveByProvider<T extends TokenSubsetKey>(\n    subset: T,\n    provider: string,\n  ): Promise<TokenSubsetMapping[T][]> {\n    const { qb } = this.getSubsetQueries(subset);\n    qb.where(\"tokens.active\", true);\n    qb.where(\"tokens.provider\", provider);\n    const enhancers = this.createEnhancers({ A: (row) => ({ ...row }) });\n    const result = await this.executeSubsetQuery({\n      subset,\n      qb,\n      params: { num: 100, page: 1 },\n      enhancers,\n      debug: false,\n    });\n    return result.rows;\n  }\n\n  async findActiveByProviderAndName<T extends TokenSubsetKey>(\n    subset: T,\n    provider: string,\n    name: string,\n  ): Promise<TokenSubsetMapping[T] | undefined> {\n    const { qb } = this.getSubsetQueries(subset);\n    qb.where(\"tokens.active\", true);\n    qb.where(\"tokens.provider\", provider);\n    qb.where(\"tokens.name\", name);\n    const enhancers = this.createEnhancers({ A: (row) => ({ ...row }) });\n    const result = await this.executeSubsetQuery({\n      subset,\n      qb,\n      params: { num: 1, page: 1 },\n      enhancers,\n      debug: false,\n    });\n    return result.rows[0];\n  }\n\n  /** 실제 인증 만료가 확인돼 재로그인이 필요한 토큰들. 수동 비활성화는 제외한다. */\n  async findReauthRequired<T extends TokenSubsetKey>(subset: T): Promise<TokenSubsetMapping[T][]> {\n    const { qb } = this.getSubsetQueries(subset);\n    qb.where(\"tokens.reauth_required\", true);\n    qb.orderBy(\"tokens.name\", \"asc\");\n    const enhancers = this.createEnhancers({ A: (row) => ({ ...row }) });\n    const result = await this.executeSubsetQuery({\n      subset,\n      qb,\n      params: { num: 100, page: 1 },\n      enhancers,\n      debug: false,\n    });\n    return result.rows;\n  }\n\n  async findActive<T extends TokenSubsetKey>(subset: T): Promise<TokenSubsetMapping[T][]> {\n    const { qb } = this.getSubsetQueries(subset);\n    qb.where(\"tokens.active\", true);\n    const enhancers = this.createEnhancers({ A: (row) => ({ ...row }) });\n    const result = await this.executeSubsetQuery({\n      subset,\n      qb,\n      params: { num: 100, page: 1 },\n      enhancers,\n      debug: false,\n    });\n    return result.rows;\n  }\n\n  async save(spa: TokenSaveParams[]): Promise<number[]> {\n    const wdb = this.getPuri(\"w\");\n    spa.forEach((sp) => {\n      wdb.ubRegister(\"tokens\", applyCreateDefaults(sp));\n    });\n    return wdb.transaction(async (trx) => {\n      return trx.ubUpsert(\"tokens\");\n    });\n  }\n\n  async updateFields(id: number, fields: TokenUpdateFields): Promise<number> {\n    const wdb = this.getPuri(\"w\");\n    return wdb.transaction((trx) => trx.table(\"tokens\").where(\"id\", id).update(fields));\n  }\n\n  async toggleActive(id: number): Promise<{ active: boolean; reauthRequired: boolean } | null> {\n    const wdb = this.getPuri(\"w\");\n    return wdb.transaction(async (trx) => {\n      const token = await trx\n        .from(\"tokens\")\n        .select({ active: \"active\", reauth_required: \"reauth_required\" })\n        .where(\"id\", id)\n        .forUpdate()\n        .first();\n      if (!token) return null;\n      if (!token.active && token.reauth_required) {\n        return { active: false, reauthRequired: true };\n      }\n\n      const active = !token.active;\n      await trx.from(\"tokens\").where(\"id\", id).update({ active });\n      return { active, reauthRequired: false };\n    });\n  }\n\n  /**\n   * 같은 계정의 기존 토큰을 지우고 새로 저장한다(로그인·재로그인 공통 경로).\n   *\n   * provider 응답에 계정 식별자가 없으면 dedup 자체가 불가능하므로 경고만 남기고\n   * 중복 제거 없이 저장한다(죽은 row 가 남는다).\n   */\n  async replaceByAccount(\n    provider: string,\n    accountId: string | undefined,\n    saveParams: TokenSaveParams,\n  ): Promise<void> {\n    let keepaliveEnabled = saveParams.keepalive_enabled;\n    if (accountId) {\n      const oldEntries = await this.findByAccountIdentifier(\"A\", provider, accountId);\n      if (keepaliveEnabled === undefined && oldEntries.length > 0) {\n        keepaliveEnabled = oldEntries.some((entry) => entry.keepalive_enabled);\n      }\n      if (oldEntries.length > 0) await this.del(oldEntries.map((o) => o.id));\n    } else {\n      logger.warn(\n        `${provider} login without account identifier: dedup skipped for ${saveParams.name ?? \"unnamed\"}`,\n      );\n    }\n\n    await this.save([\n      keepaliveEnabled === undefined\n        ? saveParams\n        : { ...saveParams, keepalive_enabled: keepaliveEnabled },\n    ]);\n  }\n\n  /**\n   * Record confirmed expiry and remove the token from routing atomically.\n   * The last active token is also deactivated; its notification is urgent.\n   */\n  async markReauthRequired(\n    id: number,\n    expectedCredentials: TokenCredentials,\n  ): Promise<{ marked: boolean; wasLastActive: boolean; staleCredentials: boolean }> {\n    const wdb = this.getPuri(\"w\");\n    return wdb.transaction(async (trx) => {\n      const token = await trx\n        .from(\"tokens\")\n        .select({\n          provider: \"provider\",\n          credentials: \"credentials\",\n          reauth_required: \"reauth_required\",\n        })\n        .where(\"id\", id)\n        .forUpdate()\n        .first();\n      if (!token || token.reauth_required) {\n        return { marked: false, wasLastActive: false, staleCredentials: false };\n      }\n      if (!isDeepStrictEqual(token.credentials, expectedCredentials)) {\n        return { marked: false, wasLastActive: false, staleCredentials: true };\n      }\n\n      await trx.knex.raw(\"SELECT pg_advisory_xact_lock(?, hashtext(?))\", [\n        TOKEN_AUTH_DEATH_LOCK_CLASS_ID,\n        token.provider,\n      ]);\n      const updated = await trx.knex.raw<{ rows: { was_last_active: boolean }[] }>(\n        `WITH previous AS (\n           SELECT active AND NOT EXISTS (\n             SELECT 1 FROM tokens peer\n             WHERE peer.provider = tokens.provider AND peer.active\n               AND NOT peer.reauth_required AND peer.id <> tokens.id\n           ) AS was_last_active FROM tokens WHERE id = ?\n         )\n         UPDATE tokens\n         SET reauth_required = true,\n             active = false\n         WHERE id = ? AND reauth_required = false\n         RETURNING (SELECT was_last_active FROM previous) AS was_last_active`,\n        [id, id],\n      );\n      const marked = updated.rows[0];\n      if (!marked) return { marked: false, wasLastActive: false, staleCredentials: false };\n\n      if (marked.was_last_active) {\n        logger.error(`deactivated expired token ${id}: no usable provider tokens remain`);\n      }\n      return { marked: true, wasLastActive: marked.was_last_active, staleCredentials: false };\n    });\n  }\n\n  /** Repair rows retained by the former last-active exception before pool reconciliation. */\n  async deactivateExpiredTokens(): Promise<void> {\n    await this.getPuri(\"w\")\n      .table(\"tokens\")\n      .where(\"reauth_required\", true)\n      .where(\"active\", true)\n      .update({ active: false });\n  }\n\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async reorder(ids: number[]): Promise<{ done: boolean }> {\n    const wdb = this.getPuri(\"w\");\n    await wdb.transaction(async (trx) => {\n      for (let i = 0; i < ids.length; i++) {\n        await trx.table(\"tokens\").where(\"id\", ids[i]!).update({ ord: i });\n      }\n    });\n    return { done: true };\n  }\n\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async del(ids: number[]): Promise<number> {\n    const wdb = this.getPuri(\"w\");\n    await wdb.transaction(async (trx) => {\n      return trx.table(\"tokens\").whereIn(\"tokens.id\", ids).delete();\n    });\n    return ids.length;\n  }\n}\n\nexport const TokenModel = new TokenModelClass();\n"],"mappings":"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"}

package/bundle/dist/startup-migrations.js

@@ -22,7 +22,7 @@ const MIGRATION_FILE_RE = /^\d{14}_.+\.ts$/;
 function createStartupMigrationSource(dirs) {
 	return {
 		async getMigrations() {
-			return (await readdir(dirs.sourceDir)).filter((name) => MIGRATION_FILE_RE.test(name) && !name.endsWith(".d.ts")).sort();
+			return (await readdir(dirs.sourceDir)).filter((name) => MIGRATION_FILE_RE.test(name) && !name.endsWith(".d.ts")).toSorted();
 		},
 		getMigrationName(name) {
 			return name;
@@ -40,17 +40,20 @@ function createStartupMigrationSource(dirs) {
 		}
 	};
 }
-async function runRequiredMigrations(dirs = resolveStartupMigrationDirs()) {
+async function runRequiredMigrations(dirs = resolveStartupMigrationDirs(), deps = {
+	getKnex: () => TokenModel.getDB("w"),
+	exit: process.exit
+}) {
 	const log = getLogger(["qgrid", "startup"]);
 	try {
-		const [batch, migrations] = await TokenModel.getDB("w").migrate.latest({ migrationSource: createStartupMigrationSource(dirs) });
+		const [batch, migrations] = await deps.getKnex().migrate.latest({ migrationSource: createStartupMigrationSource(dirs) });
 		if (migrations.length > 0) log.info(`migration: ${migrations.length} applied (batch ${batch})`);
 	} catch (error) {
 		log.error(`migration failed: ${error.message}`);
-		process.exit(1);
+		deps.exit(1);
 	}
 }
 //#endregion
 export { createStartupMigrationSource, resolveStartupMigrationDirs, runRequiredMigrations };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/bundle/dist/utils/providers/anthropic/claude-session.js

@@ -1,5 +1,6 @@
 import { ARGV_SAFE_MAX_UTF8_BYTES, assertAnthropicSchemaArgvSize } from "../common/schema-validation.js";
 import { ANTHROPIC_CLAUDE_CWD, ANTHROPIC_DISALLOWED_TOOLS, anthropicConfigDir, assertSupportedOneMillionSuffix, canonicalAnthropicModel, needsCli1mSuffix, supports1MContext, usesAdaptiveThinking } from "./anthropic-constants.js";
+import { resolveAnthropicEffort } from "../common/effort.js";
 import { createTtftTracker } from "../common/ttft.js";
 import { buildStreamJsonInput, handleStreamJsonLine } from "./stream-json-adapter.js";
 import { randomUUID } from "node:crypto";
@@ -110,7 +111,7 @@ function buildClaudeArgs(opts) {
 		...systemArgs,
 		...usesAdaptiveThinking(opts.model) ? [] : ["--thinking", "disabled"],
 		"--effort",
-		opts.effort ?? "low",
+		resolveAnthropicEffort(opts.effort) ?? "low",
 		"--disable-slash-commands",
 		"--session-id",
 		opts.sessionId
@@ -272,4 +273,4 @@ function runClaudeSession(req, onDelta) {
 //#endregion
 export { SYSTEM_PROMPT_ARGV_MAX_BYTES, applyOneMillionSuffix, buildClaudeArgs, decorateAndSerialize, ensureConfigDir, makeAnthropicWorkerId, oneMillionEnv, runClaudeSession, shouldPinStructuredRetries, structuredOutputRetriesEnv, thinkingEnv, withSessionLock };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"claude-session.js","names":[],"sources":["../../../../src/utils/providers/anthropic/claude-session.ts"],"sourcesContent":["/**\n * claude-session — Claude CLI 세션 spawn + QgridThreadCoord 매핑 + per-session 락.\n *\n * 멀티턴: 매 호출 fresh `--session-id <uuid>`로 실행한다. 입력은 어댑터가 만든 JSONL 을\n * stdin 으로 흘리고(`--input-format stream-json`), 출력은 파서로 처리한다.\n *\n * 핵심 계약:\n *  - coord 는 임의 저장이 아니라 기존 QgridThreadCoord{workerId,threadId,epoch,systemHash} 에\n *    매핑한다. threadId=세션 uuid, epoch=0 고정(worker restart 개념 없음), workerId=token 기반\n *    안정 합성, systemHash=요청 system 해시. issueConvContext/decideConvRouting 과 round-trip.\n *  - withSessionLock 은 exported primitive 로 유지한다. 기본 경로에서는 매 호출 새 session-id 라\n *    사실상 no-contention 이지만, 직접 호출자/테스트의 직렬화 보장은 보존한다.\n *  - stream-json 직렬화 시 SDK envelope(uuid/session_id/parent_tool_use_id) decorate.\n *  - structured output 일 때 출력 파서에 { structuredOutput: true } 전달(없으면 streamObject 깨짐).\n */\n\nimport { spawn } from \"node:child_process\";\nimport { randomUUID } from \"node:crypto\";\nimport { mkdirSync, unlinkSync, writeFileSync } from \"node:fs\";\n\nimport { type JsonValue, type TokenUsageBreakdown, type UserInput } from \"../common/provider-types\";\nimport {\n  ARGV_SAFE_MAX_UTF8_BYTES,\n  assertAnthropicSchemaArgvSize,\n} from \"../common/schema-validation\";\nimport { createTtftTracker } from \"../common/ttft\";\nimport {\n  ANTHROPIC_CLAUDE_CWD,\n  anthropicConfigDir,\n  ANTHROPIC_DEFAULT_EFFORT,\n  ANTHROPIC_DISALLOWED_TOOLS,\n  assertSupportedOneMillionSuffix,\n  canonicalAnthropicModel,\n  needsCli1mSuffix,\n  supports1MContext,\n  usesAdaptiveThinking,\n} from \"./anthropic-constants\";\nimport {\n  buildStreamJsonInput,\n  type ClaudeStreamJsonState,\n  type ClaudeStreamJsonLine,\n  type ClaudeStreamResult,\n  handleStreamJsonLine,\n} from \"./stream-json-adapter\";\n\n// ── per-session 락 ─────────────────────────────────────────────────\n\n// session-id 단위 직렬화 primitive. 기본 경로에서는 매 호출 새 uuid 라 사실상 no-op 이지만,\n// 같은 session-id 를 직접 쓰는 호출자는 여전히 직렬화 보장을 받는다.\nconst sessionChains = new Map<string, Promise<unknown>>();\n\nexport async function withSessionLock<T>(sessionId: string, fn: () => Promise<T>): Promise<T> {\n  const prev = sessionChains.get(sessionId) ?? Promise.resolve();\n  // 이전 turn 의 성패와 무관하게 직렬 체인을 잇는다.\n  const next = prev.then(fn, fn);\n  // tail: 성패 무관 settle 되는 핸들. 이걸 맵에 두고, finally 에서 \"여전히 내가 끝\"일 때만 삭제.\n  // (set 직후 undefined 검사로 하면 절대 삭제 안 돼 세션 id 가 누수됨 — tail 일치 검사로 회피.)\n  const tail = next.then(\n    () => {},\n    () => {},\n  );\n  sessionChains.set(sessionId, tail);\n  try {\n    return await next;\n  } finally {\n    // 그 사이 다른 turn 이 체인을 이어받았으면 tail 이 교체돼 있다 — 그때는 삭제하지 않는다.\n    if (sessionChains.get(sessionId) === tail) sessionChains.delete(sessionId);\n  }\n}\n\n// ── coord 매핑 ──────────────────────────────────────────────────────\n\n// token 기반 안정 workerId 합성. Anthropic 은 worker pool 이 없으므로 tokenId 를 그대로 쓴다.\nexport function makeAnthropicWorkerId(tokenId: number): number {\n  return tokenId;\n}\n\n// ── envelope decorate ──────────────────────────────────────────────\n\n// stream-json 입력 라인에 SDK envelope 부착 후 직렬화. session 소유자인 여기서 한다.\nexport function decorateAndSerialize(\n  lines: Array<ClaudeStreamJsonLine>,\n  sessionId: string,\n): string {\n  return (\n    lines\n      .map((line) =>\n        JSON.stringify({\n          ...line,\n          session_id: sessionId,\n          uuid: randomUUID(),\n          parent_tool_use_id: null,\n        }),\n      )\n      .join(\"\\n\") + \"\\n\"\n  );\n}\n\n// ── spawn + consume ────────────────────────────────────────────────\n\nexport interface ClaudeSessionRequest {\n  tokenId: number;\n  token: string; // OAuth access token\n  model: string;\n  system?: string;\n  jsonSchema?: string; // 있으면 structured output\n  effort?: string;\n  timeoutMs: number;\n  coldHistory?: Array<JsonValue>;\n  input: Array<UserInput>;\n  abortSignal?: AbortSignal;\n  includePartialMessages?: boolean;\n}\n\nexport interface ClaudeSessionResult extends ClaudeStreamResult {\n  sessionId: string;\n  workerId: number;\n  ttftMs: number | null;\n}\n\n// per-token CLAUDE_CONFIG_DIR 보장(격리). 경로 규칙은 anthropicConfigDir(순수 함수)이 소유 —\n// 여기선 그 경로에 빈 settings 를 깔아 claude-mem hook 등을 차단한다. (R10 격리)\n// 이 seed 파일은 claude-mem hook / 사용자 설정 오염 차단을 위한 격리 경계다. 매 호출마다 다시 써서\n// 외부 변조·삭제 후에도 다음 실행에서 self-healing 되도록 기존 semantics 를 유지한다.\nexport function ensureConfigDir(tokenId: number): string {\n  const dir = anthropicConfigDir(tokenId);\n  mkdirSync(dir, { recursive: true });\n  writeFileSync(`${dir}/.claude.json`, \"{}\");\n  writeFileSync(`${dir}/settings.json`, \"{}\");\n  return dir;\n}\n\nlet cwdEnsured = false;\nfunction ensureCwd(): void {\n  if (cwdEnsured) return;\n  mkdirSync(`${ANTHROPIC_CLAUDE_CWD}/.claude`, { recursive: true });\n  writeFileSync(`${ANTHROPIC_CLAUDE_CWD}/.claude/settings.json`, \"{}\");\n  cwdEnsured = true;\n}\n\n// spawn args 구성. 멀티턴/격리/structured 모드 반영.\nexport function applyOneMillionSuffix(model: string, needsSuffix: boolean): string {\n  const base = canonicalAnthropicModel(model);\n  return needsSuffix ? `${base}[1m]` : base;\n}\n\nexport function oneMillionEnv(supported: boolean): { CLAUDE_CODE_DISABLE_1M_CONTEXT?: \"1\" } {\n  return supported ? {} : { CLAUDE_CODE_DISABLE_1M_CONTEXT: \"1\" };\n}\n\nexport function thinkingEnv(model: string): {\n  CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING?: \"1\";\n  MAX_THINKING_TOKENS?: \"0\";\n} {\n  return usesAdaptiveThinking(model)\n    ? {}\n    : {\n        CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING: \"1\",\n        MAX_THINKING_TOKENS: \"0\",\n      };\n}\n\n// SON-495: structured output retry 를 1 로 고정한다. CC 가 attempt 를 reject 하고 retry 하면\n// `{rejected}{accepted}` 누적이 AI-SDK 의 JSON.parse 를 깨뜨리므로, retry 자체를 막아 그 경로를\n// 원천 차단한다. `0` 은 CC query loop(`callsThisQuery >= maxRetries`)가 첫 attempt emit 전에\n// 실패시키므로(`error_max_structured_output_retries`) 외부 값이 1 미만이어도 1 로 클램프한다.\nexport function structuredOutputRetriesEnv(raw = process.env.MAX_STRUCTURED_OUTPUT_RETRIES): {\n  MAX_STRUCTURED_OUTPUT_RETRIES: string;\n} {\n  if (!raw) return { MAX_STRUCTURED_OUTPUT_RETRIES: \"1\" };\n  const parsed = Number.parseInt(raw, 10);\n  if (!Number.isFinite(parsed)) return { MAX_STRUCTURED_OUTPUT_RETRIES: \"1\" };\n  return { MAX_STRUCTURED_OUTPUT_RETRIES: String(Math.max(parsed, 1)) };\n}\n\n// SON-495 의 retry 고정은 \"스트리밍 + structured\" 조합 한정 정책이다. 스트림에서 retry 가 돌면\n// wall-clock 이 2배가 되어 실용성이 없기 때문이다(원 결정 사유). 논스트림 generate 는 애초에 완료를\n// 기다리므로 그 사유가 성립하지 않는다. 반면 Claude 계열은 OpenAI 대비 structured output 준수율이\n// 낮아, 논스트림까지 retry=1 로 묶으면 1회 reject 가 곧바로\n// `error_max_structured_output_retries` 로 직결된다(실측: deti_production opus-4-8 실패율 39.6%).\n// 스트리밍 여부는 `--include-partial-messages` 를 붙이는 generateStream 경로에서만 true 가 되므로\n// (anthropic-dispatcher 의 generate/generateStream 분기) 이를 실질 구분자로 쓴다.\n// 비성공 subtype 을 항상 isError 로 올리는 SON-495 의 나머지 절반은 그대로 유지된다 — retry 후에도\n// degenerate 출력이면 조용히 통과시키지 않고 정직하게 실패한다.\nexport function shouldPinStructuredRetries(opts: {\n  useStructured: boolean;\n  includePartialMessages?: boolean;\n}): boolean {\n  return opts.useStructured && opts.includePartialMessages === true;\n}\n\n// Linux 단일 argv 인자 한계(MAX_ARG_STRLEN = PAGE_SIZE×32 = 128KB, 커널 하드코딩 상수)\n// 시스템 프롬프트가 이를 넘으면 execve 가 E2BIG 로 거부된다. deti 등 대형 프롬프트는 실측\n// 평균 343KB·최대 485KB(opus-4-8)라 일상적으로 초과한다. 한계의 절반(64KB)을 임계값으로 잡아\n// UTF-8 멀티바이트·예측 못 한 여유분까지 안전 마진을 둔다.\nexport const SYSTEM_PROMPT_ARGV_MAX_BYTES = ARGV_SAFE_MAX_UTF8_BYTES;\n\nexport function buildClaudeArgs(opts: {\n  model: string;\n  // 시스템 프롬프트 전달은 크기로 분기한다(호출부가 결정):\n  //  - 작으면 system(inline) → --system-prompt <text> (파일 I/O 없음, 기존 경로)\n  //  - 크면 systemPromptFile(경로) → --system-prompt-file <path> (argv 한계 회피)\n  // --system-prompt-file 은 --system-prompt 와 동일하게 default 를 replace 한다(append 아님 —\n  // R7 격리 보존, 실측 확인). 둘 다 없으면 빈 --system-prompt(default 23k 주입 방지).\n  system?: string;\n  systemPromptFile?: string;\n  effort?: string;\n  jsonSchema?: string;\n  sessionId: string;\n  needsOneMillionSuffix?: boolean;\n  includePartialMessages?: boolean;\n}): Array<string> {\n  const useStructured = Boolean(opts.jsonSchema && opts.jsonSchema.length > 0);\n  if (useStructured) assertAnthropicSchemaArgvSize(opts.jsonSchema!);\n  // --tools \"\" 로 전체 차단, structured(jsonSchema 있음) 면 StructuredOutput 만 허용.\n  const toolArgs = useStructured\n    ? [\"--tools\", \"\", \"--allowed-tools\", \"StructuredOutput\"]\n    : [\"--tools\", \"\"];\n\n  // 시스템 프롬프트: 파일 경로가 오면 --system-prompt-file, 아니면 inline --system-prompt.\n  // (호출부가 크기로 분기해 둘 중 하나만 채운다. 둘 다 없으면 빈 --system-prompt.)\n  const systemArgs = opts.systemPromptFile\n    ? [\"--system-prompt-file\", opts.systemPromptFile]\n    : [\"--system-prompt\", opts.system ?? \"\"];\n\n  const args: Array<string> = [\n    \"-p\",\n    ...toolArgs,\n    \"--disallowedTools\",\n    ...ANTHROPIC_DISALLOWED_TOOLS,\n    \"--input-format\",\n    \"stream-json\",\n    \"--output-format\",\n    \"stream-json\",\n    \"--verbose\",\n    ...(opts.includePartialMessages ? [\"--include-partial-messages\"] : []),\n    \"--permission-mode\",\n    \"bypassPermissions\",\n    \"--setting-sources\",\n    \"project\",\n    \"--model\",\n    applyOneMillionSuffix(opts.model, opts.needsOneMillionSuffix ?? false),\n    // inline [System] 금지 — 정식 채널만(R7). 생략 시 CC default(23k) 주입되므로 반드시 명시.\n    // 크기에 따라 --system-prompt(작음) / --system-prompt-file(큼)로 분기(systemArgs).\n    ...systemArgs,\n    // Fable 5 는 adaptive thinking 이 필수이고, Opus 5 는 공식 기본 adaptive 동작을 보존한다.\n    ...(usesAdaptiveThinking(opts.model) ? [] : [\"--thinking\", \"disabled\"]),\n    \"--effort\",\n    opts.effort ?? ANTHROPIC_DEFAULT_EFFORT,\n    \"--disable-slash-commands\",\n    \"--session-id\",\n    opts.sessionId,\n  ];\n  if (useStructured) args.push(\"--json-schema\", opts.jsonSchema!);\n  return args;\n}\n\n/**\n * Claude 세션을 spawn 해 한 turn 을 실행한다. per-session 락으로 직렬화된다.\n * @param onDelta 점진 텍스트 delta(streamText) 또는 structured 부분 JSON(streamObject).\n */\nexport function runClaudeSession(\n  req: ClaudeSessionRequest,\n  onDelta: (text: string) => void,\n): Promise<ClaudeSessionResult> {\n  // 정규화 규칙은 canonicalAnthropicModel 이 단독 소유 — dispatcher 가 이미 canonical 을 넘기지만,\n  // 직접 호출(테스트/미래 caller) 대비 방어적으로 한 번 더 통과시킨다(이미 canonical 이면 no-op).\n  assertSupportedOneMillionSuffix(req.model);\n  const model = canonicalAnthropicModel(req.model);\n  const supportsOneMillion = supports1MContext(model);\n  const needsOneMillionSuffix = needsCli1mSuffix(model);\n  const sessionId = randomUUID();\n  const useStructured = Boolean(req.jsonSchema && req.jsonSchema.length > 0);\n  const workerId = makeAnthropicWorkerId(req.tokenId);\n\n  return withSessionLock(sessionId, () => {\n    ensureCwd();\n    const configDir = ensureConfigDir(req.tokenId);\n\n    // 시스템 프롬프트를 크기로 분기: 128KB(argv 한계)의 절반을 넘으면 파일로 넘겨 E2BIG 회피.\n    // 작은 프롬프트는 파일 I/O 없이 기존 inline 경로를 그대로 쓴다(대부분의 호출).\n    // 실제 파일 쓰기는 abort 체크 이후(Promise 안)로 미뤄, 이미 취소된 요청엔 쓰지 않는다.\n    const system = req.system ?? \"\";\n    const useSystemPromptFile = Buffer.byteLength(system, \"utf8\") > SYSTEM_PROMPT_ARGV_MAX_BYTES;\n    const systemPromptFile = useSystemPromptFile\n      ? `${configDir}/system-prompt-${sessionId}.txt`\n      : undefined;\n\n    const args = buildClaudeArgs({\n      model,\n      system: useSystemPromptFile ? undefined : req.system,\n      systemPromptFile,\n      effort: req.effort,\n      jsonSchema: req.jsonSchema,\n      sessionId,\n      needsOneMillionSuffix,\n      includePartialMessages: req.includePartialMessages,\n    });\n\n    const inputLines = buildStreamJsonInput({\n      coldHistory: req.coldHistory,\n      input: req.input,\n    });\n    const stdinPayload = decorateAndSerialize(inputLines, sessionId);\n\n    return new Promise<ClaudeSessionResult>((resolve, reject) => {\n      if (req.abortSignal?.aborted) {\n        reject(new Error(\"aborted\"));\n        return;\n      }\n\n      // 대형 시스템 프롬프트는 spawn 직전에 파일로 기록(argv E2BIG 회피). 종료 시 정리한다.\n      if (systemPromptFile) writeFileSync(systemPromptFile, system);\n\n      const child = spawn(\"claude\", args, {\n        // stderr 도 캡처: invalid OAuth / 잘못된 플래그 / CLI 검증 실패가\n        // \"closed without result\" 로 뭉개지지 않게 close/error 에 stderr 를 실어 보낸다.\n        stdio: [\"pipe\", \"pipe\", \"pipe\"],\n        cwd: ANTHROPIC_CLAUDE_CWD,\n        env: {\n          PATH: process.env.PATH,\n          TMPDIR: process.env.TMPDIR,\n          CLAUDE_CODE_OAUTH_TOKEN: req.token,\n          CLAUDE_CONFIG_DIR: configDir,\n          CLAUDE_CODE_DISABLE_AUTO_MEMORY: \"1\",\n          ...thinkingEnv(model),\n          ...oneMillionEnv(supportsOneMillion),\n          CLAUDE_CODE_DISABLE_CLAUDE_MDS: \"1\",\n          CLAUDE_CODE_DISABLE_TERMINAL_TITLE: \"1\",\n          CLAUDE_CODE_DISABLE_BUNDLED_SKILLS: \"1\",\n          CLAUDE_CODE_DISABLE_WORKFLOWS: \"1\",\n          CLAUDE_CODE_ATTRIBUTION_HEADER: \"0\",\n          // structured + 스트리밍일 때만 retry 를 고정한다(SON-495). text 모드와 논스트림\n          // generate 는 CC 기본 retry 를 그대로 쓴다.\n          ...(shouldPinStructuredRetries({\n            useStructured,\n            includePartialMessages: req.includePartialMessages,\n          })\n            ? structuredOutputRetriesEnv()\n            : {}),\n        },\n      });\n\n      let settled = false;\n      let buffer = \"\";\n      const streamState: ClaudeStreamJsonState = {};\n      const ttftTracker = createTtftTracker();\n      const onTrackedDelta = ttftTracker.wrapDelta(onDelta);\n      // bounded stderr 버퍼(최근 ~4KB만 유지 — 무한 누적 방지).\n      let stderrBuf = \"\";\n      const STDERR_CAP = 4096;\n      child.stderr?.on(\"data\", (d: Buffer) => {\n        stderrBuf = (stderrBuf + d.toString()).slice(-STDERR_CAP);\n      });\n      const stderrSuffix = () => (stderrBuf.trim() ? ` — stderr: ${stderrBuf.trim()}` : \"\");\n      // spawn 시 쓴 임시 시스템 프롬프트 파일 정리(한 번만). 모든 종료 경로에서 호출한다.\n      // 누락돼도 다음 ensureConfigDir 가 디렉토리를 재사용할 뿐이지만, sessionId 별 파일이라\n      // 쌓이면 디스크가 차므로 settle 시 즉시 지운다.\n      const cleanupSpawnFiles = () => {\n        if (!systemPromptFile) return;\n        try {\n          unlinkSync(systemPromptFile);\n        } catch {\n          // 이미 없거나 권한 문제면 무시 — 정리는 best-effort.\n        }\n      };\n      let cleanupAbort: (() => void) | undefined;\n      const timer = setTimeout(() => {\n        if (settled) return;\n        settled = true;\n        cleanupAbort?.();\n        cleanupSpawnFiles();\n        child.kill();\n        reject(new Error(`Claude session timeout after ${req.timeoutMs / 1000}s`));\n      }, req.timeoutMs);\n\n      const finish = (result: ClaudeStreamResult) => {\n        if (settled) return;\n        settled = true;\n        clearTimeout(timer);\n        cleanupAbort?.();\n        cleanupSpawnFiles();\n        resolve({ ...result, sessionId, workerId, ttftMs: ttftTracker.value() });\n      };\n\n      const onAbort = () => {\n        if (settled) return;\n        settled = true;\n        clearTimeout(timer);\n        cleanupAbort?.();\n        cleanupSpawnFiles();\n        child.kill();\n        reject(new Error(\"aborted\"));\n      };\n      cleanupAbort = () => req.abortSignal?.removeEventListener(\"abort\", onAbort);\n      req.abortSignal?.addEventListener(\"abort\", onAbort, { once: true });\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          const result = handleStreamJsonLine(line, onTrackedDelta, {\n            structuredOutput: useStructured,\n            state: streamState,\n          });\n          if (result) {\n            finish(result);\n            return;\n          }\n        }\n      });\n\n      child.on(\"close\", () => {\n        if (settled) return;\n        settled = true;\n        clearTimeout(timer);\n        cleanupAbort?.();\n        cleanupSpawnFiles();\n        reject(new Error(`Claude session closed without result${stderrSuffix()}`));\n      });\n      child.on(\"error\", (err) => {\n        if (settled) return;\n        settled = true;\n        clearTimeout(timer);\n        cleanupAbort?.();\n        cleanupSpawnFiles();\n        reject(new Error(`Claude session spawn error: ${err.message}`));\n      });\n\n      // stdin 으로 입력 JSONL 흘리고 닫는다.\n      ttftTracker.markStart();\n      child.stdin?.write(stdinPayload);\n      child.stdin?.end();\n    });\n  });\n}\n\n// usage 재노출(테스트 편의).\nexport type { TokenUsageBreakdown };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAiDA,MAAM,gCAAgB,IAAI,IAA8B;AAExD,eAAsB,gBAAmB,WAAmB,IAAkC;CAG5F,MAAM,QAFO,cAAc,IAAI,SAAS,KAAK,QAAQ,QAAQ,EAEhD,CAAK,KAAK,IAAI,EAAE;CAG7B,MAAM,OAAO,KAAK,WACV,CAAC,SACD,CAAC,CACT;CACA,cAAc,IAAI,WAAW,IAAI;CACjC,IAAI;EACF,OAAO,MAAM;CACf,UAAU;EAER,IAAI,cAAc,IAAI,SAAS,MAAM,MAAM,cAAc,OAAO,SAAS;CAC3E;AACF;AAKA,SAAgB,sBAAsB,SAAyB;CAC7D,OAAO;AACT;AAKA,SAAgB,qBACd,OACA,WACQ;CACR,OACE,MACG,KAAK,SACJ,KAAK,UAAU;EACb,GAAG;EACH,YAAY;EACZ,MAAM,WAAW;EACjB,oBAAoB;CACtB,CAAC,CACH,CAAC,CACA,KAAK,IAAI,IAAI;AAEpB;AA4BA,SAAgB,gBAAgB,SAAyB;CACvD,MAAM,MAAM,mBAAmB,OAAO;CACtC,UAAU,KAAK,EAAE,WAAW,KAAK,CAAC;CAClC,cAAc,GAAG,IAAI,gBAAgB,IAAI;CACzC,cAAc,GAAG,IAAI,iBAAiB,IAAI;CAC1C,OAAO;AACT;AAEA,IAAI,aAAa;AACjB,SAAS,YAAkB;CACzB,IAAI,YAAY;CAChB,UAAU,GAAG,qBAAqB,WAAW,EAAE,WAAW,KAAK,CAAC;CAChE,cAAc,GAAG,qBAAqB,yBAAyB,IAAI;CACnE,aAAa;AACf;AAGA,SAAgB,sBAAsB,OAAe,aAA8B;CACjF,MAAM,OAAO,wBAAwB,KAAK;CAC1C,OAAO,cAAc,GAAG,KAAK,QAAQ;AACvC;AAEA,SAAgB,cAAc,WAA8D;CAC1F,OAAO,YAAY,CAAC,IAAI,EAAE,gCAAgC,IAAI;AAChE;AAEA,SAAgB,YAAY,OAG1B;CACA,OAAO,qBAAqB,KAAK,IAC7B,CAAC,IACD;EACE,uCAAuC;EACvC,qBAAqB;CACvB;AACN;AAMA,SAAgB,2BAA2B,MAAM,QAAQ,IAAI,+BAE3D;CACA,IAAI,CAAC,KAAK,OAAO,EAAE,+BAA+B,IAAI;CACtD,MAAM,SAAS,OAAO,SAAS,KAAK,EAAE;CACtC,IAAI,CAAC,OAAO,SAAS,MAAM,GAAG,OAAO,EAAE,+BAA+B,IAAI;CAC1E,OAAO,EAAE,+BAA+B,OAAO,KAAK,IAAI,QAAQ,CAAC,CAAC,EAAE;AACtE;AAWA,SAAgB,2BAA2B,MAG/B;CACV,OAAO,KAAK,iBAAiB,KAAK,2BAA2B;AAC/D;AAMA,MAAa,+BAA+B;AAE5C,SAAgB,gBAAgB,MAcd;CAChB,MAAM,gBAAgB,QAAQ,KAAK,cAAc,KAAK,WAAW,SAAS,CAAC;CAC3E,IAAI,eAAe,8BAA8B,KAAK,UAAW;CAEjE,MAAM,WAAW,gBACb;EAAC;EAAW;EAAI;EAAmB;CAAkB,IACrD,CAAC,WAAW,EAAE;CAIlB,MAAM,aAAa,KAAK,mBACpB,CAAC,wBAAwB,KAAK,gBAAgB,IAC9C,CAAC,mBAAmB,KAAK,UAAU,EAAE;CAEzC,MAAM,OAAsB;EAC1B;EACA,GAAG;EACH;EACA,GAAG;EACH;EACA;EACA;EACA;EACA;EACA,GAAI,KAAK,yBAAyB,CAAC,4BAA4B,IAAI,CAAC;EACpE;EACA;EACA;EACA;EACA;EACA,sBAAsB,KAAK,OAAO,KAAK,yBAAyB,KAAK;EAGrE,GAAG;EAEH,GAAI,qBAAqB,KAAK,KAAK,IAAI,CAAC,IAAI,CAAC,cAAc,UAAU;EACrE;EACA,KAAK,UAAA;EACL;EACA;EACA,KAAK;CACP;CACA,IAAI,eAAe,KAAK,KAAK,iBAAiB,KAAK,UAAW;CAC9D,OAAO;AACT;;;;;AAMA,SAAgB,iBACd,KACA,SAC8B;CAG9B,gCAAgC,IAAI,KAAK;CACzC,MAAM,QAAQ,wBAAwB,IAAI,KAAK;CAC/C,MAAM,qBAAqB,kBAAkB,KAAK;CAClD,MAAM,wBAAwB,iBAAiB,KAAK;CACpD,MAAM,YAAY,WAAW;CAC7B,MAAM,gBAAgB,QAAQ,IAAI,cAAc,IAAI,WAAW,SAAS,CAAC;CACzE,MAAM,WAAW,sBAAsB,IAAI,OAAO;CAElD,OAAO,gBAAgB,iBAAiB;EACtC,UAAU;EACV,MAAM,YAAY,gBAAgB,IAAI,OAAO;EAK7C,MAAM,SAAS,IAAI,UAAU;EAC7B,MAAM,sBAAsB,OAAO,WAAW,QAAQ,MAAM,IAAI;EAChE,MAAM,mBAAmB,sBACrB,GAAG,UAAU,iBAAiB,UAAU,QACxC;EAEJ,MAAM,OAAO,gBAAgB;GAC3B;GACA,QAAQ,sBAAsB,SAAY,IAAI;GAC9C;GACA,QAAQ,IAAI;GACZ,YAAY,IAAI;GAChB;GACA;GACA,wBAAwB,IAAI;EAC9B,CAAC;EAMD,MAAM,eAAe,qBAJF,qBAAqB;GACtC,aAAa,IAAI;GACjB,OAAO,IAAI;EACb,CAC0C,GAAY,SAAS;EAE/D,OAAO,IAAI,SAA8B,SAAS,WAAW;GAC3D,IAAI,IAAI,aAAa,SAAS;IAC5B,uBAAO,IAAI,MAAM,SAAS,CAAC;IAC3B;GACF;GAGA,IAAI,kBAAkB,cAAc,kBAAkB,MAAM;GAE5D,MAAM,QAAQ,MAAM,UAAU,MAAM;IAGlC,OAAO;KAAC;KAAQ;KAAQ;IAAM;IAC9B,KAAK;IACL,KAAK;KACH,MAAM,QAAQ,IAAI;KAClB,QAAQ,QAAQ,IAAI;KACpB,yBAAyB,IAAI;KAC7B,mBAAmB;KACnB,iCAAiC;KACjC,GAAG,YAAY,KAAK;KACpB,GAAG,cAAc,kBAAkB;KACnC,gCAAgC;KAChC,oCAAoC;KACpC,oCAAoC;KACpC,+BAA+B;KAC/B,gCAAgC;KAGhC,GAAI,2BAA2B;MAC7B;MACA,wBAAwB,IAAI;KAC9B,CAAC,IACG,2BAA2B,IAC3B,CAAC;IACP;GACF,CAAC;GAED,IAAI,UAAU;GACd,IAAI,SAAS;GACb,MAAM,cAAqC,CAAC;GAC5C,MAAM,cAAc,kBAAkB;GACtC,MAAM,iBAAiB,YAAY,UAAU,OAAO;GAEpD,IAAI,YAAY;GAEhB,MAAM,QAAQ,GAAG,SAAS,MAAc;IACtC,aAAa,YAAY,EAAE,SAAS,EAAA,CAAG,MAAM,KAAW;GAC1D,CAAC;GACD,MAAM,qBAAsB,UAAU,KAAK,IAAI,cAAc,UAAU,KAAK,MAAM;GAIlF,MAAM,0BAA0B;IAC9B,IAAI,CAAC,kBAAkB;IACvB,IAAI;KACF,WAAW,gBAAgB;IAC7B,QAAQ,CAER;GACF;GACA,IAAI;GACJ,MAAM,QAAQ,iBAAiB;IAC7B,IAAI,SAAS;IACb,UAAU;IACV,eAAe;IACf,kBAAkB;IAClB,MAAM,KAAK;IACX,uBAAO,IAAI,MAAM,gCAAgC,IAAI,YAAY,IAAK,EAAE,CAAC;GAC3E,GAAG,IAAI,SAAS;GAEhB,MAAM,UAAU,WAA+B;IAC7C,IAAI,SAAS;IACb,UAAU;IACV,aAAa,KAAK;IAClB,eAAe;IACf,kBAAkB;IAClB,QAAQ;KAAE,GAAG;KAAQ;KAAW;KAAU,QAAQ,YAAY,MAAM;IAAE,CAAC;GACzE;GAEA,MAAM,gBAAgB;IACpB,IAAI,SAAS;IACb,UAAU;IACV,aAAa,KAAK;IAClB,eAAe;IACf,kBAAkB;IAClB,MAAM,KAAK;IACX,uBAAO,IAAI,MAAM,SAAS,CAAC;GAC7B;GACA,qBAAqB,IAAI,aAAa,oBAAoB,SAAS,OAAO;GAC1E,IAAI,aAAa,iBAAiB,SAAS,SAAS,EAAE,MAAM,KAAK,CAAC;GAElE,MAAM,QAAQ,GAAG,SAAS,MAAc;IACtC,IAAI,SAAS;IACb,UAAU,EAAE,SAAS;IACrB,MAAM,QAAQ,OAAO,MAAM,IAAI;IAC/B,SAAS,MAAM,IAAI,KAAK;IACxB,KAAK,MAAM,QAAQ,OAAO;KACxB,MAAM,SAAS,qBAAqB,MAAM,gBAAgB;MACxD,kBAAkB;MAClB,OAAO;KACT,CAAC;KACD,IAAI,QAAQ;MACV,OAAO,MAAM;MACb;KACF;IACF;GACF,CAAC;GAED,MAAM,GAAG,eAAe;IACtB,IAAI,SAAS;IACb,UAAU;IACV,aAAa,KAAK;IAClB,eAAe;IACf,kBAAkB;IAClB,uBAAO,IAAI,MAAM,uCAAuC,aAAa,GAAG,CAAC;GAC3E,CAAC;GACD,MAAM,GAAG,UAAU,QAAQ;IACzB,IAAI,SAAS;IACb,UAAU;IACV,aAAa,KAAK;IAClB,eAAe;IACf,kBAAkB;IAClB,uBAAO,IAAI,MAAM,+BAA+B,IAAI,SAAS,CAAC;GAChE,CAAC;GAGD,YAAY,UAAU;GACtB,MAAM,OAAO,MAAM,YAAY;GAC/B,MAAM,OAAO,IAAI;EACnB,CAAC;CACH,CAAC;AACH"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"claude-session.js","names":[],"sources":["../../../../src/utils/providers/anthropic/claude-session.ts"],"sourcesContent":["/**\n * claude-session — Claude CLI 세션 spawn + QgridThreadCoord 매핑 + per-session 락.\n *\n * 멀티턴: 매 호출 fresh `--session-id <uuid>`로 실행한다. 입력은 어댑터가 만든 JSONL 을\n * stdin 으로 흘리고(`--input-format stream-json`), 출력은 파서로 처리한다.\n *\n * 핵심 계약:\n *  - coord 는 임의 저장이 아니라 기존 QgridThreadCoord{workerId,threadId,epoch,systemHash} 에\n *    매핑한다. threadId=세션 uuid, epoch=0 고정(worker restart 개념 없음), workerId=token 기반\n *    안정 합성, systemHash=요청 system 해시. issueConvContext/decideConvRouting 과 round-trip.\n *  - withSessionLock 은 exported primitive 로 유지한다. 기본 경로에서는 매 호출 새 session-id 라\n *    사실상 no-contention 이지만, 직접 호출자/테스트의 직렬화 보장은 보존한다.\n *  - stream-json 직렬화 시 SDK envelope(uuid/session_id/parent_tool_use_id) decorate.\n *  - structured output 일 때 출력 파서에 { structuredOutput: true } 전달(없으면 streamObject 깨짐).\n */\n\nimport { spawn } from \"node:child_process\";\nimport { randomUUID } from \"node:crypto\";\nimport { mkdirSync, unlinkSync, writeFileSync } from \"node:fs\";\n\nimport { resolveAnthropicEffort } from \"../common/effort\";\nimport { type JsonValue, type TokenUsageBreakdown, type UserInput } from \"../common/provider-types\";\nimport {\n  ARGV_SAFE_MAX_UTF8_BYTES,\n  assertAnthropicSchemaArgvSize,\n} from \"../common/schema-validation\";\nimport { createTtftTracker } from \"../common/ttft\";\nimport {\n  ANTHROPIC_CLAUDE_CWD,\n  anthropicConfigDir,\n  ANTHROPIC_DEFAULT_EFFORT,\n  ANTHROPIC_DISALLOWED_TOOLS,\n  assertSupportedOneMillionSuffix,\n  canonicalAnthropicModel,\n  needsCli1mSuffix,\n  supports1MContext,\n  usesAdaptiveThinking,\n} from \"./anthropic-constants\";\nimport {\n  buildStreamJsonInput,\n  type ClaudeStreamJsonState,\n  type ClaudeStreamJsonLine,\n  type ClaudeStreamResult,\n  handleStreamJsonLine,\n} from \"./stream-json-adapter\";\n\n// ── per-session 락 ─────────────────────────────────────────────────\n\n// session-id 단위 직렬화 primitive. 기본 경로에서는 매 호출 새 uuid 라 사실상 no-op 이지만,\n// 같은 session-id 를 직접 쓰는 호출자는 여전히 직렬화 보장을 받는다.\nconst sessionChains = new Map<string, Promise<unknown>>();\n\nexport async function withSessionLock<T>(sessionId: string, fn: () => Promise<T>): Promise<T> {\n  const prev = sessionChains.get(sessionId) ?? Promise.resolve();\n  // 이전 turn 의 성패와 무관하게 직렬 체인을 잇는다.\n  const next = prev.then(fn, fn);\n  // tail: 성패 무관 settle 되는 핸들. 이걸 맵에 두고, finally 에서 \"여전히 내가 끝\"일 때만 삭제.\n  // (set 직후 undefined 검사로 하면 절대 삭제 안 돼 세션 id 가 누수됨 — tail 일치 검사로 회피.)\n  const tail = next.then(\n    () => {},\n    () => {},\n  );\n  sessionChains.set(sessionId, tail);\n  try {\n    return await next;\n  } finally {\n    // 그 사이 다른 turn 이 체인을 이어받았으면 tail 이 교체돼 있다 — 그때는 삭제하지 않는다.\n    if (sessionChains.get(sessionId) === tail) sessionChains.delete(sessionId);\n  }\n}\n\n// ── coord 매핑 ──────────────────────────────────────────────────────\n\n// token 기반 안정 workerId 합성. Anthropic 은 worker pool 이 없으므로 tokenId 를 그대로 쓴다.\nexport function makeAnthropicWorkerId(tokenId: number): number {\n  return tokenId;\n}\n\n// ── envelope decorate ──────────────────────────────────────────────\n\n// stream-json 입력 라인에 SDK envelope 부착 후 직렬화. session 소유자인 여기서 한다.\nexport function decorateAndSerialize(\n  lines: Array<ClaudeStreamJsonLine>,\n  sessionId: string,\n): string {\n  return (\n    lines\n      .map((line) =>\n        JSON.stringify({\n          ...line,\n          session_id: sessionId,\n          uuid: randomUUID(),\n          parent_tool_use_id: null,\n        }),\n      )\n      .join(\"\\n\") + \"\\n\"\n  );\n}\n\n// ── spawn + consume ────────────────────────────────────────────────\n\nexport interface ClaudeSessionRequest {\n  tokenId: number;\n  token: string; // OAuth access token\n  model: string;\n  system?: string;\n  jsonSchema?: string; // 있으면 structured output\n  effort?: string;\n  timeoutMs: number;\n  coldHistory?: Array<JsonValue>;\n  input: Array<UserInput>;\n  abortSignal?: AbortSignal;\n  includePartialMessages?: boolean;\n}\n\nexport interface ClaudeSessionResult extends ClaudeStreamResult {\n  sessionId: string;\n  workerId: number;\n  ttftMs: number | null;\n}\n\n// per-token CLAUDE_CONFIG_DIR 보장(격리). 경로 규칙은 anthropicConfigDir(순수 함수)이 소유 —\n// 여기선 그 경로에 빈 settings 를 깔아 claude-mem hook 등을 차단한다. (R10 격리)\n// 이 seed 파일은 claude-mem hook / 사용자 설정 오염 차단을 위한 격리 경계다. 매 호출마다 다시 써서\n// 외부 변조·삭제 후에도 다음 실행에서 self-healing 되도록 기존 semantics 를 유지한다.\nexport function ensureConfigDir(tokenId: number): string {\n  const dir = anthropicConfigDir(tokenId);\n  mkdirSync(dir, { recursive: true });\n  writeFileSync(`${dir}/.claude.json`, \"{}\");\n  writeFileSync(`${dir}/settings.json`, \"{}\");\n  return dir;\n}\n\nlet cwdEnsured = false;\nfunction ensureCwd(): void {\n  if (cwdEnsured) return;\n  mkdirSync(`${ANTHROPIC_CLAUDE_CWD}/.claude`, { recursive: true });\n  writeFileSync(`${ANTHROPIC_CLAUDE_CWD}/.claude/settings.json`, \"{}\");\n  cwdEnsured = true;\n}\n\n// spawn args 구성. 멀티턴/격리/structured 모드 반영.\nexport function applyOneMillionSuffix(model: string, needsSuffix: boolean): string {\n  const base = canonicalAnthropicModel(model);\n  return needsSuffix ? `${base}[1m]` : base;\n}\n\nexport function oneMillionEnv(supported: boolean): { CLAUDE_CODE_DISABLE_1M_CONTEXT?: \"1\" } {\n  return supported ? {} : { CLAUDE_CODE_DISABLE_1M_CONTEXT: \"1\" };\n}\n\nexport function thinkingEnv(model: string): {\n  CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING?: \"1\";\n  MAX_THINKING_TOKENS?: \"0\";\n} {\n  return usesAdaptiveThinking(model)\n    ? {}\n    : {\n        CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING: \"1\",\n        MAX_THINKING_TOKENS: \"0\",\n      };\n}\n\n// SON-495: structured output retry 를 1 로 고정한다. CC 가 attempt 를 reject 하고 retry 하면\n// `{rejected}{accepted}` 누적이 AI-SDK 의 JSON.parse 를 깨뜨리므로, retry 자체를 막아 그 경로를\n// 원천 차단한다. `0` 은 CC query loop(`callsThisQuery >= maxRetries`)가 첫 attempt emit 전에\n// 실패시키므로(`error_max_structured_output_retries`) 외부 값이 1 미만이어도 1 로 클램프한다.\nexport function structuredOutputRetriesEnv(raw = process.env.MAX_STRUCTURED_OUTPUT_RETRIES): {\n  MAX_STRUCTURED_OUTPUT_RETRIES: string;\n} {\n  if (!raw) return { MAX_STRUCTURED_OUTPUT_RETRIES: \"1\" };\n  const parsed = Number.parseInt(raw, 10);\n  if (!Number.isFinite(parsed)) return { MAX_STRUCTURED_OUTPUT_RETRIES: \"1\" };\n  return { MAX_STRUCTURED_OUTPUT_RETRIES: String(Math.max(parsed, 1)) };\n}\n\n// SON-495 의 retry 고정은 \"스트리밍 + structured\" 조합 한정 정책이다. 스트림에서 retry 가 돌면\n// wall-clock 이 2배가 되어 실용성이 없기 때문이다(원 결정 사유). 논스트림 generate 는 애초에 완료를\n// 기다리므로 그 사유가 성립하지 않는다. 반면 Claude 계열은 OpenAI 대비 structured output 준수율이\n// 낮아, 논스트림까지 retry=1 로 묶으면 1회 reject 가 곧바로\n// `error_max_structured_output_retries` 로 직결된다(실측: deti_production opus-4-8 실패율 39.6%).\n// 스트리밍 여부는 `--include-partial-messages` 를 붙이는 generateStream 경로에서만 true 가 되므로\n// (anthropic-dispatcher 의 generate/generateStream 분기) 이를 실질 구분자로 쓴다.\n// 비성공 subtype 을 항상 isError 로 올리는 SON-495 의 나머지 절반은 그대로 유지된다 — retry 후에도\n// degenerate 출력이면 조용히 통과시키지 않고 정직하게 실패한다.\nexport function shouldPinStructuredRetries(opts: {\n  useStructured: boolean;\n  includePartialMessages?: boolean;\n}): boolean {\n  return opts.useStructured && opts.includePartialMessages === true;\n}\n\n// Linux 단일 argv 인자 한계(MAX_ARG_STRLEN = PAGE_SIZE×32 = 128KB, 커널 하드코딩 상수)\n// 시스템 프롬프트가 이를 넘으면 execve 가 E2BIG 로 거부된다. deti 등 대형 프롬프트는 실측\n// 평균 343KB·최대 485KB(opus-4-8)라 일상적으로 초과한다. 한계의 절반(64KB)을 임계값으로 잡아\n// UTF-8 멀티바이트·예측 못 한 여유분까지 안전 마진을 둔다.\nexport const SYSTEM_PROMPT_ARGV_MAX_BYTES = ARGV_SAFE_MAX_UTF8_BYTES;\n\nexport function buildClaudeArgs(opts: {\n  model: string;\n  // 시스템 프롬프트 전달은 크기로 분기한다(호출부가 결정):\n  //  - 작으면 system(inline) → --system-prompt <text> (파일 I/O 없음, 기존 경로)\n  //  - 크면 systemPromptFile(경로) → --system-prompt-file <path> (argv 한계 회피)\n  // --system-prompt-file 은 --system-prompt 와 동일하게 default 를 replace 한다(append 아님 —\n  // R7 격리 보존, 실측 확인). 둘 다 없으면 빈 --system-prompt(default 23k 주입 방지).\n  system?: string;\n  systemPromptFile?: string;\n  effort?: string;\n  jsonSchema?: string;\n  sessionId: string;\n  needsOneMillionSuffix?: boolean;\n  includePartialMessages?: boolean;\n}): Array<string> {\n  const useStructured = Boolean(opts.jsonSchema && opts.jsonSchema.length > 0);\n  if (useStructured) assertAnthropicSchemaArgvSize(opts.jsonSchema!);\n  // --tools \"\" 로 전체 차단, structured(jsonSchema 있음) 면 StructuredOutput 만 허용.\n  const toolArgs = useStructured\n    ? [\"--tools\", \"\", \"--allowed-tools\", \"StructuredOutput\"]\n    : [\"--tools\", \"\"];\n\n  // 시스템 프롬프트: 파일 경로가 오면 --system-prompt-file, 아니면 inline --system-prompt.\n  // (호출부가 크기로 분기해 둘 중 하나만 채운다. 둘 다 없으면 빈 --system-prompt.)\n  const systemArgs = opts.systemPromptFile\n    ? [\"--system-prompt-file\", opts.systemPromptFile]\n    : [\"--system-prompt\", opts.system ?? \"\"];\n\n  const args: Array<string> = [\n    \"-p\",\n    ...toolArgs,\n    \"--disallowedTools\",\n    ...ANTHROPIC_DISALLOWED_TOOLS,\n    \"--input-format\",\n    \"stream-json\",\n    \"--output-format\",\n    \"stream-json\",\n    \"--verbose\",\n    ...(opts.includePartialMessages ? [\"--include-partial-messages\"] : []),\n    \"--permission-mode\",\n    \"bypassPermissions\",\n    \"--setting-sources\",\n    \"project\",\n    \"--model\",\n    applyOneMillionSuffix(opts.model, opts.needsOneMillionSuffix ?? false),\n    // inline [System] 금지 — 정식 채널만(R7). 생략 시 CC default(23k) 주입되므로 반드시 명시.\n    // 크기에 따라 --system-prompt(작음) / --system-prompt-file(큼)로 분기(systemArgs).\n    ...systemArgs,\n    // Fable 5 는 adaptive thinking 이 필수이고, Opus 5 는 공식 기본 adaptive 동작을 보존한다.\n    ...(usesAdaptiveThinking(opts.model) ? [] : [\"--thinking\", \"disabled\"]),\n    // Claude Code 어휘 밖의 effort(OpenAI 전용 ultra, 옛 none/minimal 등)는 조용히 버리고 qgrid 기본을 쓴다.\n    \"--effort\",\n    resolveAnthropicEffort(opts.effort) ?? ANTHROPIC_DEFAULT_EFFORT,\n    \"--disable-slash-commands\",\n    \"--session-id\",\n    opts.sessionId,\n  ];\n  if (useStructured) args.push(\"--json-schema\", opts.jsonSchema!);\n  return args;\n}\n\n/**\n * Claude 세션을 spawn 해 한 turn 을 실행한다. per-session 락으로 직렬화된다.\n * @param onDelta 점진 텍스트 delta(streamText) 또는 structured 부분 JSON(streamObject).\n */\nexport function runClaudeSession(\n  req: ClaudeSessionRequest,\n  onDelta: (text: string) => void,\n): Promise<ClaudeSessionResult> {\n  // 정규화 규칙은 canonicalAnthropicModel 이 단독 소유 — dispatcher 가 이미 canonical 을 넘기지만,\n  // 직접 호출(테스트/미래 caller) 대비 방어적으로 한 번 더 통과시킨다(이미 canonical 이면 no-op).\n  assertSupportedOneMillionSuffix(req.model);\n  const model = canonicalAnthropicModel(req.model);\n  const supportsOneMillion = supports1MContext(model);\n  const needsOneMillionSuffix = needsCli1mSuffix(model);\n  const sessionId = randomUUID();\n  const useStructured = Boolean(req.jsonSchema && req.jsonSchema.length > 0);\n  const workerId = makeAnthropicWorkerId(req.tokenId);\n\n  return withSessionLock(sessionId, () => {\n    ensureCwd();\n    const configDir = ensureConfigDir(req.tokenId);\n\n    // 시스템 프롬프트를 크기로 분기: 128KB(argv 한계)의 절반을 넘으면 파일로 넘겨 E2BIG 회피.\n    // 작은 프롬프트는 파일 I/O 없이 기존 inline 경로를 그대로 쓴다(대부분의 호출).\n    // 실제 파일 쓰기는 abort 체크 이후(Promise 안)로 미뤄, 이미 취소된 요청엔 쓰지 않는다.\n    const system = req.system ?? \"\";\n    const useSystemPromptFile = Buffer.byteLength(system, \"utf8\") > SYSTEM_PROMPT_ARGV_MAX_BYTES;\n    const systemPromptFile = useSystemPromptFile\n      ? `${configDir}/system-prompt-${sessionId}.txt`\n      : undefined;\n\n    const args = buildClaudeArgs({\n      model,\n      system: useSystemPromptFile ? undefined : req.system,\n      systemPromptFile,\n      effort: req.effort,\n      jsonSchema: req.jsonSchema,\n      sessionId,\n      needsOneMillionSuffix,\n      includePartialMessages: req.includePartialMessages,\n    });\n\n    const inputLines = buildStreamJsonInput({\n      coldHistory: req.coldHistory,\n      input: req.input,\n    });\n    const stdinPayload = decorateAndSerialize(inputLines, sessionId);\n\n    return new Promise<ClaudeSessionResult>((resolve, reject) => {\n      if (req.abortSignal?.aborted) {\n        reject(new Error(\"aborted\"));\n        return;\n      }\n\n      // 대형 시스템 프롬프트는 spawn 직전에 파일로 기록(argv E2BIG 회피). 종료 시 정리한다.\n      if (systemPromptFile) writeFileSync(systemPromptFile, system);\n\n      const child = spawn(\"claude\", args, {\n        // stderr 도 캡처: invalid OAuth / 잘못된 플래그 / CLI 검증 실패가\n        // \"closed without result\" 로 뭉개지지 않게 close/error 에 stderr 를 실어 보낸다.\n        stdio: [\"pipe\", \"pipe\", \"pipe\"],\n        cwd: ANTHROPIC_CLAUDE_CWD,\n        env: {\n          PATH: process.env.PATH,\n          TMPDIR: process.env.TMPDIR,\n          CLAUDE_CODE_OAUTH_TOKEN: req.token,\n          CLAUDE_CONFIG_DIR: configDir,\n          CLAUDE_CODE_DISABLE_AUTO_MEMORY: \"1\",\n          ...thinkingEnv(model),\n          ...oneMillionEnv(supportsOneMillion),\n          CLAUDE_CODE_DISABLE_CLAUDE_MDS: \"1\",\n          CLAUDE_CODE_DISABLE_TERMINAL_TITLE: \"1\",\n          CLAUDE_CODE_DISABLE_BUNDLED_SKILLS: \"1\",\n          CLAUDE_CODE_DISABLE_WORKFLOWS: \"1\",\n          CLAUDE_CODE_ATTRIBUTION_HEADER: \"0\",\n          // structured + 스트리밍일 때만 retry 를 고정한다(SON-495). text 모드와 논스트림\n          // generate 는 CC 기본 retry 를 그대로 쓴다.\n          ...(shouldPinStructuredRetries({\n            useStructured,\n            includePartialMessages: req.includePartialMessages,\n          })\n            ? structuredOutputRetriesEnv()\n            : {}),\n        },\n      });\n\n      let settled = false;\n      let buffer = \"\";\n      const streamState: ClaudeStreamJsonState = {};\n      const ttftTracker = createTtftTracker();\n      const onTrackedDelta = ttftTracker.wrapDelta(onDelta);\n      // bounded stderr 버퍼(최근 ~4KB만 유지 — 무한 누적 방지).\n      let stderrBuf = \"\";\n      const STDERR_CAP = 4096;\n      child.stderr?.on(\"data\", (d: Buffer) => {\n        stderrBuf = (stderrBuf + d.toString()).slice(-STDERR_CAP);\n      });\n      const stderrSuffix = () => (stderrBuf.trim() ? ` — stderr: ${stderrBuf.trim()}` : \"\");\n      // spawn 시 쓴 임시 시스템 프롬프트 파일 정리(한 번만). 모든 종료 경로에서 호출한다.\n      // 누락돼도 다음 ensureConfigDir 가 디렉토리를 재사용할 뿐이지만, sessionId 별 파일이라\n      // 쌓이면 디스크가 차므로 settle 시 즉시 지운다.\n      const cleanupSpawnFiles = () => {\n        if (!systemPromptFile) return;\n        try {\n          unlinkSync(systemPromptFile);\n        } catch {\n          // 이미 없거나 권한 문제면 무시 — 정리는 best-effort.\n        }\n      };\n      let cleanupAbort: (() => void) | undefined;\n      const timer = setTimeout(() => {\n        if (settled) return;\n        settled = true;\n        cleanupAbort?.();\n        cleanupSpawnFiles();\n        child.kill();\n        reject(new Error(`Claude session timeout after ${req.timeoutMs / 1000}s`));\n      }, req.timeoutMs);\n\n      const finish = (result: ClaudeStreamResult) => {\n        if (settled) return;\n        settled = true;\n        clearTimeout(timer);\n        cleanupAbort?.();\n        cleanupSpawnFiles();\n        resolve({ ...result, sessionId, workerId, ttftMs: ttftTracker.value() });\n      };\n\n      const onAbort = () => {\n        if (settled) return;\n        settled = true;\n        clearTimeout(timer);\n        cleanupAbort?.();\n        cleanupSpawnFiles();\n        child.kill();\n        reject(new Error(\"aborted\"));\n      };\n      cleanupAbort = () => req.abortSignal?.removeEventListener(\"abort\", onAbort);\n      req.abortSignal?.addEventListener(\"abort\", onAbort, { once: true });\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          const result = handleStreamJsonLine(line, onTrackedDelta, {\n            structuredOutput: useStructured,\n            state: streamState,\n          });\n          if (result) {\n            finish(result);\n            return;\n          }\n        }\n      });\n\n      child.on(\"close\", () => {\n        if (settled) return;\n        settled = true;\n        clearTimeout(timer);\n        cleanupAbort?.();\n        cleanupSpawnFiles();\n        reject(new Error(`Claude session closed without result${stderrSuffix()}`));\n      });\n      child.on(\"error\", (err) => {\n        if (settled) return;\n        settled = true;\n        clearTimeout(timer);\n        cleanupAbort?.();\n        cleanupSpawnFiles();\n        reject(new Error(`Claude session spawn error: ${err.message}`));\n      });\n\n      // stdin 으로 입력 JSONL 흘리고 닫는다.\n      ttftTracker.markStart();\n      child.stdin?.write(stdinPayload);\n      child.stdin?.end();\n    });\n  });\n}\n\n// usage 재노출(테스트 편의).\nexport type { TokenUsageBreakdown };\n"],"mappings":"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"}

package/bundle/dist/utils/providers/common/effort.js

@@ -0,0 +1,51 @@
+import { openaiModelMaxEffort } from "./model-cost.js";
+import { getLogger } from "@logtape/logtape";
+//#region src/utils/providers/common/effort.ts
+const logger = getLogger(["qgrid", "effort"]);
+/**
+* provider 별 reasoning effort 어휘.
+*
+* SDK 가 보낸 effort 문자열을 그대로 provider 에 넘기지 않는다. provider 마다 받는 값이 다르고,
+* 모르는 값을 받았을 때의 반응도 다르다(Codex 백엔드는 400 이 예상되고, Claude Code 는 경고만
+* 남기고 모델 기본 effort 로 실행한다). 각 provider dispatcher 가 요청을 만들 때 여기서 판정해,
+* 맞지 않는 값은 오류 없이 버리고 "미지정" 과 같게 취급한다.
+*/
+const OPENAI_EFFORTS = [
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max",
+	"ultra"
+];
+const ANTHROPIC_EFFORTS = [
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max"
+];
+function resolveWithin(levels, effort, max, target) {
+	if (effort === void 0) return void 0;
+	const rank = levels.indexOf(effort);
+	if (rank < 0) {
+		logger.debug(`ignoring effort "${effort}" for ${target}: not in ${levels.join("/")}`);
+		return;
+	}
+	if (max !== void 0 && rank > levels.indexOf(max)) {
+		logger.debug(`ignoring effort "${effort}" for ${target}: model supports up to "${max}"`);
+		return;
+	}
+	return effort;
+}
+/** canonical OpenAI model(`openai/` prefix 제거 후) 기준으로 effort 를 판정한다. */
+function resolveOpenAIEffort(model, effort) {
+	return resolveWithin(OPENAI_EFFORTS, effort, openaiModelMaxEffort(model), `openai/${model}`);
+}
+function resolveAnthropicEffort(effort) {
+	return resolveWithin(ANTHROPIC_EFFORTS, effort, void 0, "anthropic");
+}
+//#endregion
+export { ANTHROPIC_EFFORTS, OPENAI_EFFORTS, resolveAnthropicEffort, resolveOpenAIEffort };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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