@things-factory/ai-assistant 10.1.37 → 10.1.38

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/ai-assistant",
-  "version": "10.1.37",
+  "version": "10.1.38",
   "main": "dist-server/index.js",
   "things-factory": true,
   "author": "heartyoh",
@@ -30,9 +30,9 @@
     "@operato/i18n": "^10.0.0",
     "@operato/styles": "^10.0.0",
     "@things-factory/ai-client-base": "^10.1.31",
-    "@things-factory/auth-base": "^10.1.37",
+    "@things-factory/auth-base": "^10.1.38",
     "@things-factory/env": "^10.1.20",
-    "@things-factory/shell": "^10.1.37",
+    "@things-factory/shell": "^10.1.38",
     "dompurify": "^3.0.0",
     "graphql-scalars": "^1.22.0",
     "graphql-tag": "^2.12.6",
@@ -44,5 +44,5 @@
     "copyfiles": "^2.4.1",
     "rimraf": "^5.0.0"
   },
-  "gitHead": "d8a69e5c8803a4b9d3289df0cf38e161a207db61"
+  "gitHead": "b947349fe1c27d11038b592ceadaba336f14785b"
 }

package/server/service/chat-message/chat-message-broadcast.ts

@@ -7,6 +7,7 @@
  * **ChatSession 단위**로 묶이므로 필터 키가 sessionId (+ domain 격리).
  */
 import type { ChatMessage } from './chat-message.js' // type-only — 런타임 import 아님
+import { mayReadSession } from '../chat-session/session-visibility.js'
 
 /** chat-message 브로드캐스트 토픽. */
 export const CHAT_MESSAGE_TOPIC = 'board-ai-chat-message'
@@ -25,3 +26,43 @@ export function chatMessageFilter(domainId: string, sessionId: string) {
   return (payload: ChatMessagePayload): boolean =>
     !!payload && payload.domainId === domainId && payload.sessionId === sessionId
 }
+
+/*
+ * ── 방이 이 사람에게 열려 있나 — ADR-0073 결정 2 ────────────────────────────
+ *
+ * 공개 대화는 도메인 안 누구나, 비공개 대화는 참여자만. 저장된 길(`chatMessages`)은 그것을 묻고
+ * 있었고 방송 길은 묻지 않았다 — 구독 때 도메인 소속만 보고, 필터는 도메인 + 세션만 맞췄다. 그래서
+ * 비공개 세션의 id 를 가진 도메인 안 누구나 그 대화를 실시간으로 받았다.
+ *
+ * 규칙은 한 줄(`mayReadSession`)이고 두 길이 같은 줄을 읽는다. 여기서 다시 적으면 그날부터 두 벌이다.
+ */
+/** 방에 대한 두 물음. 저장소는 부르는 쪽이 준다 — 이 파일은 저장소를 모른다. */
+export interface ChatRoomLookup {
+  /** 그 세션의 지금 공개 범위. 이 도메인에 그런 세션이 없으면 `undefined`. */
+  visibility(): Promise<string | null | undefined>
+  /** 부르는 사람이 지금 그 세션의 참여자인가. */
+  isParticipant(): Promise<boolean>
+}
+
+export async function mayHearRoom(room: ChatRoomLookup): Promise<boolean> {
+  const visibility = await room.visibility()
+
+  /* 이 도메인에 없는 세션 — 열림으로 읽지 않는다. */
+  if (visibility === undefined) return false
+
+  /* 공개 방이면 참여 여부를 묻지 않는다. 방송마다 조회가 하나 준다. */
+  if (mayReadSession(visibility, false)) return true
+
+  return mayReadSession(visibility, await room.isParticipant())
+}
+
+/**
+ * 같은 도메인 + 세션이고 **그 방이 지금 이 사람에게 열려 있을 때만** 통과한다.
+ *
+ * 방은 메시지마다 다시 묻는다 — 누가 듣고 있는 동안 세션이 비공개로 바뀔 수 있다. 사람의 대화라
+ * 메시지가 드물고, 공개 방은 조회 하나로 끝난다.
+ */
+export function chatMessageRoomFilter(domainId: string, sessionId: string, room: ChatRoomLookup) {
+  const sameSession = chatMessageFilter(domainId, sessionId)
+  return async (payload: ChatMessagePayload): Promise<boolean> => sameSession(payload) && (await mayHearRoom(room))
+}

package/server/service/chat-message/chat-message-room.test.ts

@@ -0,0 +1,140 @@
+/*
+ * What this guards: a private conversation does not stream to people outside it.
+ *
+ * ADR-0073 decision 2 — an open session is readable by anyone in the domain, a private one by its
+ * participants. The stored path (`chatMessages`) asked that; the live path did not. Subscribing
+ * checked domain membership, the filter matched domain + session, and the resolver redacted by doors
+ * — so anyone in the domain holding a private session's id received its messages as they were
+ * written. Same value, two paths, one of them asking about the room.
+ *
+ * The room is asked on every message, not only when subscribing: a session can be made private
+ * while someone is already listening.
+ */
+import { publishChatMessage } from './chat-message-publish'
+import { chatMessageRoomFilter, mayHearRoom, type ChatRoomLookup } from './chat-message-broadcast'
+import { chatMessageStream, chatRoomLookup } from './chat-message-room'
+
+/** A room whose visibility and membership the test sets — and counts how often it is asked. */
+function room(visibility: string | null | undefined, participant: boolean) {
+  const asked = { visibility: 0, participant: 0 }
+  const lookup: ChatRoomLookup & { set(v: string | null | undefined): void } = {
+    async visibility() {
+      asked.visibility++
+      return visibility
+    },
+    async isParticipant() {
+      asked.participant++
+      return participant
+    },
+    set(v) {
+      visibility = v
+    }
+  }
+  return { lookup, asked }
+}
+
+describe('mayHearRoom — the same rule the stored path reads', () => {
+  it('★ a private room is closed to someone who does not sit in it', async () => {
+    expect(await mayHearRoom(room('private', false).lookup)).toBe(false)
+  })
+
+  it('a private room is open to its participants', async () => {
+    expect(await mayHearRoom(room('private', true).lookup)).toBe(true)
+  })
+
+  it('an open room is open to the domain, and membership is not asked', async () => {
+    const { lookup, asked } = room('open', false)
+    expect(await mayHearRoom(lookup)).toBe(true)
+    expect(asked.participant).toBe(0)
+  })
+
+  it('a session that predates the visibility column reads as open — the stored path reads it so too', async () => {
+    expect(await mayHearRoom(room(null, false).lookup)).toBe(true)
+  })
+
+  it('★ a session this domain does not have is closed, not open', async () => {
+    expect(await mayHearRoom(room(undefined, true).lookup)).toBe(false)
+  })
+})
+
+describe('chatMessageRoomFilter', () => {
+  const payload = (over: any = {}) => ({ domainId: 'd1', sessionId: 's1', message: { id: 'm1' } as any, ...over })
+
+  it('another domain or another session never passes, and the room is not asked', async () => {
+    const { lookup, asked } = room('open', true)
+    const pass = chatMessageRoomFilter('d1', 's1', lookup)
+
+    expect(await pass(payload({ domainId: 'd2' }))).toBe(false)
+    expect(await pass(payload({ sessionId: 's2' }))).toBe(false)
+    expect(asked.visibility).toBe(0)
+  })
+
+  it('★ the room is asked again for every message — a session made private mid-stream stops streaming', async () => {
+    const { lookup } = room('open', false)
+    const pass = chatMessageRoomFilter('d1', 's1', lookup)
+
+    expect(await pass(payload())).toBe(true)
+    lookup.set('private')
+    expect(await pass(payload())).toBe(false)
+  })
+})
+
+describe('chatRoomLookup — both questions stay inside the caller\'s domain', () => {
+  function repos(session: any, participant: any) {
+    const seen: any[] = []
+    const make = (row: any) => ({
+      findOne: async (options: any) => {
+        seen.push(options.where)
+        return row
+      }
+    })
+    return { deps: { sessions: make(session), participants: make(participant) }, seen }
+  }
+
+  it('★ the session and the seat are both looked up with the domain', async () => {
+    const { deps, seen } = repos({ id: 's1', visibility: 'private' }, { id: 'p1' })
+    const lookup = chatRoomLookup(deps, { domainId: 'd1', sessionId: 's1', userId: 'u1' })
+
+    expect(await lookup.visibility()).toBe('private')
+    expect(await lookup.isParticipant()).toBe(true)
+    expect(seen[0]).toEqual({ id: 's1', domain: { id: 'd1' } })
+    expect(seen[1]).toEqual({ session: { id: 's1' }, user: { id: 'u1' }, domain: { id: 'd1' } })
+  })
+
+  it('no session in this domain answers undefined — the rule reads that as closed', async () => {
+    const { deps } = repos(null, null)
+    expect(await chatRoomLookup(deps, { domainId: 'd1', sessionId: 's1', userId: 'u1' }).visibility()).toBeUndefined()
+  })
+
+  it('a caller with no user sits nowhere', async () => {
+    const { deps, seen } = repos({ id: 's1', visibility: 'private' }, { id: 'p1' })
+    expect(await chatRoomLookup(deps, { domainId: 'd1', sessionId: 's1', userId: undefined }).isParticipant()).toBe(false)
+    expect(seen).toEqual([])
+  })
+})
+
+describe('the live stream the subscription returns', () => {
+  function nextOrTimeout(it: AsyncIterator<any>, ms = 300): Promise<any> {
+    return Promise.race([it.next().then(r => r.value), new Promise(resolve => setTimeout(() => resolve('TIMEOUT'), ms))])
+  }
+
+  it('★ someone outside a private room does not receive what is said in it', async () => {
+    const it = chatMessageStream('d1', 's-private', room('private', false).lookup)[Symbol.asyncIterator]()
+    const next = nextOrTimeout(it)
+
+    publishChatMessage({ domainId: 'd1', sessionId: 's-private', message: { id: 'm1', role: 'user', content: 'not for you' } as any })
+
+    expect(await next).toBe('TIMEOUT')
+    await it.return?.()
+  })
+
+  it('a participant does', async () => {
+    const it = chatMessageStream('d1', 's-private', room('private', true).lookup)[Symbol.asyncIterator]()
+    const next = nextOrTimeout(it)
+
+    publishChatMessage({ domainId: 'd1', sessionId: 's-private', message: { id: 'm2', role: 'user', content: 'for you' } as any })
+
+    expect((await next)?.message?.id).toBe('m2')
+    await it.return?.()
+  })
+})

package/server/service/chat-message/chat-message-room.ts

@@ -0,0 +1,45 @@
+/*
+ * 방송 길의 방 — 구독이 돌려주는 스트림과, 방을 묻는 두 조회.
+ *
+ * 구독 리졸버는 파라미터 데코레이터(@Root · @Arg) 때문에 jest 가 못 읽는다. 그래서 스트림을 짜는 일을
+ * 여기로 뺐다 — 시험이 리졸버가 돌려주는 것과 **같은 것**을 돌린다(`chat-message-room.test.ts`).
+ *
+ * 저장소는 부르는 쪽이 넘긴다. 엔티티를 여기서 import 하면 이 파일도 시험에서 못 읽는다.
+ */
+import { filter, pipe } from 'graphql-yoga'
+import { pubsub } from '@things-factory/shell'
+
+import { CHAT_MESSAGE_TOPIC, chatMessageRoomFilter, type ChatRoomLookup } from './chat-message-broadcast.js'
+
+interface FindOne {
+  findOne(options: { where: any; select?: any }): Promise<any>
+}
+
+/**
+ * 방을 묻는 두 조회. **둘 다 부르는 사람의 도메인 안에서** 찾는다 — 저장된 길(`chatMessages`)의 질의와
+ * 같은 조건이다.
+ */
+export function chatRoomLookup(
+  repos: { sessions: FindOne; participants: FindOne },
+  who: { domainId: string; sessionId: string; userId?: string }
+): ChatRoomLookup {
+  return {
+    async visibility() {
+      const session = await repos.sessions.findOne({ where: { id: who.sessionId, domain: { id: who.domainId } } })
+      return session ? ((session as any).visibility ?? null) : undefined
+    },
+
+    async isParticipant() {
+      if (!who.userId) return false
+      const seat = await repos.participants.findOne({
+        where: { session: { id: who.sessionId }, user: { id: who.userId }, domain: { id: who.domainId } }
+      })
+      return !!seat
+    }
+  }
+}
+
+/** 구독이 돌려주는 스트림 — 같은 도메인 + 세션이고, 그 방이 메시지마다 이 사람에게 열려 있을 때만. */
+export function chatMessageStream(domainId: string, sessionId: string, room: ChatRoomLookup) {
+  return pipe(pubsub.subscribe(CHAT_MESSAGE_TOPIC), filter(chatMessageRoomFilter(domainId, sessionId, room)))
+}

package/server/service/chat-message/chat-message-subscription.ts

@@ -14,11 +14,12 @@
  * 순수 로직(토픽/필터)은 chat-message-broadcast.ts (테스트 가능). 여기엔 pubsub 의존만.
  */
 import { Resolver, Subscription, Root, Arg, Ctx } from 'type-graphql'
-import { filter, pipe } from 'graphql-yoga'
-import { pubsub } from '@things-factory/shell'
+import { assertDomainSubscribeAllowed, getRepository } from '@things-factory/shell'
 import { ChatMessage } from './chat-message.js'
-import { CHAT_MESSAGE_TOPIC, chatMessageFilter, type ChatMessagePayload } from './chat-message-broadcast.js'
-import { assertDomainSubscribeAllowed } from '../subscribe-auth.js'
+import { ChatSession } from '../chat-session/chat-session.js'
+import { ChatSessionParticipant } from '../chat-session-participant/chat-session-participant.js'
+import { mayHearRoom, type ChatMessagePayload } from './chat-message-broadcast.js'
+import { chatMessageStream, chatRoomLookup } from './chat-message-room.js'
 import { readerGate } from './reader-gate.js'
 
 // publishChatMessage 는 데코레이터 없는 chat-message-publish.ts 에 분리 (테스트 import 가능).
@@ -43,7 +44,21 @@ export class ChatMessageSubscription {
 
       await assertDomainSubscribeAllowed(domain, user, (d, u) => process.superUserGranted(d, u))
 
-      return pipe(pubsub.subscribe(CHAT_MESSAGE_TOPIC), filter(chatMessageFilter(domain.id, sessionId)))
+      /*
+       * **방을 묻는다** — ADR-0073 결정 2. 공개 방은 도메인 안 누구나, 비공개 방은 참여자만. 저장된 길
+       * (`chatMessages`)은 이것을 물었고 방송 길은 묻지 않아, 비공개 세션의 id 를 가진 도메인 안 누구나
+       * 그 대화를 실시간으로 받았다.
+       *
+       * 못 들어오는 방은 빈 스트림을 주지 않고 거절한다. 없는 세션과 같은 말이다 — 비공개 방이 있다는
+       * 사실도 알려 주지 않는다. 구독이 선 뒤에도 방은 메시지마다 다시 묻는다(`chatMessageRoomFilter`).
+       */
+      const room = chatRoomLookup(
+        { sessions: getRepository(ChatSession), participants: getRepository(ChatSessionParticipant) },
+        { domainId: domain.id, sessionId, userId: user?.id }
+      )
+      if (!(await mayHearRoom(room))) throw new Error('chat session not found')
+
+      return chatMessageStream(domain.id, sessionId, room)
     }
   })
   /*

package/server/service/chat-session/session-activity-subscription.ts

@@ -8,10 +8,9 @@
  */
 import { Resolver, Subscription, Root, ObjectType, Field } from 'type-graphql'
 import { filter, pipe } from 'graphql-yoga'
-import { pubsub } from '@things-factory/shell'
+import { assertDomainSubscribeAllowed, pubsub } from '@things-factory/shell'
 
 import { SESSION_ACTIVITY_TOPIC, sessionActivityFilter, type SessionActivityPayload } from './session-activity-broadcast.js'
-import { assertDomainSubscribeAllowed } from '../subscribe-auth.js'
 
 export { publishSessionActivity } from './session-activity-publish.js'
 

package/server/service/index.ts

@@ -21,7 +21,6 @@ export * from './assistant-capability-resolver.js'
 export * from './tool-access.js'
 /* 무엇이 근거인가 — 도구 결과 밖의 셋(프롬프트 · 대화 · 화면 스냅숏). */
 export * from './grounding-sources.js'
-export * from './subscribe-auth.js'
 /* 앵커 순수 로직 — 호스트가 앵커 종류를 참조한다(리졸버는 데코레이터 때문에 무겁다). */
 export * from './chat-session/session-anchor.js'
 /* Who may read a conversation — one rule, also asked by doors outside this package (board-ai's revertPatch). */

package/server/tool-registry-boot-report.test.ts

@@ -1,16 +1,24 @@
+/*
+ * The boot report prints what registered but is not yet what the contracts require.
+ *
+ * It also asks the schema, through AUTH's field table, whether a door a tool names exists. That
+ * import is why this suite did not load from 2026-09-18 (`0c3a8ac939`) until 2026-09-24: the
+ * package root of auth-base brings shell and its ORM configuration with it, and jest has no module
+ * list to give that configuration. The table is a function of one field name, so it is stood in
+ * here — the door report has its own tests (`door-declaration-report.test.ts`).
+ */
 jest.mock('@things-factory/env', () => ({ logger: { warn: jest.fn() } }))
+jest.mock('@things-factory/auth-base', () => ({ privilegeOfField: () => ({ known: false }) }))
 
 import { formatToolRegistryWarnings } from './tool-registry-boot-report'
 
 it('★ groups the recorded omissions by code and names every tool', () => {
   const lines = formatToolRegistryWarnings([
-    { code: 'tool-privilege-undeclared', params: { category: 'twin-authoring', tool: 'bindTwinEntity', kind: 'write' }, message: '' },
-    { code: 'tool-privilege-undeclared', params: { category: 'x-ops', tool: 'runThing', kind: 'external' }, message: '' }
+    { code: 'tool-doors-undeclared', params: { category: 'twin-authoring', tool: 'getOpenScene', kind: 'read' }, message: '' },
+    { code: 'tool-doors-undeclared', params: { category: 'x-ops', tool: 'runThing', kind: 'external' }, message: '' }
   ])
 
-  expect(lines).toEqual([
-    '[ai-assistant] tool-privilege-undeclared ×2: twin-authoring/bindTwinEntity(write), x-ops/runThing(external)'
-  ])
+  expect(lines).toEqual(['[ai-assistant] tool-doors-undeclared ×2: twin-authoring/getOpenScene(read), x-ops/runThing(external)'])
 })
 
 it('says nothing when every tool is declared', () => {

package/dist-server/service/subscribe-auth.d.ts

@@ -1,14 +0,0 @@
-/**
- * 구독 허용 여부 단언. 불가 시 throw (graphql-ws 가 구독 거부).
- * - domain 없음 → 거부.
- * - user 가 해당 subdomain 의 도메인 소속이 아니고 superUser 도 아니면 → 거부.
- *
- * 주의(버그 수정): process.superUserGranted 는 async(Promise<boolean>) 다. 기존 양쪽 spine 은
- * `!process.superUserGranted(...)` 로 동기 평가해 `!Promise` = 항상 false → membership throw 가
- * 발동하지 않는 fail-open 상태였다. 여기서는 await 로 제대로 평가한다 → subscribe 는 async.
- *
- * @param domain  context.state.domain
- * @param user    context.state.user (domains[] / email 사용)
- * @param isSuperUser  (domain, user) → boolean | Promise<boolean> (process.superUserGranted 주입)
- */
-export declare function assertDomainSubscribeAllowed(domain: any, user: any, isSuperUser: (domain: any, user: any) => boolean | Promise<boolean>): Promise<void>;

package/dist-server/service/subscribe-auth.js

@@ -1,33 +0,0 @@
-"use strict";
-/*
- * 구독 도메인 인증 게이트 — 순수 로직 (데코레이터·pubsub 없음 → 테스트 가능).
- *
- * 실시간 구독(@Subscription)은 같은 도메인 구성원만 허용해야 한다(도메인 격리 = 보안 핵심).
- * 이 게이트는 board-patch / chat-message 양쪽 spine 의 subscribe 클로저가 공유한다
- * (reuse — fork 금지). superUserGranted 는 process 전역 의존이라 주입받아 순수성 유지.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertDomainSubscribeAllowed = assertDomainSubscribeAllowed;
-/**
- * 구독 허용 여부 단언. 불가 시 throw (graphql-ws 가 구독 거부).
- * - domain 없음 → 거부.
- * - user 가 해당 subdomain 의 도메인 소속이 아니고 superUser 도 아니면 → 거부.
- *
- * 주의(버그 수정): process.superUserGranted 는 async(Promise<boolean>) 다. 기존 양쪽 spine 은
- * `!process.superUserGranted(...)` 로 동기 평가해 `!Promise` = 항상 false → membership throw 가
- * 발동하지 않는 fail-open 상태였다. 여기서는 await 로 제대로 평가한다 → subscribe 는 async.
- *
- * @param domain  context.state.domain
- * @param user    context.state.user (domains[] / email 사용)
- * @param isSuperUser  (domain, user) → boolean | Promise<boolean> (process.superUserGranted 주입)
- */
-async function assertDomainSubscribeAllowed(domain, user, isSuperUser) {
-    if (!domain) {
-        throw new Error('domain required');
-    }
-    const subdomain = domain?.subdomain;
-    if (!user?.domains?.find((d) => d.subdomain === subdomain) && !(await isSuperUser(domain, user))) {
-        throw new Error(`domain(${subdomain}) is not working for user(${user?.email}).`);
-    }
-}
-//# sourceMappingURL=subscribe-auth.js.map

package/dist-server/service/subscribe-auth.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"subscribe-auth.js","sourceRoot":"","sources":["../../server/service/subscribe-auth.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;AAeH,oEAYC;AAzBD;;;;;;;;;;;;GAYG;AACI,KAAK,UAAU,4BAA4B,CAChD,MAAW,EACX,IAAS,EACT,WAAmE;IAEnE,IAAI,CAAC,MAAM,EAAE,CAAC;QACZ,MAAM,IAAI,KAAK,CAAC,iBAAiB,CAAC,CAAA;IACpC,CAAC;IACD,MAAM,SAAS,GAAG,MAAM,EAAE,SAAS,CAAA;IACnC,IAAI,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC,CAAC,SAAS,KAAK,SAAS,CAAC,IAAI,CAAC,CAAC,MAAM,WAAW,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,EAAE,CAAC;QACtG,MAAM,IAAI,KAAK,CAAC,UAAU,SAAS,6BAA6B,IAAI,EAAE,KAAK,IAAI,CAAC,CAAA;IAClF,CAAC;AACH,CAAC","sourcesContent":["/*\n * 구독 도메인 인증 게이트 — 순수 로직 (데코레이터·pubsub 없음 → 테스트 가능).\n *\n * 실시간 구독(@Subscription)은 같은 도메인 구성원만 허용해야 한다(도메인 격리 = 보안 핵심).\n * 이 게이트는 board-patch / chat-message 양쪽 spine 의 subscribe 클로저가 공유한다\n * (reuse — fork 금지). superUserGranted 는 process 전역 의존이라 주입받아 순수성 유지.\n */\n\n/**\n * 구독 허용 여부 단언. 불가 시 throw (graphql-ws 가 구독 거부).\n * - domain 없음 → 거부.\n * - user 가 해당 subdomain 의 도메인 소속이 아니고 superUser 도 아니면 → 거부.\n *\n * 주의(버그 수정): process.superUserGranted 는 async(Promise<boolean>) 다. 기존 양쪽 spine 은\n * `!process.superUserGranted(...)` 로 동기 평가해 `!Promise` = 항상 false → membership throw 가\n * 발동하지 않는 fail-open 상태였다. 여기서는 await 로 제대로 평가한다 → subscribe 는 async.\n *\n * @param domain  context.state.domain\n * @param user    context.state.user (domains[] / email 사용)\n * @param isSuperUser  (domain, user) → boolean | Promise<boolean> (process.superUserGranted 주입)\n */\nexport async function assertDomainSubscribeAllowed(\n  domain: any,\n  user: any,\n  isSuperUser: (domain: any, user: any) => boolean | Promise<boolean>\n): Promise<void> {\n  if (!domain) {\n    throw new Error('domain required')\n  }\n  const subdomain = domain?.subdomain\n  if (!user?.domains?.find((d: any) => d.subdomain === subdomain) && !(await isSuperUser(domain, user))) {\n    throw new Error(`domain(${subdomain}) is not working for user(${user?.email}).`)\n  }\n}\n"]}

package/server/service/subscribe-auth.test.ts

@@ -1,57 +0,0 @@
-/**
- * 구독 도메인 인증 게이트 — 단위 테스트 (보안 핵심: 도메인 격리).
- * board-patch / chat-message 양쪽 spine 이 공유하는 게이트.
- *
- * 회귀 방지: process.superUserGranted 는 async 다. 동기 `!process.superUserGranted(...)` 로
- * 평가하면 `!Promise` = 항상 false → membership throw 가 죽는다(fail-open). 게이트는 반드시
- * await 로 평가해야 한다. 아래 superUser 분기 테스트가 그 회귀를 박는다.
- */
-import { assertDomainSubscribeAllowed } from './subscribe-auth'
-
-const never = async () => false // superUser 아님 (async — 실제 process.superUserGranted 와 동일)
-const always = async () => true // superUser (async)
-
-const domain = { id: 'd1', subdomain: 'acme' }
-const userInDomain = { email: 'a@x.io', domains: [{ subdomain: 'acme' }, { subdomain: 'other' }] }
-const userOutDomain = { email: 'b@x.io', domains: [{ subdomain: 'other' }] }
-
-describe('assertDomainSubscribeAllowed (도메인 격리 게이트)', () => {
-  it('domain 없으면 → reject (domain required)', async () => {
-    await expect(assertDomainSubscribeAllowed(undefined, userInDomain, never)).rejects.toThrow('domain required')
-    await expect(assertDomainSubscribeAllowed(null, userInDomain, never)).rejects.toThrow('domain required')
-  })
-
-  it('user 가 해당 subdomain 소속 → 통과 (superUser 검사 불필요)', async () => {
-    await expect(assertDomainSubscribeAllowed(domain, userInDomain, never)).resolves.toBeUndefined()
-  })
-
-  it('user 가 미소속 + superUser 아님 → reject (격리 — 핵심)', async () => {
-    await expect(assertDomainSubscribeAllowed(domain, userOutDomain, never)).rejects.toThrow(
-      'domain(acme) is not working for user(b@x.io).'
-    )
-  })
-
-  it('user 가 미소속이어도 superUser(async resolve true) 면 → 통과 (await 회귀 방지)', async () => {
-    await expect(assertDomainSubscribeAllowed(domain, userOutDomain, always)).resolves.toBeUndefined()
-  })
-
-  it('user.domains 없음 + superUser 아님 → reject', async () => {
-    await expect(assertDomainSubscribeAllowed(domain, { email: 'c@x.io' }, never)).rejects.toThrow(
-      'domain(acme) is not working for user(c@x.io).'
-    )
-  })
-
-  it('user.domains 없음 + superUser → 통과', async () => {
-    await expect(assertDomainSubscribeAllowed(domain, { email: 'c@x.io' }, always)).resolves.toBeUndefined()
-  })
-
-  it('isSuperUser 는 domain+user 를 받아 호출되고 await 된다', async () => {
-    const calls: any[] = []
-    const spy = async (d: any, u: any) => {
-      calls.push([d, u])
-      return true
-    }
-    await assertDomainSubscribeAllowed(domain, userOutDomain, spy)
-    expect(calls).toEqual([[domain, userOutDomain]])
-  })
-})

package/server/service/subscribe-auth.ts

@@ -1,34 +0,0 @@
-/*
- * 구독 도메인 인증 게이트 — 순수 로직 (데코레이터·pubsub 없음 → 테스트 가능).
- *
- * 실시간 구독(@Subscription)은 같은 도메인 구성원만 허용해야 한다(도메인 격리 = 보안 핵심).
- * 이 게이트는 board-patch / chat-message 양쪽 spine 의 subscribe 클로저가 공유한다
- * (reuse — fork 금지). superUserGranted 는 process 전역 의존이라 주입받아 순수성 유지.
- */
-
-/**
- * 구독 허용 여부 단언. 불가 시 throw (graphql-ws 가 구독 거부).
- * - domain 없음 → 거부.
- * - user 가 해당 subdomain 의 도메인 소속이 아니고 superUser 도 아니면 → 거부.
- *
- * 주의(버그 수정): process.superUserGranted 는 async(Promise<boolean>) 다. 기존 양쪽 spine 은
- * `!process.superUserGranted(...)` 로 동기 평가해 `!Promise` = 항상 false → membership throw 가
- * 발동하지 않는 fail-open 상태였다. 여기서는 await 로 제대로 평가한다 → subscribe 는 async.
- *
- * @param domain  context.state.domain
- * @param user    context.state.user (domains[] / email 사용)
- * @param isSuperUser  (domain, user) → boolean | Promise<boolean> (process.superUserGranted 주입)
- */
-export async function assertDomainSubscribeAllowed(
-  domain: any,
-  user: any,
-  isSuperUser: (domain: any, user: any) => boolean | Promise<boolean>
-): Promise<void> {
-  if (!domain) {
-    throw new Error('domain required')
-  }
-  const subdomain = domain?.subdomain
-  if (!user?.domains?.find((d: any) => d.subdomain === subdomain) && !(await isSuperUser(domain, user))) {
-    throw new Error(`domain(${subdomain}) is not working for user(${user?.email}).`)
-  }
-}