@dotlabo/agent-chat-relay 0.1.1 → 0.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/src/core/relay.ts CHANGED
@@ -31,6 +31,8 @@ export type Incoming = ChatMessage & {
31
31
  toOthers?: boolean
32
32
  /** 中継が止まっている間に届いた発言。登録したルームと許可した人の DM のものは記録だけして、エージェントには渡さない */
33
33
  stale?: boolean
34
+ /** 別の側の作業中でも、その作業に差し込む(端末の /now。ADR 0030) */
35
+ cutIn?: boolean
34
36
  }
35
37
 
36
38
  /** コネクターが申告する、送れるものの上限。中核は、これで送る前に確認し、エージェントへの案内を組み立てる */
@@ -68,6 +70,11 @@ export interface Connector {
68
70
  * (中核は、子の ID を親の登録で通すため)。使わないコネクターへは、その形の ID で送らない
69
71
  */
70
72
  readonly nestedRooms?: boolean
73
+ /**
74
+ * このサービスの発言を、ほかのサービスの発言と同じターンに入れない(管理者の端末。ADR 0030)。
75
+ * 作業中のターンが別の側のものなら、差し込まずに待ち、届いた順に別のターンとして渡す
76
+ */
77
+ readonly ownTurns?: boolean
71
78
  /** HTTP のエンドポイントが必要なら、そのルート */
72
79
  readonly routes?: Routes
73
80
  /** 受け取りを始める(ポーリング、常時接続など)。エンドポイントだけで受けるなら、何もしなくてよい */
@@ -140,6 +147,24 @@ export type Screener = (q: ScreenQuery) => Promise<{ drop: boolean; probabilitie
140
147
  /** always は「常に許可」(ADR 0015) */
141
148
  export type Verdict = "allow" | "always" | "deny"
142
149
 
150
+ /**
151
+ * ハーネスの途中経過(ADR 0030)。text はエージェントが書いた文の続き。tool はツールの実行で、id は同じツールの行を更新するのにだけ使い、表示しない
152
+ */
153
+ export type Progress = { kind: "text"; text: string } | { kind: "tool"; id: string; title: string; status?: string }
154
+
155
+ /**
156
+ * 中継の状態(ADR 0030)。turn は作業中のターンで、lane はその側(ownTurns のサービス。ほかのルームなら空)、rooms はそのターンに発言を渡したルームの名前。
157
+ * approvals は答えを待っている承認依頼の数、queued は側ごとの、まだ渡していない発言の数。
158
+ * steering は、作業中のターンに差し込めるか(ハーネスが対応していて、差し込みに失敗していない。ADR 0018)。差し込めなければ、cutIn の発言も次のターンを待つ
159
+ */
160
+ export type RelayStatus = { turn?: { lane: string; rooms: string[] }; approvals: number; queued: Record<string, number>; steering: boolean }
161
+
162
+ /** 中継が見ている人(管理者の端末)へ流すもの。sent は、エージェントが reply で送った発言 */
163
+ export type RelayEvent =
164
+ | { type: "status"; status: RelayStatus }
165
+ | { type: "progress"; progress: Progress }
166
+ | { type: "sent"; room: string; name?: string; text: string }
167
+
143
168
  // 承認の返事。ID は 5 文字で、l(1 と紛らわしい)は使わない
144
169
  const PERMISSION_REPLY_RE = /^\s*(y|yes|n|no|always)\s+([a-km-z]{5})\s*$/i
145
170
  const PERMISSION_TIMEOUT_MS = 30 * 60 * 1000
@@ -238,6 +263,14 @@ export class Relay {
238
263
  private runningTurns?: Promise<void>
239
264
  /** 他人宛ての判定(ADR 0029)に回した発言と、その答え(true なら渡す)。渡した発言とともに消えるよう、WeakMap にする */
240
265
  private readonly screening = new WeakMap<Incoming, Promise<boolean>>()
266
+ /** 待ち行列に入った順番。差し込めなかった発言を、もとの位置に戻すのに使う */
267
+ private readonly order = new WeakMap<Incoming, number>()
268
+ private arrivals = 0
269
+ /** 作業中のターンの側(laneOf。ADR 0030)。ターンがなければ使わない */
270
+ private turnLane = ""
271
+ /** 中継の様子を見ているもの(管理者の端末) */
272
+ private readonly observers = new Set<(e: RelayEvent) => void>()
273
+ private statusPending = false
241
274
 
242
275
  constructor(
243
276
  private readonly access: AccessStore,
@@ -277,9 +310,55 @@ export class Relay {
277
310
 
278
311
  attach(session: Session): void {
279
312
  this.session = session
313
+ this.changed()
280
314
  this.kick()
281
315
  }
282
316
 
317
+ // ---- 管理者の端末へ流すもの(ADR 0030) ----
318
+
319
+ /** 中継の様子を受け取る。やめるときは、返した関数を呼ぶ */
320
+ observe(fn: (e: RelayEvent) => void): () => void {
321
+ this.observers.add(fn)
322
+ return () => this.observers.delete(fn)
323
+ }
324
+
325
+ status(): RelayStatus {
326
+ const queued: Record<string, number> = {}
327
+ for (const m of this.queue) {
328
+ const lane = this.laneOf(m)
329
+ queued[lane] = (queued[lane] ?? 0) + 1
330
+ }
331
+ const approvals = [...this.batches.values(), ...(this.collecting ? [this.collecting] : [])].reduce((n, b) => n + b.items.length, 0)
332
+ const rooms = [...(this.turn?.keys() ?? [])].map((r) => this.roomNames.get(r) ?? r)
333
+ const steering = this.session?.steer !== undefined && this.steerable
334
+ return { ...(this.turn ? { turn: { lane: this.turnLane, rooms } } : {}), approvals, queued, steering }
335
+ }
336
+
337
+ /** ハーネスの途中経過。チャットの記録には入れず、ルームにも送らない */
338
+ progress(p: Progress): void {
339
+ this.emit({ type: "progress", progress: p })
340
+ }
341
+
342
+ private emit(e: RelayEvent): void {
343
+ for (const fn of this.observers) {
344
+ try {
345
+ fn(e)
346
+ } catch (err) {
347
+ this.log.error("端末へ流せませんでした", { error: String(err) })
348
+ }
349
+ }
350
+ }
351
+
352
+ /** 状態が変わった。同じ処理の中の変化は、まとめて 1 回だけ流す */
353
+ private changed(): void {
354
+ if (this.statusPending || this.observers.size === 0) return
355
+ this.statusPending = true
356
+ queueMicrotask(() => {
357
+ this.statusPending = false
358
+ this.emit({ type: "status", status: this.status() })
359
+ })
360
+ }
361
+
283
362
  /** コネクターが受けた発言 */
284
363
  receive(m: Incoming): ReceiveResult {
285
364
  // 古い依頼の実行、古い承認の返事、ペアリングのコードを出さないよう、許可の判定(gate)を通さない
@@ -308,7 +387,9 @@ export class Relay {
308
387
  // 判定には、この発言より前の、同じルームの発言を渡す
309
388
  if (r.screen && this.screen) this.screening.set(m, this.screenMessage(this.screen, m, [...(this.records.get(m.room) ?? [])]))
310
389
  this.record(m)
390
+ this.order.set(m, this.arrivals++)
311
391
  this.queue.push(m)
392
+ this.changed()
312
393
  this.kick()
313
394
  // 受信モードが「すべて」のルームの、メンションのない発言には出さない
314
395
  return { ...r, acknowledge: m.mentioned }
@@ -407,6 +488,7 @@ export class Relay {
407
488
  b.id = b.items.length === 1 ? b.items[0]!.id : this.newPermissionId()
408
489
  this.batches.set(b.id, b)
409
490
  b.waiting = setTimeout(() => this.noticeTurn("approval"), this.timing.approvalMs)
491
+ this.changed()
410
492
  const approvers = this.access.load().allowFrom
411
493
  for (const user of approvers) if (canAnswer(b, user, approvers)) this.sendBatchTo(user, b)
412
494
  }
@@ -442,6 +524,7 @@ export class Relay {
442
524
  // 「常に許可」が示されていない依頼には、今回だけの許可として答える
443
525
  for (const item of items) item.resolve(verdict === "always" && !item.req.always ? "allow" : verdict)
444
526
  b.items = b.items.filter((i) => !items.includes(i))
527
+ this.changed()
445
528
  if (b.items.length > 0) return
446
529
  clearTimeout(b.timeout)
447
530
  clearTimeout(b.waiting)
@@ -494,6 +577,7 @@ export class Relay {
494
577
  checkFiles(c, paths)
495
578
  const ids = await c.send(room, text, { replyTo, files: paths })
496
579
  this.replied(room)
580
+ this.emit({ type: "sent", room, name: this.roomNames.get(room), text })
497
581
  const attachments = paths.map((p) => ({ name: basename(p), type: "file" }))
498
582
  this.record({ id: ids[0] ?? `sent-${Date.now()}`, room, sender: "me", text, ts: Date.now(), attachments, fromMe: true })
499
583
  return ids
@@ -556,13 +640,34 @@ export class Relay {
556
640
  * 待ち行列の、今ある発言を取り出す。他人宛ての判定を待っている発言があれば、その答えを待ち、外す発言を除く。
557
641
  * 待つ間に届いた発言は残すので、発言の順番は変わらない
558
642
  */
559
- private async take(): Promise<Incoming[]> {
560
- const batch = this.queue.slice()
643
+ private async take(pick: (m: Incoming) => boolean): Promise<Incoming[]> {
644
+ const batch = this.queue.filter(pick)
561
645
  const keep = await Promise.all(batch.map((m) => this.screening.get(m) ?? Promise.resolve(true)))
562
- this.queue.splice(0, batch.length)
646
+ for (const m of batch) this.queue.splice(this.queue.indexOf(m), 1)
647
+ this.changed()
563
648
  return batch.filter((_, i) => keep[i])
564
649
  }
565
650
 
651
+ /** 渡せなかった発言を、届いた順の位置に戻す。あとから届いた発言より前に渡る */
652
+ private requeue(batch: Incoming[]): void {
653
+ this.queue.push(...batch)
654
+ this.queue.sort((a, b) => this.arrival(a) - this.arrival(b))
655
+ this.changed()
656
+ }
657
+
658
+ /** 発言が届いた順番 */
659
+ private arrival(m: Incoming): number {
660
+ return this.order.get(m) ?? 0
661
+ }
662
+
663
+ /**
664
+ * 発言の側(ADR 0030)。ownTurns のコネクター(管理者の端末)ならそのサービス、ほかのルームはすべて空。
665
+ * 側が違う発言は、同じターンに入れない
666
+ */
667
+ private laneOf(m: Incoming): string {
668
+ return this.connector(m.room)?.ownTurns ? serviceOf(m.room) : ""
669
+ }
670
+
566
671
  private kick(): void {
567
672
  this.arrived?.()
568
673
  if (this.running || !this.session || this.queue.length === 0) return
@@ -573,11 +678,14 @@ export class Relay {
573
678
  private async run(): Promise<void> {
574
679
  try {
575
680
  while (this.session && this.queue.length > 0) {
576
- const batch = await this.take()
681
+ // いちばん古い発言の側の発言を、まとめて 1 つのターンにする(ADR 0030)
682
+ const lane = this.laneOf(this.queue[0]!)
683
+ const batch = await this.take((m) => this.laneOf(m) === lane)
577
684
  if (batch.length === 0) continue
578
685
  const text = await this.render(batch)
579
686
  const turnRooms = new Map<string, TurnRoom>()
580
687
  this.turn = turnRooms
688
+ this.turnLane = lane
581
689
  this.delivered(turnRooms, batch)
582
690
  let failed = false
583
691
  const turn = this.session
@@ -588,7 +696,7 @@ export class Relay {
588
696
  })
589
697
  // 差し込みの結果を待つ間にターンが終わっても、時間のたった知らせを出さない
590
698
  .finally(() => stopSlowTimers(turnRooms))
591
- await this.steerUntil(this.session, turn, turnRooms)
699
+ await this.steerUntil(this.session, turn, turnRooms, lane)
592
700
  this.endTurn(turnRooms, failed)
593
701
  }
594
702
  } finally {
@@ -600,11 +708,15 @@ export class Relay {
600
708
  * ターンが終わるまで、届いた発言をそのターンに差し込む(ADR 0018)。
601
709
  * 差し込めないハーネスや、差し込めなかった発言は、ためておき、ターンが終わってからまとめて渡す。
602
710
  * 差し込みの結果を待つ間にターンが終わったら、次の発言は差し込まず、次のターンで渡す(#50)。
603
- * 差し込めた発言のルームは、rooms に足す
711
+ * 差し込めた発言のルームは、rooms に足す。
712
+ * 差し込むのは、そのターンと同じ側の発言と、明示して差し込む発言(cutIn)だけ。ほかは、ターンが終わるまで待つ(ADR 0030)。
713
+ * cutIn の発言は、同じ側でそれより前に届いて待っている発言と一緒に差し込む。同じ人の発言を、送った順に渡すため
604
714
  */
605
- private async steerUntil(session: Session, turn: Promise<void>, rooms: Map<string, TurnRoom>): Promise<void> {
715
+ private async steerUntil(session: Session, turn: Promise<void>, rooms: Map<string, TurnRoom>, lane: string): Promise<void> {
606
716
  const steer = session.steer?.bind(session)
607
717
  if (!steer || !this.steerable) return turn
718
+ const cutsIn = (m: Incoming) => this.queue.some((c) => c.cutIn === true && this.laneOf(c) === this.laneOf(m) && this.arrival(c) >= this.arrival(m))
719
+ const joins = (m: Incoming) => this.laneOf(m) === lane || cutsIn(m)
608
720
  let done = false
609
721
  const ended = turn.then(() => {
610
722
  done = true
@@ -612,8 +724,8 @@ export class Relay {
612
724
  })
613
725
  for (;;) {
614
726
  if (done) return
615
- if (this.queue.length > 0) {
616
- const batch = await this.take()
727
+ if (this.queue.some(joins)) {
728
+ const batch = await this.take(joins)
617
729
  if (batch.length === 0) continue
618
730
  try {
619
731
  const text = await this.render(batch)
@@ -626,7 +738,7 @@ export class Relay {
626
738
  this.log.error("作業中のターンへの差し込みに失敗しました。以後は、ターンが終わってから渡します", { error: String(err) })
627
739
  }
628
740
  // 渡せなかった発言は、あとから届いた発言より前に渡す
629
- this.queue.unshift(...batch)
741
+ this.requeue(batch)
630
742
  await turn
631
743
  return
632
744
  }
@@ -689,6 +801,7 @@ export class Relay {
689
801
  r.mentioned ||= m.mentioned
690
802
  if (r.mentioned) r.slow ??= setTimeout(() => this.noticeRoom(m.room, r, "slow"), this.timing.slowMs)
691
803
  }
804
+ this.changed()
692
805
  }
693
806
 
694
807
  /** そのターンで、ルームへ返事した */
@@ -703,6 +816,7 @@ export class Relay {
703
816
  for (const [room, r] of turn) this.noticeRoom(room, r, failed ? "failed" : "silent")
704
817
  this.turn = undefined
705
818
  this.turnMessages = []
819
+ this.changed()
706
820
  }
707
821
 
708
822
  /** 作業中のターンのルームすべてに知らせる */
@@ -1,9 +1,11 @@
1
1
  // ハーネスを ACP で動かす(ADR 0006)。中継が ACP のクライアントになり、ハーネスを子プロセスとして起動する。
2
2
  // セッションは 1 つ。チャット用ツールの MCP サーバーを session/new(再開なら session/resume か session/load)で渡し、発言は session/prompt で渡し、作業中に届いた発言は、対応していれば _session/steering で差し込む(ADR 0018)。
3
3
 
4
+ import { dirname, isAbsolute, sep } from "node:path"
4
5
  import * as acp from "@agentclientprotocol/sdk"
5
- import type { Log, PermissionRequest, Session, Verdict } from "../core/relay.ts"
6
+ import type { Log, PermissionRequest, Progress, Session, Verdict } from "../core/relay.ts"
6
7
  import { RotatingFile } from "./log-file.ts"
8
+ import { protectedBy, targetsOf } from "./protect.ts"
7
9
  import { VERSION } from "../version.ts"
8
10
 
9
11
  export type HarnessConfig = {
@@ -29,10 +31,26 @@ export type HarnessConfig = {
29
31
  mode?: string
30
32
  /** ハーネスの stderr を追記するファイル。画面には出さない。10MB を超えそうになったら <path>.1 に移して新しく始める */
31
33
  stderrPath: string
34
+ } & HarnessHooks
35
+
36
+ /** 管理者の端末のためのもの(ADR 0030) */
37
+ export type HarnessHooks = {
38
+ /** 途中経過(エージェントの文とツールの実行)を受ける。session/load が再送する履歴は渡さない */
39
+ onProgress?: (p: Progress) => void
40
+ /**
41
+ * エージェントに読ませないパス(端末の接続用のトークンとソケット)。対象にこれを含む依頼は、承認者に尋ねずに拒否する。
42
+ * 読み取りの「常に許可」の範囲(対象のディレクトリ)にこれが入る依頼には、「常に許可」を出さない
43
+ */
44
+ protect?: string[]
32
45
  }
33
46
 
34
47
  const MAX_STDERR_BYTES = 10 * 1024 * 1024
35
48
 
49
+ /** 端末の接続用のファイルに触れる依頼を、承認者に尋ねずに拒否したときのログ(ADR 0030)。中継の本体が拒否したときも、ハーネスが拒否したときも同じ文にする */
50
+ export const PROTECTED_DENIED_LOG = "端末の接続用のファイルに触れるため、承認者に尋ねずに拒否しました"
51
+ /** ハーネスが尋ねずに拒否したツール呼び出しの、failed の tool_call_update に付く _meta のキー(同梱の pi のアダプターが付ける。#78) */
52
+ const PROTECTED_META_KEY = "io.github.dot-labo/protected"
53
+
36
54
  /**
37
55
  * ハーネスの stdin を、ACP の SDK に渡す stream にする。書き込みの失敗(ハーネスが読まずに終了したときの EPIPE など)は
38
56
  * Promise で返し、SDK に接続を閉じさせる。受けずに捨てると、受け手のない reject になり、中継のプロセスごと終了する
@@ -85,25 +103,19 @@ export async function startHarness(
85
103
  let turnText = ""
86
104
  // session/load が応答の前に再送する履歴は、新しい出力として扱わない
87
105
  let replaying = false
106
+ /** ツールの表示名。更新(tool_call_update)に名前がないときに使う */
107
+ const toolTitles = new Map<string, string>()
88
108
  const app = acp
89
109
  .client({ name: "agent-chat-relay" })
90
- .onRequest("session/request_permission", async ({ params }) => {
91
- const tc = params.toolCall
92
- const title = tc.title ?? tc.kind ?? "ツールの実行"
93
- const input = tc.rawInput === undefined ? "" : JSON.stringify(tc.rawInput, null, 2)
94
- const always = alwaysOption(tc.kind, params.options)
95
- // そのターンでエージェントが書いた文も渡す。承認依頼の送り先を推すのに使う(ADR 0026)
96
- const verdict = await onPermission({ title, input, always: always?.name, agentText: turnText, ...(cfg.requireFullPermissionDisplay ? { requireFullDisplay: true } : {}) })
97
- const option = verdict === "always" && always ? always : params.options.find((o) => o.kind === (verdict === "deny" ? "reject_once" : "allow_once"))
98
- log.info(`実行承認:${verdict}`, { tool: title })
99
- if (!option) return { outcome: { outcome: "cancelled" } }
100
- return { outcome: { outcome: "selected", optionId: option.optionId } }
101
- })
110
+ .onRequest("session/request_permission", ({ params }) => answerPermission(params, cfg, onPermission, turnText, log))
102
111
  .onNotification("session/update", ({ params }) => {
103
112
  if (replaying) return
104
113
  const u = params.update
105
114
  if (u.sessionUpdate === "agent_message_chunk" && u.content.type === "text") turnText += u.content.text
106
115
  if (u.sessionUpdate === "tool_call") log.info(`ツール:${u.title}`)
116
+ const p = progressOf(u, toolTitles)
117
+ if (deniedByHarness(u)) log.error(PROTECTED_DENIED_LOG, { tool: toolTitles.get(u.toolCallId) })
118
+ if (p) cfg.onProgress?.(p)
107
119
  })
108
120
 
109
121
  const ready = Promise.withResolvers<{ sessionId: string; session: Session }>()
@@ -252,3 +264,64 @@ export function alwaysOption(kind: acp.ToolKind | null | undefined, options: acp
252
264
  if (kind === "switch_mode" || kind === "edit") return undefined
253
265
  return options.find((o) => o.kind === "allow_always")
254
266
  }
267
+
268
+ /** 実行承認の依頼を承認者に尋ね、ハーネスが示した選択肢で答える。agentText は、そのターンでエージェントが書いた文(送り先を推すのに使う。ADR 0026) */
269
+ async function answerPermission(
270
+ params: acp.RequestPermissionRequest,
271
+ cfg: HarnessConfig,
272
+ onPermission: (req: PermissionRequest) => Promise<Verdict>,
273
+ agentText: string,
274
+ log: Log,
275
+ ): Promise<acp.RequestPermissionResponse> {
276
+ const tc = params.toolCall
277
+ const title = tc.title ?? tc.kind ?? "ツールの実行"
278
+ const input = tc.rawInput === undefined ? "" : JSON.stringify(tc.rawInput, null, 2)
279
+ const guard = guardProtected(tc, cfg.cwd, cfg.protect ?? [])
280
+ const always = guard === undefined ? alwaysOption(tc.kind, params.options) : undefined
281
+ let verdict: Verdict = "deny"
282
+ if (guard === "deny") log.error(PROTECTED_DENIED_LOG, { tool: title })
283
+ else verdict = await onPermission({ title, input, always: always?.name, agentText, ...(cfg.requireFullPermissionDisplay ? { requireFullDisplay: true } : {}) })
284
+ const option = verdict === "always" && always ? always : params.options.find((o) => o.kind === (verdict === "deny" ? "reject_once" : "allow_once"))
285
+ log.info(`実行承認:${verdict}`, { tool: title })
286
+ if (!option) return { outcome: { outcome: "cancelled" } }
287
+ return { outcome: { outcome: "selected", optionId: option.optionId } }
288
+ }
289
+
290
+ /** 端末の接続用のファイルに触れるため、ハーネスが尋ねずに拒否したツール呼び出しの結果か(ADR 0030、#78) */
291
+ function deniedByHarness(u: acp.SessionUpdate): u is acp.ToolCallUpdate & { sessionUpdate: "tool_call_update" } {
292
+ return u.sessionUpdate === "tool_call_update" && u.status === "failed" && u._meta?.[PROTECTED_META_KEY] === true
293
+ }
294
+
295
+ /**
296
+ * ハーネスの通知を、端末に流す途中経過にする(ADR 0030)。思考の出力やほかの通知は流さない。
297
+ * ツールの更新に名前がなければ、最初の名前を使う。名前も種類もなければ「ツールの実行」とし、ID は表示に使わない
298
+ */
299
+ export function progressOf(u: acp.SessionUpdate, titles: Map<string, string>): Progress | undefined {
300
+ if (u.sessionUpdate === "agent_message_chunk") return u.content.type === "text" ? { kind: "text", text: u.content.text } : undefined
301
+ if (u.sessionUpdate !== "tool_call" && u.sessionUpdate !== "tool_call_update") return undefined
302
+ const title = u.title || titles.get(u.toolCallId) || u.kind || "ツールの実行"
303
+ titles.set(u.toolCallId, title)
304
+ return { kind: "tool", id: u.toolCallId, title, ...(u.status ? { status: u.status } : {}) }
305
+ }
306
+
307
+ /**
308
+ * 端末の接続用のファイル(protect)を守る(ADR 0030)。依頼の対象(ACP の locations と、入力のパス)がそれを含むなら deny。
309
+ * 読み取りの「常に許可」は、対象のディレクトリ全体に効く(claude-agent-acp 0.101.0)。その範囲にそれが入るなら once(「常に許可」を出さない)。
310
+ * パスを省いた検索は、作業ディレクトリを対象とみなす。どちらのパスも、シンボリックリンクをたどった実体で比べる。
311
+ * 依頼のパスの .. は、OS のとおりに解いたものと、文字列の上で畳んだものの両方で比べ、どちらかが当たれば当たりとする。
312
+ * Bash などの、対象のパスを示さない依頼は見分けられない(ADR 0030 の限界)
313
+ */
314
+ export function guardProtected(
315
+ tc: Pick<acp.ToolCallUpdate, "kind" | "locations" | "rawInput">,
316
+ cwd: string,
317
+ protect: string[],
318
+ ): "deny" | "once" | undefined {
319
+ const raw = (tc.rawInput ?? {}) as Record<string, unknown>
320
+ const given = [...(tc.locations ?? []).map((l) => l.path), ...["file_path", "path", "notebook_path"].map((k) => raw[k])]
321
+ const paths = given.filter((p): p is string => typeof p === "string" && p !== "")
322
+ const targets = (paths.length === 0 && tc.kind === "search" ? [cwd] : paths).flatMap((p) => targetsOf(isAbsolute(p) ? p : `${cwd}${sep}${p}`))
323
+ const hits = protectedBy(protect)
324
+ if (targets.some(hits)) return "deny"
325
+ if ((tc.kind === "read" || tc.kind === "search") && targets.some((t) => hits(dirname(t)))) return "once"
326
+ return undefined
327
+ }
@@ -3,7 +3,7 @@ import { join, resolve } from "node:path"
3
3
  import { fileURLToPath } from "node:url"
4
4
  import type { Log, PermissionRequest, Verdict } from "../../core/relay.ts"
5
5
  import { BUN_ISOLATED, type HarnessOptions } from "../config.ts"
6
- import { startHarness, type HarnessConfig } from "../harness.ts"
6
+ import { startHarness, type HarnessConfig, type HarnessHooks } from "../harness.ts"
7
7
  import { preparePiState } from "./state.ts"
8
8
 
9
9
  const ADAPTER = fileURLToPath(new URL("../../vendor/pi/adapter.js", import.meta.url))
@@ -17,11 +17,11 @@ export function preparePiLaunch({ home, options, cwd, sessionId, stderrPath }: P
17
17
  if (sessionId !== undefined) state.requireSession(sessionId)
18
18
  state.checkModelFiles()
19
19
  const inherited = options.inheritSettings ? resolve(process.env.PI_CODING_AGENT_DIR || join(homedir(), ".pi", "agent")) : undefined
20
- return async (mcp: HarnessConfig["mcp"], onPermission: (req: PermissionRequest) => Promise<Verdict>) => {
20
+ return async (mcp: HarnessConfig["mcp"], onPermission: (req: PermissionRequest) => Promise<Verdict>, hooks: HarnessHooks = {}) => {
21
21
  if (inherited) log.error("警告:pi の端末・プロジェクト設定を引き継ぎます。信頼済みの拡張などが実行承認を通らずに動くことがあります")
22
22
  const launched = await startHarness({
23
23
  command: [...BUN_ISOLATED, ADAPTER],
24
- cwd: state.workspace, mcp, sessionId, stderrPath,
24
+ cwd: state.workspace, mcp, sessionId, stderrPath, ...hooks,
25
25
  inheritEnv: false,
26
26
  requireFullPermissionDisplay: true,
27
27
  env: {
@@ -31,6 +31,8 @@ export function preparePiLaunch({ home, options, cwd, sessionId, stderrPath }: P
31
31
  PI_OFFLINE: "1",
32
32
  PI_TELEMETRY: "0",
33
33
  PI_ACP_MANAGED_CHAT_WORKSPACE: state.workspace,
34
+ // pi の承認依頼はパスを文の中にしか持たず、中継の本体では守れない。拡張で照合する(ADR 0030)
35
+ PI_ACP_MANAGED_PROTECT: JSON.stringify(hooks.protect ?? []),
34
36
  PI_CODING_AGENT_DIR: state.agentDir,
35
37
  ...(inherited ? { PI_ACP_INHERITED_AGENT_DIR: inherited } : {}),
36
38
  },
@@ -1,3 +1,8 @@
1
+ import { homedir } from "node:os"
2
+ import { isAbsolute, join, sep } from "node:path"
3
+ import { fileURLToPath } from "node:url"
4
+ import { protectedBy, targetsOf } from "../protect.ts"
5
+
1
6
  // pi 1.5.2 の tool_call と ui.confirm の接続に必要な部分だけを受ける。
2
7
  type PiToolCall = { toolName: string; input: unknown }
3
8
  type PiApprovalContext = {
@@ -11,10 +16,16 @@ type Blocked = { block: true; reason: string }
11
16
  // 中継の実行承認と同じ 30 分を上限にする(src/core/relay.ts の PERMISSION_TIMEOUT_MS)。
12
17
  const MAX_APPROVAL_WAIT_MS = 30 * 60 * 1000
13
18
 
14
- function textField(input: unknown, key: string): string | undefined {
19
+ function stringField(input: unknown, key: string): string | undefined {
15
20
  if (!input || typeof input !== "object" || Array.isArray(input)) return
16
21
  const value: unknown = Object.getOwnPropertyDescriptor(input, key)?.value
17
- if (typeof value === "string" && value.trim()) return value
22
+ if (typeof value === "string") return value
23
+ }
24
+
25
+ /** 表示に使う文字列。空白だけのものは、確認できないとして扱う */
26
+ function textField(input: unknown, key: string): string | undefined {
27
+ const value = stringField(input, key)
28
+ if (value?.trim()) return value
18
29
  }
19
30
 
20
31
  /** 改行や表示方向を変える文字を、対象の一部として見える形にする。 */
@@ -36,6 +47,53 @@ export function describePiToolCall({ toolName, input }: PiToolCall): { title: st
36
47
  return { title: "その他のツールの実行", message: `ツール: ${quoted(toolName)}(対象を確認できません)` }
37
48
  }
38
49
 
50
+ // pi 1.5.2 の dist/utils/paths.js の UNICODE_SPACES。pi はこれを普通の空白にしてから開く。
51
+ const UNICODE_SPACES = /[\u00A0\u2000-\u200A\u202F\u205F\u3000]/g
52
+
53
+ /**
54
+ * pi 1.5.2 の resolveToCwd(dist/core/tools/path-utils.js、dist/utils/paths.js の normalizePath)と同じ規則で、
55
+ * ツールの path を絶対パスにする。pi はこれらの関数を公開していないので、規則を写す(テストが、入力の表について実物の pi のツールと突き合わせる)。
56
+ * ~ は、pi と同じく、このプロセスの HOME(中継が用意した pi のホーム)で展開する。.. は畳まない(targetsOf が両方を比べる)
57
+ */
58
+ function piPath(path: string, cwd: string): string {
59
+ let p = path.replace(UNICODE_SPACES, " ")
60
+ if (p.startsWith("@")) p = p.slice(1)
61
+ if (p === "~") p = homedir()
62
+ else if (p.startsWith("~/")) p = join(homedir(), p.slice(2))
63
+ else if (p.startsWith("file://")) p = fileURLToPath(p)
64
+ return isAbsolute(p) ? p : `${cwd}${sep}${p}`
65
+ }
66
+
67
+ /**
68
+ * read は、パスのファイルがなければ、macOS のファイル名の候補を開く(pi 1.5.2 の resolveReadPath)。
69
+ * どれを開くかはファイルの有無で決まるので、すべてを比べる。write・edit でも比べる(多めに拒否するだけ)
70
+ */
71
+ function readVariants(p: string): string[] {
72
+ const nfd = p.normalize("NFD")
73
+ const curly = (s: string) => s.replace(/'/g, "\u2019")
74
+ return [p, p.replace(/ (AM|PM)\./gi, "\u202F$1."), nfd, curly(p), curly(nfd)]
75
+ }
76
+
77
+ /**
78
+ * 端末の接続用のファイル(protect)に触れる read・write・edit を、承認者に尋ねずに拒否する(ADR 0030)。
79
+ * パスは pi と同じ規則で解き、シンボリックリンクをたどった実体で比べる。解けないパスも拒否する。
80
+ * bash などの、対象のパスを示さない操作は見分けられない(ADR 0030 の限界)
81
+ */
82
+ export function guardPiToolCall({ toolName, input }: PiToolCall, cwd: string, protect: string[]): Blocked | undefined {
83
+ if (toolName !== "read" && toolName !== "write" && toolName !== "edit") return
84
+ // 空白だけのパスも、pi はその名前のファイルとして開くので、trim せずに比べる
85
+ const path = stringField(input, "path")
86
+ if (path === undefined) return
87
+ const blocked: Blocked = { block: true, reason: "端末の接続用のファイルには触れられません" }
88
+ let abs: string
89
+ try {
90
+ abs = piPath(path, cwd)
91
+ } catch {
92
+ return blocked
93
+ }
94
+ return readVariants(abs).flatMap(targetsOf).some(protectedBy(protect)) ? blocked : undefined
95
+ }
96
+
39
97
  /** 実行承認を求める。承認を省けるかどうかは、実際の読み取りなどを担う呼び出し側で判断する。 */
40
98
  export async function approvePiToolCall(
41
99
  event: PiToolCall,
@@ -0,0 +1,37 @@
1
+ // 依頼の対象のパスを、端末の接続用のファイル(ADR 0030)と比べる。中継の本体(guardProtected)と、pi の拡張の両方で使う。
2
+
3
+ import { realpathSync } from "node:fs"
4
+ import { basename, dirname, join, relative, resolve, sep } from "node:path"
5
+
6
+ /**
7
+ * 依頼のパス(絶対パス)の、比べる候補。どちらも、シンボリックリンクをたどった実体のパス。
8
+ * ツールが .. を OS のとおりに解くか(リンクの先の親)、文字列の上で畳んでから開くか(リンクのある場所の親)は分からないので、両方を返す
9
+ */
10
+ export function targetsOf(abs: string): string[] {
11
+ return [real(abs), real(resolve(abs))]
12
+ }
13
+
14
+ /** 実体のパス dir が、守るパスのどれかであるか、どれかを中に含むかを返す関数 */
15
+ export function protectedBy(protect: string[]): (dir: string) => boolean {
16
+ const guarded = protect.map(real)
17
+ return (dir) => guarded.some((p) => inside(dir, p))
18
+ }
19
+
20
+ /**
21
+ * シンボリックリンクをたどった実体のパス。まだないパスは、あるところまでをたどり、残りをつなぐ。
22
+ * OS と同じく、リンクをたどってから .. を解く realpath(native)を使う。Bun の JS 版は、先に .. を畳む
23
+ */
24
+ function real(p: string): string {
25
+ try {
26
+ return realpathSync.native(p)
27
+ } catch {
28
+ const parent = dirname(p)
29
+ return parent === p ? p : join(real(parent), basename(p))
30
+ }
31
+ }
32
+
33
+ /** p が dir そのものか、その中にあるか。どちらも絶対パス(POSIX では、relative は絶対パスを返さない) */
34
+ function inside(dir: string, p: string): boolean {
35
+ const rel = relative(dir, p)
36
+ return rel !== ".." && !rel.startsWith(`..${sep}`)
37
+ }