discord-connector

1import type { EngineInterface, On } from 'claude-code'
2
3import {
4  ASK_TIMEOUT_SECONDS,
5  BACKGROUND_BLOCKED,
6  isBackgroundRequest,
7  NO_ANSWER,
8  formatAskCreateFailure,
9  formatPermissionDenied,
10  formatLogLine,
11  interpretAskWait,
12  LOG_RELATIVE_PATH,
13  neutralizeBotMention,
14  parseAskId,
15  planAskCreate,
16  sendArgv,
17  waitArgv,
18  type Question,
19  type RunContext,
20} from './logic'
21
22const CLI_TIMEOUT_MS = 30_000
23const WAIT_TIMEOUT_MS = 600_000
24
25async function writeLog($: EngineInterface, message: string): Promise<void> {
26  try {
27    const home = await $.env.get('HOME')
28
29    if (!home) {
30      return
31    }
32
33    const path = `${home}/${LOG_RELATIVE_PATH}`
34    const prior = (await $.fs.exists(path)) ? String(await $.fs.read(path)) : ''
35
36    await $.fs.write(path, prior + formatLogLine(await $.clock.now(), message))
37  } catch {
38    // 로그 실패가 원래 흐름을 막으면 안 된다
39  }
40}
41
42async function readContext($: EngineInterface): Promise<RunContext | undefined> {
43  const markers = {
44    DISCORD_CONNECTOR_THREAD_ID: await $.env.get('DISCORD_CONNECTOR_THREAD_ID'),
45    DISCORD_CONNECTOR_REQUESTER_ID: await $.env.get('DISCORD_CONNECTOR_REQUESTER_ID'),
46    DISCORD_CONNECTOR_BOT_ID: await $.env.get('DISCORD_CONNECTOR_BOT_ID'),
47  }
48  const missing = Object.entries(markers)
49    .filter(([, value]) => !value)
50    .map(([name]) => name)
51
52  if (missing.length === Object.keys(markers).length) {
53    return undefined
54  }
55
56  if (missing.length > 0) {
57    await writeLog($, `표식 env 계약 위반 — 없는 값: ${missing.join(', ')}. 개입하지 않아요`)
58
59    return undefined
60  }
61
62  return {
63    threadId: markers.DISCORD_CONNECTOR_THREAD_ID as string,
64    requesterId: markers.DISCORD_CONNECTOR_REQUESTER_ID as string,
65    botId: markers.DISCORD_CONNECTOR_BOT_ID as string,
66  }
67}
68
69async function notify($: EngineInterface, ctx: RunContext, text: string): Promise<void> {
70  try {
71    const sent = await $.process.run(sendArgv(ctx.threadId), {
72      stdin: neutralizeBotMention(text, ctx.botId),
73      timeoutMs: CLI_TIMEOUT_MS,
74    })
75
76    if (sent.exitCode !== 0) {
77      await writeLog($, `알림 전송 실패 (exit ${sent.exitCode}): ${(sent.stderr || sent.stdout).slice(-300)}`)
78    }
79  } catch (err) {
80    await writeLog($, `알림 전송 예외: ${String(err)}`)
81  }
82}
83
84async function askOne($: EngineInterface, ctx: RunContext, q: Question): Promise<string> {
85  const deadlineEpochSec = Math.floor((await $.clock.now()) / 1000) + ASK_TIMEOUT_SECONDS
86  const plan = planAskCreate(q, ctx, deadlineEpochSec)
87
88  if ('error' in plan) {
89    await writeLog($, `질문을 만들 수 없어요: ${plan.error}`)
90    await notify($, ctx, formatAskCreateFailure(plan.error))
91
92    return NO_ANSWER
93  }
94
95  let askId: string | undefined
96  let failure = ''
97
98  try {
99    const created = await $.process.run(plan.argv, { timeoutMs: CLI_TIMEOUT_MS })
100
101    askId = created.exitCode === 0 ? parseAskId(created.stdout) : undefined
102
103    if (askId === undefined) {
104      failure = `exit ${created.exitCode}: ${(created.stdout || created.stderr).slice(-300)}`
105    }
106  } catch (err) {
107    failure = String(err)
108  }
109
110  if (askId === undefined) {
111    await writeLog($, `ask create 실패: ${failure}`)
112    await notify($, ctx, formatAskCreateFailure(failure))
113
114    return NO_ANSWER
115  }
116
117  try {
118    const waited = await $.process.run(waitArgv(askId), { timeoutMs: WAIT_TIMEOUT_MS })
119
120    if (waited.exitCode !== 0) {
121      await writeLog($, `ask wait 비정상 종료 (exit ${waited.exitCode}): ${(waited.stderr || waited.stdout).slice(-300)}`)
122
123      return NO_ANSWER
124    }
125
126    const outcome = interpretAskWait(waited.stdout)
127
128    if ('unanswered' in outcome) {
129      await writeLog($, `ask wait 미응답: ${outcome.unanswered}`)
130
131      return NO_ANSWER
132    }
133
134    return outcome.answer
135  } catch (err) {
136    await writeLog($, `ask wait 예외: ${String(err)}`)
137
138    return NO_ANSWER
139  }
140}
141
142export function register(on: On): void {
143  on('tool.call', { tool: 'AskUserQuestion' }, async ($, e, next) => {
144    const ctx = await readContext($)
145
146    if (ctx === undefined) {
147      return next(e)
148    }
149
150    const answers: Record<string, string> = {}
151
152    for (const q of e.questions) {
153      answers[q.question] = await askOne($, ctx, q)
154    }
155
156    return { result: { questions: e.questions, answers } } as never
157  })
158
159  on('tool.call', { tool: 'Bash' }, async ($, e, next) => {
160    if (!isBackgroundRequest(e) || (await readContext($)) === undefined) {
161      return next(e)
162    }
163
164    await writeLog($, 'Bash 백그라운드 실행을 막았어요')
165
166    return { deny: BACKGROUND_BLOCKED }
167  })
168
169  on('agent.spawn', async ($, e, next) => {
170    if (!isBackgroundRequest({ run_in_background: e.background }) || (await readContext($)) === undefined) {
171      return next(e)
172    }
173
174    await writeLog($, `서브에이전트 백그라운드 실행을 막았어요 (${e.subagentType})`)
175
176    return { deny: BACKGROUND_BLOCKED }
177  })
178
179  on('classic.PermissionDenied', async ($, e, next) => {
180    const ctx = await readContext($)
181
182    if (ctx !== undefined) {
183      await notify($, ctx, formatPermissionDenied(e.tool_name, e.reason))
184    }
185
186    return next(e)
187  })
188}
189

1export const NO_ANSWER = 'Discord에서 시간 안에 답이 없었어요'
2
3export const ASK_TIMEOUT_SECONDS = 540
4
5export type RunContext = {
6  threadId: string
7  requesterId: string
8  botId: string
9}
10
11export type Question = {
12  question: string
13  options: readonly { label: string }[]
14  multiSelect: boolean
15}
16
17const LIMITS = {
18  single: { maxOptions: 4, maxLabel: 80 },
19  multi: { maxOptions: 25, maxLabel: 100 },
20} as const
21
22export function neutralizeBotMention(text: string, botId: string): string {
23  return text.split(`<@${botId}>`).join(`@${botId}`).split(`<@!${botId}>`).join(`@${botId}`)
24}
25
26export function sendArgv(threadId: string): string[] {
27  return ['discord', '--json', 'send', threadId, '-', '--split']
28}
29
30export function waitArgv(askId: string): string[] {
31  return ['discord', '--json', 'ask', 'wait', askId, '--timeout', String(ASK_TIMEOUT_SECONDS)]
32}
33
34export type AskCreatePlan = { argv: string[] } | { error: string }
35
36export function planAskCreate(q: Question, ctx: RunContext, deadlineEpochSec: number): AskCreatePlan {
37  const limit = q.multiSelect ? LIMITS.multi : LIMITS.single
38  const kind = q.multiSelect ? '다중 선택' : '단일 선택'
39
40  if (q.options.length < 1 || q.options.length > limit.maxOptions) {
41    return { error: `${kind} 질문의 선택지는 1~${limit.maxOptions}개여야 해요 (받은 개수: ${q.options.length})` }
42  }
43
44  const tooLong = q.options.find(o => o.label.length > limit.maxLabel)
45
46  if (tooLong !== undefined) {
47    return { error: `${kind} 선택지 라벨은 ${limit.maxLabel}자 이하여야 해요: ${tooLong.label.slice(0, 30)}…` }
48  }
49
50  const body = `${neutralizeBotMention(q.question, ctx.botId)}\n마감 <t:${deadlineEpochSec}:t>`
51  const argv = ['discord', '--json', 'ask', 'create', ctx.threadId, body]
52
53  for (const o of q.options) {
54    argv.push('--option', neutralizeBotMention(o.label, ctx.botId))
55  }
56
57  argv.push('--timeout', String(ASK_TIMEOUT_SECONDS), '--allowed-user', ctx.requesterId)
58
59  if (q.multiSelect) {
60    argv.push('--multi-select')
61  }
62
63  return { argv }
64}
65
66function envelopeData(stdout: string): Record<string, unknown> | undefined {
67  let parsed: unknown
68
69  try {
70    parsed = JSON.parse(stdout)
71  } catch {
72    return undefined
73  }
74
75  if (typeof parsed !== 'object' || parsed === null || (parsed as { ok?: unknown }).ok !== true) {
76    return undefined
77  }
78
79  const data = (parsed as { data?: unknown }).data
80
81  return typeof data === 'object' && data !== null ? (data as Record<string, unknown>) : undefined
82}
83
84export function parseAskId(stdout: string): string | undefined {
85  const id = envelopeData(stdout)?.ask_id
86
87  return typeof id === 'string' && id !== '' ? id : undefined
88}
89
90export type AskWaitOutcome = { answer: string } | { unanswered: string }
91
92export function interpretAskWait(stdout: string): AskWaitOutcome {
93  const data = envelopeData(stdout)
94
95  if (data === undefined) {
96    return { unanswered: `응답이 성공 엔벨로프가 아니에요: ${stdout.slice(-300)}` }
97  }
98
99  if (data.status !== 'answered') {
100    return { unanswered: `상태가 answered 가 아니에요: ${String(data.status)}` }
101  }
102
103  const value = data.value
104
105  if (typeof value === 'string') {
106    return { answer: value }
107  }
108
109  if (Array.isArray(value) && value.every(v => typeof v === 'string')) {
110    return { answer: value.join(', ') }
111  }
112
113  return { unanswered: `answered 인데 value 형식이 달라요: ${JSON.stringify(value)}` }
114}
115
116export const LOG_RELATIVE_PATH = '.areum/discord-connector/logs/hook.log'
117
118export function formatLogLine(epochMs: number, message: string): string {
119  return `${new Date(epochMs).toISOString()} ${message}\n`
120}
121
122export function formatAskCreateFailure(reason: string): string {
123  return `질문을 Discord 에 올리지 못했어요: ${reason}\n질문은 답 없이 넘어가요.`
124}
125
126export function formatPermissionDenied(toolName: string, reason: string): string {
127  return [
128    '자동 모드가 도구 실행을 거부했어요.',
129    `- 도구: ${toolName}`,
130    `- 사유: ${reason}`,
131    '다시 진행하려면 이 스레드에서 봇을 멘션해 재지시해 주세요.',
132  ].join('\n')
133}
134
135export const BACKGROUND_BLOCKED =
136  '이 실행은 Discord 에서 시작돼 턴이 끝나면 종료돼요. 백그라운드 결과는 사용자에게 전달되지 않으니 run_in_background 없이 포그라운드로 다시 실행하세요.'
137
138export function isBackgroundRequest(input: { run_in_background?: unknown }): boolean {
139  return input.run_in_background === true
140}
141