pr-bridge-watch

1import type { EngineInterface, ProcessRunInit, ProcessRunResult, Register, ToolCallResult } from 'claude-code'
2
3import {
4  ARCHIVE_TOOL,
5  archiveTargetOf,
6  headOfCommand,
7  isAutoModeNoVerdict,
8  isDesktopEntrypoint,
9  isLiveWorkRefusal,
10  isPrCreateCommand,
11  isSelfArchive,
12  isStopRequest,
13  pullRefsOf,
14  SEND_MESSAGE_TOOL,
15  statusUrlOf,
16  STOP_REQUEST,
17  watchUrlOf,
18} from './pr-watch.ts'
19
20const DEFAULT_BRIDGE = 'ws://127.0.0.1:8799'
21/** 停止要求を送ってから archive をやり直すまでの待ち */
22export const STOP_REQUEST_WAIT_MS = 3000
23
24/** gitDir: branch の実在を突合する git の共通ディレクトリ。取れなければ null (突合では止めない) */
25type Watch = { pr: string; ref: string; gitDir: string | null; taskId: string | null }
26
27/** engine の口。`$` は変数に持てない (plugin validate が拒否する) ので閉包で持つ */
28type Host = {
29  run: (argv: readonly string[], init?: ProcessRunInit) => Promise<ProcessRunResult>
30  taskStop: (taskId: string) => Promise<ToolCallResult>
31  log: (text: string) => void
32}
33
34function hostOf($: EngineInterface): Host {
35  return {
36    run: (argv, init) => $.process.run(argv, init),
37    taskStop: taskId => $.tool.call({ tool: 'TaskStop', task_id: taskId } as Parameters<typeof $.tool.call>[0]),
38    log: text => $.ui.log(text),
39  }
40}
41
42/**
43 * PR を作る Bash (`gh pr create` / pr-push.sh) を包み、成功して PR の URL が出たら
44 * その branch の CI を gh-actions-bridge の `ws /watch?repo=…&ref=…` に Monitor で繋ぐ。
45 *
46 * bridge は systemd --user の常駐 1 本 (CLAUDE.md)。ここでは起動も kill もしない。
47 * 繋げなかったとき (bridge が落ちている / Monitor が拒否された) は、model への context に
48 * 自分で張る Monitor の引数を書いて返す — 見張りが黙って欠けるより model に拾わせる。
49 * 例外は model が従えない 2 つで、どちらも 1 行の事実だけを返す:
50 * - Claude desktop (Code タブ): app 側が PR の CI を監視するので、張ろうとしない
51 * - auto mode: hook の発した Monitor に分類器が判定を返さない。model に張らせても同じなので頼まない
52 *
53 * `ref` の /watch は bridge が閉じず、persistent な Monitor は `archive_session` を
54 * 「still has live work」で断らせる。止めどきは次の 3 つ:
55 * - Actions の通知 (task-notification) が来るたびに全部の見張りを突合し、local の branch が
56 *   消えていたら TaskStop (PR は親が作る → 子の archive + worktree-janitor で branch が消える → 親の見張りが止まる)
57 * - このセッション自身を archive する直前に全部止める
58 * - 他のセッションの archive が live work で断られたら、相手へ停止要求を send_message して 1 回やり直す。
59 *   受けた側は session.receive / prompt.submit で要求を飲み込み (turn を起こさない)、全部止める
60 */
61export const register: Register = (on, options) => {
62  const bridge = typeof options.bridgeUrl === 'string' && options.bridgeUrl !== '' ? options.bridgeUrl : DEFAULT_BRIDGE
63  // repo#ref → 見張り。同じセッションで同じ branch を二重に見張らない (pr-push.sh の再実行・PR の作り直し)
64  const watches = new Map<string, Watch>()
65  let reconciling = false
66
67  const stopWatch = async (host: Host, key: string, why: string) => {
68    const w = watches.get(key)
69    if (w === undefined) return
70    watches.delete(key)
71    if (w.taskId === null) return
72    try {
73      const r = await host.taskStop(w.taskId)
74      const failed = r.deny ?? (r.isError ? r.text : undefined)
75      host.log(
76        failed === undefined
77          ? `pr-bridge-watch: ${w.pr} ${why} → Monitor (task ${w.taskId}) を止めた`
78          : `pr-bridge-watch: ${w.pr} ${why} → Monitor (task ${w.taskId}) を止められなかった (${failed})`,
79      )
80    } catch (err) {
81      host.log(`pr-bridge-watch: ${w.pr} ${why} → Monitor (task ${w.taskId}) を止められなかった (${String(err)})`)
82    }
83  }
84
85  const stopAll = (host: Host, why: string) => Promise.all([...watches.keys()].map(key => stopWatch(host, key, why)))
86
87  /** 全部の見張りを local の branch と突合し、消えた branch の Monitor を止める */
88  const reconcile = async (host: Host) => {
89    if (reconciling) return
90    reconciling = true
91    try {
92      for (const [key, w] of [...watches]) {
93        if (w.gitDir === null) continue
94        if ((await branchExists(host, w.gitDir, w.ref)) === false) await stopWatch(host, key, `の branch ${w.ref} が local に無い`)
95      }
96    } finally {
97      reconciling = false
98    }
99  }
100
101  // Actions の通知 (Monitor の event) が来たら突合する。通知そのものは素通し
102  on('prompt.submit', async ($, e, next) => {
103    if (isStopRequest(e.text)) {
104      await stopAll(hostOf($), 'のセッションに archive の停止要求が来た')
105      return { drop: 'pr-bridge-watch: archive の停止要求を受けて Monitor を止めた' }
106    }
107    if (e.origin.kind === 'task-notification' && watches.size > 0) void reconcile(hostOf($))
108    return next(e)
109  })
110
111  // 他のセッションの send_message は queue に入る前にここを通る。停止要求なら turn を起こさずに飲み込む
112  on('session.receive', async ($, e, next) => {
113    if (!isStopRequest(e.text)) return next(e)
114    await stopAll(hostOf($), 'のセッションに archive の停止要求が来た')
115    return { consumed: 'pr-bridge-watch: archive の停止要求を受けて Monitor を止めた' }
116  })
117
118  on('tool.call', async ($, e, next) => {
119    const input = e as { session_id?: unknown; reason?: unknown }
120    if (isSelfArchive(e.tool, input)) {
121      if (watches.size > 0) await stopAll(hostOf($), 'のセッションを archive する')
122      return next(e)
123    }
124    const target = archiveTargetOf(e.tool, input)
125    if (target === null) return next(e)
126
127    const result = await next(e)
128    if (!result.isError || !isLiveWorkRefusal(result.text ?? String(result.result ?? ''))) return result
129    try {
130      // ccd の MCP tool は /plugin-types を打った環境によって型に載らないので unknown 経由
131      const sent = await $.tool.call({ tool: SEND_MESSAGE_TOOL, session_id: target, message: STOP_REQUEST } as unknown as Parameters<
132        typeof $.tool.call
133      >[0])
134      if (sent.deny !== undefined || sent.isError) return result
135      await $.clock.sleep(STOP_REQUEST_WAIT_MS, { signal: next.signal })
136      const retried = await $.tool.call({
137        tool: ARCHIVE_TOOL,
138        session_id: target,
139        ...(typeof input.reason === 'string' ? { reason: input.reason } : {}),
140      } as unknown as Parameters<typeof $.tool.call>[0])
141      const note = retried.isError
142        ? 'pr-bridge-watch: live work で断られたので相手に Monitor の停止要求を送り 1 回やり直したが、まだ畳めない'
143        : 'pr-bridge-watch: live work で断られたので相手に Monitor の停止要求を送り、やり直して畳めた'
144      return { ...retried, context: [...(retried.context ?? []), note] } as ToolCallResult
145    } catch {
146      return result
147    }
148  })
149
150  on('tool.call', { tool: 'Bash' }, async ($, e, next) => {
151    if (!isPrCreateCommand(e.command)) return next(e)
152
153    const result = await next(e)
154    if (result.deny !== undefined || result.isError) return result
155
156    const prs = pullRefsOf(result.text ?? '')
157    if (prs.length === 0) return result
158    if (await isDesktop($)) {
159      const note = `pr-bridge-watch: Claude desktop では app が PR の CI を監視するので bridge に Monitor を張らない (${prs.map(pr => pr.url).join(' ')})`
160      return { ...result, context: [...(result.context ?? []), note] }
161    }
162
163    const host = hostOf($)
164    const notes: string[] = []
165    for (const pr of prs) {
166      const ref = (await headRefOf(host, pr.url)) ?? headOfCommand(e.command)
167      if (ref === null) {
168        notes.push(`pr-bridge-watch: ${pr.url} の branch が分からず bridge に繋いでいない`)
169        continue
170      }
171      const key = `${pr.repo}#${ref}`
172      if (watches.has(key)) continue
173
174      const url = watchUrlOf(bridge, pr.repo, ref)
175      const description = `${pr.repo} PR #${pr.number} CI [${ref}]`
176      const manual = `Monitor({ ws: { url: "${url}" }, description: "${description}", persistent: true, timeout_ms: 3600000 })`
177      const noVerdict = `pr-bridge-watch: auto mode では hook から Monitor を張れない (分類器が判定を返さない)。${pr.url} の CI は PR の監視か gh pr checks で確認する`
178
179      if (!(await isBridgeUp($, bridge))) {
180        notes.push(`pr-bridge-watch: bridge (${statusUrlOf(bridge)}) に届かない。systemctl --user status gh-actions-bridge を確認し、戻ったら ${manual}`)
181        continue
182      }
183      try {
184        const started = await $.tool.call({
185          tool: 'Monitor',
186          description,
187          ws: { url },
188          persistent: true,
189          timeout_ms: 3600000,
190        } as Parameters<typeof $.tool.call>[0])
191        if (started.deny !== undefined || started.isError) {
192          const refused = started.deny ?? started.text
193          notes.push(isAutoModeNoVerdict(refused ?? '') ? noVerdict : `pr-bridge-watch: Monitor を張れなかった (${refused})。自分で ${manual}`)
194          continue
195        }
196        const id = (started.result as { taskId?: unknown } | undefined)?.taskId
197        const taskId = typeof id === 'string' ? id : null
198        const gitDir = await gitDirWithBranch(host, ref)
199        watches.set(key, { pr: pr.url, ref, gitDir, taskId })
200        const stops =
201          taskId === null
202            ? '。task ID が取れず自動では止められない — 要らなくなったら TaskStop すること (残すと archive_session が畳めない)。'
203            : gitDir === null
204              ? ` (task ${taskId})。local に branch ${ref} が見つからず突合では止まらない — 要らなくなったら TaskStop すること (archive 時は自動で止める)。`
205              : ` (task ${taskId})。local の branch が消えたら次の Actions 通知で、archive のときはその前に自動で止める。`
206        notes.push(
207          `pr-bridge-watch: ${pr.url} の CI を bridge の /watch (repo=${pr.repo} ref=${ref}) に Monitor で繋いだ${stops}` +
208            'gh run list で polling しない。通知が来なければ拡張の watch 対象 repos (get-config) を確認',
209        )
210      } catch (err) {
211        notes.push(isAutoModeNoVerdict(String(err)) ? noVerdict : `pr-bridge-watch: Monitor の起動に失敗 (${String(err)})。自分で ${manual}`)
212      }
213    }
214    if (notes.length === 0) return result
215    return { ...result, context: [...(result.context ?? []), ...notes] }
216  })
217}
218
219/** PR の head branch。gh が無い / 失敗したら null (呼び出し側が command の --head に落ちる) */
220async function headRefOf(host: Host, url: string): Promise<string | null> {
221  try {
222    const r = await host.run(['gh', 'pr', 'view', url, '--json', 'headRefName', '--jq', '.headRefName'], { timeoutMs: 15000 })
223    const value = r.stdout.trim()
224    return r.exitCode === 0 && value !== '' ? value : null
225  } catch {
226    return null
227  }
228}
229
230/** セッションの cwd の git 共通ディレクトリ (worktree でも main clone の .git)。そこに branch が在るときだけ返す */
231async function gitDirWithBranch(host: Host, ref: string): Promise<string | null> {
232  try {
233    const r = await host.run(['git', 'rev-parse', '--path-format=absolute', '--git-common-dir'], { timeoutMs: 15000 })
234    const gitDir = r.stdout.trim()
235    if (r.exitCode !== 0 || gitDir === '') return null
236    return (await branchExists(host, gitDir, ref)) === true ? gitDir : null
237  } catch {
238    return null
239  }
240}
241
242/** true: 在る / false: 無い (branch か git dir ごと消えた) / null: git を走らせられなかった (止めない) */
243async function branchExists(host: Host, gitDir: string, ref: string): Promise<boolean | null> {
244  try {
245    const r = await host.run(['git', `--git-dir=${gitDir}`, 'show-ref', '--verify', '--quiet', `refs/heads/${ref}`], {
246      timeoutMs: 15000,
247    })
248    return r.exitCode === 0
249  } catch {
250    return null
251  }
252}
253
254/** 読めなければ desktop ではない扱い (いままでどおり張りに行く) */
255async function isDesktop($: EngineInterface): Promise<boolean> {
256  try {
257    return isDesktopEntrypoint(await $.env.get('CLAUDE_CODE_ENTRYPOINT'))
258  } catch {
259    return false
260  }
261}
262
263async function isBridgeUp($: EngineInterface, bridge: string): Promise<boolean> {
264  try {
265    return (await $.http.fetch(statusUrlOf(bridge))).ok
266  } catch {
267    return false
268  }
269}
270

1// 純粋な判定だけを置く (engine の `$` に触らない)。node --test から直接 import する。
2
3/** PR を作る Bash か。`gh pr create` 直打ちと claude-skills の pr-push.sh */
4export function isPrCreateCommand(command: string): boolean {
5  return /\bgh\s+pr\s+create\b/.test(command) || /\bpr-push(\.sh)?\b/.test(command)
6}
7
8export type PullRef = { repo: string; number: number; url: string }
9
10/** 出力に出た PR の URL (重複は 1 つに畳む) */
11export function pullRefsOf(text: string): PullRef[] {
12  const seen = new Map<string, PullRef>()
13  for (const m of text.matchAll(/https:\/\/github\.com\/([\w.-]+\/[\w.-]+)\/pull\/(\d+)/g)) {
14    const url = m[0]
15    if (!seen.has(url)) seen.set(url, { repo: m[1]!, number: Number(m[2]), url })
16  }
17  return [...seen.values()]
18}
19
20/** `--head X` / `-H X` / `--head=X` を command から拾う (gh pr view が失敗したときの保険) */
21export function headOfCommand(command: string): string | null {
22  const m = command.match(/(?:--head|-H)(?:=|\s+)(["']?)([^\s"']+)\1/)
23  return m ? m[2]! : null
24}
25
26/**
27 * bridge の /watch URL。`ws://127.0.0.1:8799` → `ws://127.0.0.1:8799/watch?repo=…&ref=…`。
28 * ref の 40 文字切りは bridge 側がやる (watch.rs) のでここでは切らない
29 */
30export function watchUrlOf(bridge: string, repo: string, ref: string): string {
31  const base = bridge.replace(/\/+$/, '')
32  return `${base}/watch?repo=${encodeURIComponent(repo)}&ref=${encodeURIComponent(ref)}`
33}
34
35/** bridge の状態 (`GET /`) を叩く http URL */
36export function statusUrlOf(bridge: string): string {
37  return bridge.replace(/^ws(s?):/, 'http$1:').replace(/\/+$/, '') + '/'
38}
39
40/**
41 * Claude desktop (Code タブ) のセッションか。`CLAUDE_CODE_ENTRYPOINT` の値で見る。
42 * desktop は app 側が PR の CI を監視し、model が Monitor で CI を見張ることを禁じているので張らない
43 */
44export function isDesktopEntrypoint(entrypoint: string | undefined): boolean {
45  return entrypoint === 'claude-desktop'
46}
47
48/**
49 * auto mode の分類器が、hook の発した tool 呼び出しに判定を返さなかった拒否か。
50 * `$.tool.call` の戻りに種別の欄は無いので文面で見る (テストで文面を固定している)
51 */
52export function isAutoModeNoVerdict(text: string): boolean {
53  return /auto mode classifier/i.test(text) && /gave no verdict/i.test(text)
54}
55
56export const ARCHIVE_TOOL ='mcp__ccd_session_mgmt__archive_session'
57export const SEND_MESSAGE_TOOL = 'mcp__ccd_session_mgmt__send_message'
58
59/** `archive_session` がこのセッション自身を畳む呼び出しか */
60export function isSelfArchive(tool: string, input: { session_id?: unknown }): boolean {
61  return tool === ARCHIVE_TOOL && input.session_id === 'self'
62}
63
64/** 他のセッションを畳む `archive_session` なら、その session_id */
65export function archiveTargetOf(tool: string, input: { session_id?: unknown }): string | null {
66  return tool === ARCHIVE_TOOL && typeof input.session_id === 'string' && input.session_id !== 'self' ? input.session_id : null
67}
68
69/** archive が「まだ動いている (background task 等)」で断られた応答か。pinned / 画面に開いている等の拒否は含めない */
70export function isLiveWorkRefusal(text: string): boolean {
71  return /was not archived/i.test(text) && /live work|background (task|work)|still working/i.test(text)
72}
73
74/** 相手の pr-bridge-watch が拾って Monitor を全部止める合図 (send_message の本文に入れる) */
75export const STOP_MARKER = '[pr-bridge-watch:stop]'
76
77export const STOP_REQUEST =
78  `${STOP_MARKER} このセッションを archive するので、bridge の /watch に張った Monitor を止めてください。` +
79  'pr-bridge-watch が入っていれば自動で処理され、この文はモデルに届きません。届いた場合は TaskStop で Monitor を止めるだけで、返信は不要です。'
80
81export function isStopRequest(text: string): boolean {
82  return text.includes(STOP_MARKER)
83}
84