@things-factory/ai-assistant 10.1.47 → 10.1.52

package/server/service/chat-session/session-inbox.ts

@@ -15,6 +15,8 @@
  * 숫자가 필요해지면 화면에 보이는 세션에 한해 따로 세면 된다. 처음부터 N번 세지 않는다.
  */
 
+import { mayReadSession } from './session-visibility.js'
+
 /** 목록에 필요한 세션 필드(엔티티·typeorm 비의존). */
 export interface InboxSessionRow {
   id?: string
@@ -29,11 +31,15 @@ export interface InboxSessionRow {
   /** 그 미리보기가 지나온 문 — 목록도 같은 관문을 지난다. */
   lastMessageDoors?: string[] | null
   createdAt?: Date | string | null
+  /** 도메인 안 누구나 읽나(`open`) · 참여자만(`private`) — ADR-0073 판정 2. 값이 없으면 open(옛 행). */
+  visibility?: string | null
 }
 
 /** 내 참여 기록(읽은 지점). */
 export interface MyParticipation {
   sessionId?: string
+  /** 이 대화에서 나의 자리 — `owner` 만 공개 범위를 바꾼다. */
+  role?: string | null
   lastReadAt?: Date | string | null
   /** 내 목록에서 숨긴 시각 — 이후 새 활동이 생기면 다시 보인다. */
   hiddenAt?: Date | string | null
@@ -46,6 +52,10 @@ export interface InboxEntry extends InboxSessionRow {
   participant: boolean
   /** 내가 숨긴 대화인가 — 목록에서 빠지지만 필터로 볼 수 있다(되돌리기 가능). */
   hidden?: boolean
+  /** `open` · `private` — 목록이 자물쇠를 그리는 근거. */
+  visibility: string
+  /** 내가 이 대화의 owner 인가 — 공개 범위를 바꿀 수 있는 사람. UI 힌트이고 판정은 문이 다시 한다. */
+  owner: boolean
 }
 
 function time(v: Date | string | null | undefined): number {
@@ -68,23 +78,33 @@ function time(v: Date | string | null | undefined): number {
 export function buildInbox(sessions: InboxSessionRow[], mine: MyParticipation[]): InboxEntry[] {
   const readBy = new Map<string, number>()
   const isParticipant = new Set<string>()
+  const owns = new Set<string>()
   for (const p of mine) {
     if (!p.sessionId) continue
     isParticipant.add(p.sessionId)
     readBy.set(p.sessionId, time(p.lastReadAt))
+    if (p.role === 'owner') owns.add(p.sessionId)
   }
 
-  const entries = sessions.map(session => {
-    const id = session.id ?? ''
-    const activity = time(session.lastMessageAt)
-    const participant = isParticipant.has(id)
-    const read = readBy.get(id) ?? 0
-    return {
-      ...session,
-      participant,
-      unread: participant && activity > 0 && activity > read
-    }
-  })
+  const entries = sessions
+    /*
+     * 남의 비공개 대화는 목록에도 서지 않는다 — ADR-0073 판정 1 의 「읽는 길은 같은 관문을 지난다」.
+     * 메시지 문(`chatMessages`)만 막고 목록이 이름을 내보내면, 대화의 주제가 다른 길로 새어 나간다.
+     */
+    .filter(session => mayReadSession(session.visibility, isParticipant.has(session.id ?? '')))
+    .map(session => {
+      const id = session.id ?? ''
+      const activity = time(session.lastMessageAt)
+      const participant = isParticipant.has(id)
+      const read = readBy.get(id) ?? 0
+      return {
+        ...session,
+        participant,
+        visibility: session.visibility ?? 'open',
+        owner: owns.has(id),
+        unread: participant && activity > 0 && activity > read
+      }
+    })
 
   return entries.sort(
     (a, b) => (time(b.lastMessageAt) || time(b.createdAt)) - (time(a.lastMessageAt) || time(a.createdAt))
@@ -121,6 +141,36 @@ export function applyHidden(entries: InboxEntry[], hiddenAt: Map<string, Date |
  * **상한을 두고** 가져오고(아래 INBOX_SCAN_CAP) 걸러내기·정렬·페이지는 여기서 한다.
  * 상한을 넘으면 잘렸다는 사실을 그대로 알린다(조용히 일부만 보여주지 않는다).
  */
+/** What the conversation list is narrowed by - the manager's filters (design/ai/shared-dock.md §2-6). */
+export interface InboxFilter {
+  /** Only this conversation kind (mode). Absent: every kind on the anchor. */
+  kind?: string | null
+  /** Only the ones I started. */
+  mineOnly?: boolean | null
+  /** Only the ones I am in (owner or member). */
+  participantOnly?: boolean | null
+  /** Only 'open' or only 'private'. */
+  visibility?: string | null
+  /** Only the ones with activity I have not read. */
+  unreadOnly?: boolean | null
+}
+
+/**
+ * Narrow the list. Pure - the resolver builds the entries (with the reader's gate already applied) and
+ * this decides only what the person asked to see. A session from before the kind column has no kind:
+ * it is shown under every kind, so it is never lost from the list it was started in.
+ */
+export function filterInbox<T extends InboxEntry & { mine?: boolean }>(entries: T[], filter: InboxFilter = {}): T[] {
+  return entries.filter(entry => {
+    if (filter.kind && entry.kind && entry.kind !== filter.kind) return false
+    if (filter.mineOnly && !entry.mine) return false
+    if (filter.participantOnly && !entry.participant) return false
+    if (filter.visibility && (entry.visibility ?? 'open') !== filter.visibility) return false
+    if (filter.unreadOnly && !entry.unread) return false
+    return true
+  })
+}
+
 export function searchInbox(entries: InboxEntry[], search?: string): InboxEntry[] {
   const q = (search ?? '').trim().toLowerCase()
   if (!q) return entries

package/server/service/chat-session/session-purge.test.ts

@@ -0,0 +1,24 @@
+/* When a deleted conversation is emptied - design/ai/shared-dock.md §9-5. */
+
+import { DEFAULT_RETENTION_DAYS, purgeCutoff, retentionDaysOf } from './session-retention'
+
+describe('retention', () => {
+  it('defaults to 30 days, and reads a positive number of days', () => {
+    expect(DEFAULT_RETENTION_DAYS).toBe(30)
+    expect(retentionDaysOf(undefined)).toBe(30)
+    expect(retentionDaysOf('x')).toBe(30)
+    expect(retentionDaysOf(7)).toBe(7)
+    expect(retentionDaysOf('14')).toBe(14)
+  })
+
+  it('0 or false turns the job off', () => {
+    expect(retentionDaysOf(0)).toBeNull()
+    expect(retentionDaysOf(false)).toBeNull()
+    expect(retentionDaysOf('0')).toBeNull()
+  })
+
+  it('a conversation is due once its deletion is older than the retention', () => {
+    const now = new Date('2026-09-25T00:00:00Z')
+    expect(purgeCutoff(now, 30).toISOString()).toBe('2026-08-26T00:00:00.000Z')
+  })
+})

package/server/service/chat-session/session-purge.ts

@@ -0,0 +1,81 @@
+/*
+ * Emptying deleted conversations after they have been kept long enough - design/ai/shared-dock.md §9-5.
+ *
+ * `deleteAISession` is a soft delete: from that moment nobody can open the conversation or its files
+ * (every door checks the session), and within the retention period it can still be brought back whole.
+ * Nothing ever emptied them afterwards, so a deleted conversation's messages - and now its files - stayed
+ * forever (2026-09-25). This job removes a conversation, its messages, its participants and its attached
+ * files together once the retention period has passed.
+ *
+ * Retention: config `ai-assistant.sessionRetentionDays`, default 30. `0` or `false` turns the job off.
+ */
+import { config } from '@things-factory/env'
+import { getRepository } from '@things-factory/shell'
+import { In, IsNull, LessThan, Not } from 'typeorm'
+
+import { ChatMessage } from '../chat-message/chat-message.js'
+import { ChatSessionParticipant } from '../chat-session-participant/chat-session-participant.js'
+import { ChatSession } from './chat-session.js'
+import { removeSessionFiles } from './session-attachments.js'
+
+import { DAY_MS, purgeCutoff, retentionDaysOf } from './session-retention.js'
+
+export { DEFAULT_RETENTION_DAYS, purgeCutoff, retentionDaysOf } from './session-retention.js'
+/** How many conversations one run empties - a large backlog is worked off over several runs. */
+export const PURGE_BATCH = 100
+
+export interface PurgeResult {
+  purged: number
+  failed: { sessionId: string; message: string }[]
+}
+
+/** Empties the conversations whose deletion is older than the retention period. */
+export async function purgeDeletedSessions(now = new Date(), retentionDays = retentionDaysOf(config.get('ai-assistant', {})?.sessionRetentionDays)): Promise<PurgeResult> {
+  const result: PurgeResult = { purged: 0, failed: [] }
+  if (retentionDays === null) return result
+
+  const sessions = await getRepository(ChatSession).find({
+    where: { deletedAt: LessThan(purgeCutoff(now, retentionDays)) } as any,
+    withDeleted: true,
+    relations: ['domain'],
+    take: PURGE_BATCH
+  })
+
+  for (const session of sessions) {
+    try {
+      await removeSessionFiles(session as any)
+      /* Messages point at each other (parentMessage) - drop the links before the rows. */
+      await getRepository(ChatMessage).update({ session: { id: session.id }, parentMessage: Not(IsNull()) } as any, { parentMessage: null } as any)
+      await getRepository(ChatMessage).delete({ session: { id: session.id } } as any)
+      await getRepository(ChatSessionParticipant).delete({ session: { id: session.id } } as any)
+      /* Board patches and anything else hanging on the session go with it (ON DELETE CASCADE). */
+      await getRepository(ChatSession).delete({ id: In([session.id]) } as any)
+      result.purged++
+    } catch (error) {
+      /* One conversation that cannot be emptied must not stop the rest; it is tried again next run. */
+      result.failed.push({ sessionId: session.id!, message: (error as Error).message })
+    }
+  }
+
+  return result
+}
+
+let timer: ReturnType<typeof setInterval> | undefined
+
+/** Runs the job once a little after boot, then daily. The timer never keeps the process alive. */
+export function schedulePurge(): void {
+  if (timer) return
+  const run = () =>
+    purgeDeletedSessions()
+      .then(({ purged, failed }) => {
+        if (purged || failed.length) console.info(`[ai-assistant] purged ${purged} deleted conversation(s)`, failed.length ? { failed } : '')
+      })
+      .catch(error => console.warn('[ai-assistant] purging deleted conversations failed:', (error as Error).message))
+
+  const first = setTimeout(run, 60 * 1000)
+  first.unref?.()
+  timer = setInterval(run, DAY_MS)
+  timer.unref?.()
+}
+
+process.on('bootstrap-module-start' as any, () => schedulePurge())

package/server/service/chat-session/session-retention.ts

@@ -0,0 +1,17 @@
+/* How long a deleted conversation is kept before it is emptied - pure, tested alone (shared-dock.md §9-5). */
+
+export const DAY_MS = 24 * 60 * 60 * 1000
+export const DEFAULT_RETENTION_DAYS = 30
+
+/** The retention the config asks for: a positive number of days, `null` when the job is off, the default when unreadable. */
+export function retentionDaysOf(value: unknown): number | null {
+  if (value === false || value === 0 || value === '0') return null
+  const days = Number(value)
+  return Number.isFinite(days) && days > 0 ? days : DEFAULT_RETENTION_DAYS
+}
+
+/** Conversations deleted before this moment are due. */
+export function purgeCutoff(now: Date, retentionDays: number): Date {
+  return new Date(now.getTime() - retentionDays * DAY_MS)
+}
+

package/server/service/chat-session/session-visibility.ts

@@ -32,3 +32,14 @@ export function initialVisibility(session: { anchorType?: string | null; copyOf?
 export function mayReadSession(visibility: string | null | undefined, isParticipant: boolean): boolean {
   return (visibility ?? 'open') === 'open' || isParticipant
 }
+
+/**
+ * 이 사람이 이 대화에 **쓸** 수 있나 — 읽을 수 있는 사람만 쓴다.
+ *
+ * 읽는 문(`chatMessages`)과 목록만 막고 쓰는 문을 열어 두면, 비공개 대화의 id 를 가진 사람이 그 안에 말을
+ * 넣을 수 있었다. `assistantChat` 에서는 더 나쁘다 — 답이 그 대화의 이력 위에서 만들어지므로, 읽을 수 없는
+ * 내용이 답으로 새어 나간다(2026-09-24, operato-ecs 두 사람 시험 7번). 쓰는 문도 같은 관문을 지난다.
+ */
+export function mayWriteSession(visibility: string | null | undefined, isParticipant: boolean): boolean {
+  return mayReadSession(visibility, isParticipant)
+}

package/server/service/chat-session/session-write-gate.test.ts

@@ -0,0 +1,53 @@
+/*
+ * The write gate - a private conversation is written by its people only (ADR-0073 decision 1, for writing).
+ * Reproduces operato-ecs two-person test step 7 (2026-09-24): an outsider wrote into a private conversation
+ * by its id, and through assistantChat the answer would be built on that private history.
+ */
+import { assertMayWriteSession } from './session-write-gate'
+import { mayWriteSession } from './session-visibility'
+import { isRoomRole } from '../chat-session-participant/participant-lookup-roles'
+
+const t = (_key: string, options?: any) => options?.defaultValue ?? _key
+
+describe('who may write into a conversation', () => {
+  it('anyone in the domain writes into a public one - no lookup', async () => {
+    let asked = false
+    await expect(
+      assertMayWriteSession({ session: { visibility: 'open' }, userId: 'bob', isParticipant: async () => ((asked = true), false), t })
+    ).resolves.toBeUndefined()
+    expect(asked).toBe(false)
+  })
+
+  it('a row from before the visibility column is public', async () => {
+    await expect(assertMayWriteSession({ session: {}, userId: 'bob', isParticipant: async () => false, t })).resolves.toBeUndefined()
+  })
+
+  it('★ an outsider is refused on a private one, by a sentence that says what to do', async () => {
+    await expect(
+      assertMayWriteSession({ session: { visibility: 'private' }, userId: 'bob', isParticipant: async () => false, t })
+    ).rejects.toThrow(/private - only the people in it can write here/)
+  })
+
+  it('a participant writes into a private one', async () => {
+    await expect(
+      assertMayWriteSession({ session: { visibility: 'private' }, userId: 'alice', isParticipant: async () => true, t })
+    ).resolves.toBeUndefined()
+  })
+
+  it('no user is no participant', async () => {
+    await expect(assertMayWriteSession({ session: { visibility: 'private' }, isParticipant: async () => true, t })).rejects.toThrow()
+  })
+
+  it('the write rule is the read rule', () => {
+    expect(mayWriteSession('open', false)).toBe(true)
+    expect(mayWriteSession('private', false)).toBe(false)
+    expect(mayWriteSession('private', true)).toBe(true)
+  })
+
+  it('★ a hide-only viewer row is not being in the room', () => {
+    expect(isRoomRole('owner')).toBe(true)
+    expect(isRoomRole('member')).toBe(true)
+    expect(isRoomRole('viewer')).toBe(false)
+    expect(isRoomRole(undefined)).toBe(false)
+  })
+})

package/server/service/chat-session/session-write-gate.ts

@@ -0,0 +1,31 @@
+/*
+ * The gate every door that writes into a conversation passes - ADR-0073 decision 1, applied to writing.
+ *
+ * `mayWriteSession` is the rule; this looks up only what the rule needs (whether the writer is in the
+ * room, and only for a private conversation) and refuses by a named message. Kept apart from the resolvers
+ * so the five write doors call one line and cannot drift.
+ */
+import { mayWriteSession } from './session-visibility.js'
+
+export interface WriteGateInput {
+  session: { id?: string; visibility?: string | null }
+  userId?: string
+  /** Is this user a participant of the session (owner or member)? Asked only for a private one. */
+  isParticipant: () => Promise<boolean>
+  t: (key: string, options?: Record<string, unknown>) => string
+}
+
+export async function assertMayWriteSession({ session, userId, isParticipant, t }: WriteGateInput): Promise<void> {
+  const visibility = session.visibility ?? 'open'
+  /* A public conversation is open to everyone in the domain - no lookup. */
+  if (visibility === 'open') return
+
+  const participant = !!userId && (await isParticipant())
+  if (!mayWriteSession(visibility, participant)) {
+    throw new Error(
+      t('ai-assistant.text.private-session-refused', {
+        defaultValue: 'this conversation is private - only the people in it can write here. ask one of them to bring you in.'
+      })
+    )
+  }
+}

package/server/service/chat-session-participant/invite-notification.test.ts

@@ -28,3 +28,18 @@ describe('buildInviteNotification — 협업 초대 알림 payload', () => {
     expect(buildInviteNotification(['u1'], undefined, { name: 'Kim' })!.url).toBeUndefined()
   })
 })
+
+describe('an invite outside a board', () => {
+  it('does not call it a board', () => {
+    const p = buildInviteNotification(['u1'], undefined, { name: 'Kim' }, 'press-plc down')!
+    expect(p.type).toBe('chat-invite')
+    expect(p.title).toBe('Conversation invite')
+    expect(p.title).not.toMatch(/board/i)
+    expect(p.body).toContain('press-plc down')
+    expect(p.url).toBeUndefined()
+  })
+
+  it('says a conversation when it has no name yet', () => {
+    expect(buildInviteNotification(['u1'], undefined, { name: 'Kim' })!.body).toBe('Kim brought you into a conversation.')
+  })
+})

package/server/service/chat-session-participant/invite-notification.ts

@@ -30,19 +30,37 @@ export interface Inviter {
 export function buildInviteNotification(
   userIds: string[],
   boardId: string | undefined,
-  inviter: Inviter | undefined | null
+  inviter: Inviter | undefined | null,
+  sessionName?: string | null
 ): InviteNotification | null {
   if (!Array.isArray(userIds) || userIds.length === 0) return null
 
   const who = inviter?.name || inviter?.email || 'someone'
+
+  /* A board conversation keeps its board wording and the link to the modeller. */
+  if (boardId) {
+    return {
+      receivers: userIds,
+      type: 'board-collab-invite',
+      subject: 'info',
+      title: 'Board collaboration invite',
+      body: `${who} invited you to collaborate on a board.`,
+      url: `board-modeller/${boardId}`,
+      mode: 'background'
+    }
+  }
+
+  /*
+   * Every other conversation is not about a board. Both chat doors called this without one and every
+   * invite read "Board collaboration invite" - in operato-ecs, in plant, anywhere (2026-09-24).
+   */
+  const name = sessionName?.trim()
   return {
     receivers: userIds,
-    type: 'board-collab-invite',
+    type: 'chat-invite',
     subject: 'info',
-    title: 'Board collaboration invite',
-    body: `${who} invited you to collaborate on a board.`,
-    // board 가 연결돼 있으면 모델러로 바로 가는 링크. 없으면 링크 생략.
-    url: boardId ? `board-modeller/${boardId}` : undefined,
+    title: 'Conversation invite',
+    body: name ? `${who} brought you into the conversation "${name}".` : `${who} brought you into a conversation.`,
     mode: 'background'
   }
 }

package/server/service/chat-session-participant/participant-lookup-roles.ts

@@ -0,0 +1,6 @@
+/** Being in the room - owner or member. A `viewer` row only remembers a hide. Pure, so it is tested alone. */
+export const ROOM_ROLES = ['owner', 'member'] as const
+
+export function isRoomRole(role: string | null | undefined): boolean {
+  return (ROOM_ROLES as readonly string[]).includes(role ?? '')
+}

package/server/service/chat-session-participant/participant-lookup.ts

@@ -0,0 +1,22 @@
+/*
+ * Is this user in the room - owner or member?
+ *
+ * A `viewer` row is not being in the room: `hideAISession` writes one to remember a hide for someone who
+ * never took part. Counting it let a person who hid a private conversation by its id read it afterwards -
+ * the hide became the key. Every gate that asks "is this a participant" asks here.
+ */
+import { getRepository } from '@things-factory/shell'
+
+import { ChatSessionParticipant } from './chat-session-participant.js'
+
+import { isRoomRole } from './participant-lookup-roles.js'
+
+export { ROOM_ROLES, isRoomRole } from './participant-lookup-roles.js'
+
+export async function isSessionParticipant(domainId: string, sessionId: string, userId: string | undefined, tx?: any): Promise<boolean> {
+  if (!userId) return false
+  const row = await getRepository(ChatSessionParticipant, tx).findOne({
+    where: { domain: { id: domainId } as any, session: { id: sessionId } as any, user: { id: userId } as any }
+  })
+  return isRoomRole(row?.role)
+}