@dotlabo/agent-chat-relay 0.0.0-stage → 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/CHANGELOG.md +109 -0
- package/LICENSE +21 -0
- package/README.md +154 -2
- package/bin/agent-chat-relay +22 -0
- package/package.json +69 -4
- package/src/connectors/chatwork.ts +289 -0
- package/src/connectors/common.ts +106 -0
- package/src/connectors/discord.ts +335 -0
- package/src/connectors/http.ts +137 -0
- package/src/connectors/line-media.ts +63 -0
- package/src/connectors/line.ts +444 -0
- package/src/connectors/terminal.ts +367 -0
- package/src/core/access.ts +250 -0
- package/src/core/instructions.ts +21 -0
- package/src/core/mcp.ts +160 -0
- package/src/core/relay.ts +1063 -0
- package/src/core/retention.ts +44 -0
- package/src/harness/config.ts +137 -0
- package/src/harness/harness.ts +327 -0
- package/src/harness/log-file.ts +34 -0
- package/src/harness/pi/config.ts +51 -0
- package/src/harness/pi/state.ts +97 -0
- package/src/harness/pi/tool-approval.ts +128 -0
- package/src/harness/protect.ts +37 -0
- package/src/home.ts +67 -0
- package/src/jev.ts +201 -0
- package/src/main.ts +275 -0
- package/src/prompt.ts +12 -0
- package/src/serve-args.ts +56 -0
- package/src/shutdown.ts +52 -0
- package/src/terminal.ts +172 -0
- package/src/vendor/pi/adapter.js +3238 -0
- package/src/vendor/pi/managed-extension.ts +94 -0
- package/src/vendor/pi/managed-pi-rpc.ts +102 -0
- package/src/vendor/pi/managed-read.ts +99 -0
- package/src/vendor/pi/package.json +7 -0
- package/src/vendor/pi/pi-LICENSE +21 -0
- package/src/vendor/pi/pi-acp-LICENSE +21 -0
- package/src/version.ts +4 -0
- package/src/workspace.ts +117 -0
|
@@ -0,0 +1,44 @@
|
|
|
1
|
+
// 受け取った添付と、返した画像を消す時期(ADR 0005)。
|
|
2
|
+
|
|
3
|
+
import { readdirSync, rmSync, statSync } from "node:fs"
|
|
4
|
+
import { join } from "node:path"
|
|
5
|
+
import type { Log } from "./relay.ts"
|
|
6
|
+
|
|
7
|
+
/** 受け取った添付と公開した画像を残す期間 */
|
|
8
|
+
export const RETENTION_MS = 7 * 24 * 60 * 60 * 1000
|
|
9
|
+
|
|
10
|
+
/** dir の直下で、更新から maxAgeMs を過ぎたファイルを消す。消した数を返す */
|
|
11
|
+
export function pruneOld(dir: string, maxAgeMs: number): number {
|
|
12
|
+
let names: string[]
|
|
13
|
+
try {
|
|
14
|
+
names = readdirSync(dir)
|
|
15
|
+
} catch {
|
|
16
|
+
return 0
|
|
17
|
+
}
|
|
18
|
+
let n = 0
|
|
19
|
+
for (const name of names) {
|
|
20
|
+
const p = join(dir, name)
|
|
21
|
+
try {
|
|
22
|
+
const st = statSync(p)
|
|
23
|
+
if (st.isFile() && Date.now() - st.mtimeMs > maxAgeMs) {
|
|
24
|
+
rmSync(p)
|
|
25
|
+
n++
|
|
26
|
+
}
|
|
27
|
+
} catch {
|
|
28
|
+
// 途中で消えたものは無視する
|
|
29
|
+
}
|
|
30
|
+
}
|
|
31
|
+
return n
|
|
32
|
+
}
|
|
33
|
+
|
|
34
|
+
/** dir の中の、保存から 7 日を過ぎたファイルを、今と 1 時間ごとに消す。止める関数を返す */
|
|
35
|
+
export function schedulePrune(dir: string, what: string, log: Log): () => void {
|
|
36
|
+
const prune = () => {
|
|
37
|
+
const removed = pruneOld(dir, RETENTION_MS)
|
|
38
|
+
if (removed > 0) log.info(`7 日を過ぎた${what}を消しました`, { removed })
|
|
39
|
+
}
|
|
40
|
+
prune()
|
|
41
|
+
const timer = setInterval(prune, 60 * 60 * 1000)
|
|
42
|
+
timer.unref()
|
|
43
|
+
return () => clearInterval(timer)
|
|
44
|
+
}
|
|
@@ -0,0 +1,137 @@
|
|
|
1
|
+
// ハーネスごとの起動方法。実行承認と設定の読み込みに関わる部分は安全境界(AGENTS.md、ADR 0017)。
|
|
2
|
+
|
|
3
|
+
import { existsSync, readFileSync, writeFileSync } from "node:fs"
|
|
4
|
+
import { join } from "node:path"
|
|
5
|
+
import { fileURLToPath } from "node:url"
|
|
6
|
+
import type { HarnessConfig } from "./harness.ts"
|
|
7
|
+
import type { HarnessName } from "../serve-args.ts"
|
|
8
|
+
import type { Log } from "../core/relay.ts"
|
|
9
|
+
|
|
10
|
+
/**
|
|
11
|
+
* Bun で別のプログラムを動かすときの先頭部分。Bun は、cwd の .env を環境変数に読み込み、cwd の bunfig.toml の preload を実行する。
|
|
12
|
+
* cwd は作業ディレクトリで、エージェントが書けるか、管理者のプロジェクトの .env がありうるので、どちらも読ませない(ADR 0019)
|
|
13
|
+
*/
|
|
14
|
+
export const BUN_ISOLATED = [process.execPath, "--no-env-file", "--config=/dev/null"]
|
|
15
|
+
|
|
16
|
+
/** claude-agent-acp の入り口。起動したディレクトリではなく、このパッケージの依存から探す */
|
|
17
|
+
const ADAPTER = fileURLToPath(import.meta.resolve("@agentclientprotocol/claude-agent-acp/dist/index.js"))
|
|
18
|
+
|
|
19
|
+
/**
|
|
20
|
+
* Claude Code に読み込ませない指示のファイル。CLAUDE.local.md と .claude/rules/ も、上位のディレクトリから読まれる
|
|
21
|
+
* (Claude Code 2.1.327 で、CLAUDE.md・AGENTS.md だけを除くと、この 2 つが残ることを確認した)
|
|
22
|
+
*/
|
|
23
|
+
export const CLAUDE_MD_EXCLUDES = ["**/AGENTS.md", "**/CLAUDE.md", "**/CLAUDE.local.md", "**/.claude/rules/**"]
|
|
24
|
+
|
|
25
|
+
/** 管理者が環境変数で選ぶ、ハーネスの設定の読み込み(ADR 0017) */
|
|
26
|
+
export type HarnessOptions = {
|
|
27
|
+
/** RELAY_HARNESS_SETTINGS=default。ユーザー設定・CLAUDE.md などを、その環境の既定どおりに読ませる */
|
|
28
|
+
inheritSettings: boolean
|
|
29
|
+
/** RELAY_HARNESS_MEMORY=1。自動メモリを有効にする */
|
|
30
|
+
memory: boolean
|
|
31
|
+
}
|
|
32
|
+
|
|
33
|
+
/** 決めた値以外は、書き間違いとして起動しない。空の値は指定なしとして扱う */
|
|
34
|
+
export function harnessOptionsFromEnv(env: Record<string, string | undefined>): HarnessOptions {
|
|
35
|
+
return {
|
|
36
|
+
inheritSettings: flag(env, "RELAY_HARNESS_SETTINGS", "default"),
|
|
37
|
+
memory: flag(env, "RELAY_HARNESS_MEMORY", "1"),
|
|
38
|
+
}
|
|
39
|
+
}
|
|
40
|
+
|
|
41
|
+
function flag(env: Record<string, string | undefined>, name: string, on: string): boolean {
|
|
42
|
+
const v = env[name]
|
|
43
|
+
if (!v) return false
|
|
44
|
+
if (v !== on) throw new Error(`${name} に指定できるのは ${on} だけです(今は ${JSON.stringify(v)})`)
|
|
45
|
+
return true
|
|
46
|
+
}
|
|
47
|
+
|
|
48
|
+
export function harnessConfig(
|
|
49
|
+
name: Exclude<HarnessName, "pi">,
|
|
50
|
+
cwd: string,
|
|
51
|
+
mcp: HarnessConfig["mcp"],
|
|
52
|
+
opts: HarnessOptions,
|
|
53
|
+
log: Log,
|
|
54
|
+
/** 管理者が指定した作業ディレクトリ(RELAY_WORKSPACE)か。中継専用でなければ、管理者のファイルを上書きしない */
|
|
55
|
+
specified = false,
|
|
56
|
+
env: Record<string, string | undefined> = process.env,
|
|
57
|
+
): Omit<HarnessConfig, "stderrPath"> {
|
|
58
|
+
switch (name) {
|
|
59
|
+
case "claude": {
|
|
60
|
+
const claude = Bun.which("claude", { PATH: env.PATH ?? "" })
|
|
61
|
+
if (!claude) throw new Error("claude が見つかりません")
|
|
62
|
+
return {
|
|
63
|
+
// Agent SDK に同梱の CLI ではなく、インストール済みの claude を使う
|
|
64
|
+
command: [...BUN_ISOLATED, ADAPTER],
|
|
65
|
+
env: { CLAUDE_CODE_EXECUTABLE: claude },
|
|
66
|
+
cwd,
|
|
67
|
+
mcp,
|
|
68
|
+
mode: "default",
|
|
69
|
+
meta: { claudeCode: { options: claudeOptions(opts) } },
|
|
70
|
+
}
|
|
71
|
+
}
|
|
72
|
+
case "opencode": {
|
|
73
|
+
// 今は実行承認が働かない(#6)。安全境界を割るので、明示しない限り起動しない
|
|
74
|
+
if (env.RELAY_ALLOW_UNSAFE_HARNESS !== "1") {
|
|
75
|
+
throw new Error("opencode では実行承認が働かない(#6)ため、RELAY_ALLOW_UNSAFE_HARNESS=1 がないと起動しません")
|
|
76
|
+
}
|
|
77
|
+
// OpenCode は今もユーザーの設定を読み、自動メモリもない
|
|
78
|
+
if (opts.inheritSettings || opts.memory) log.info("RELAY_HARNESS_SETTINGS・RELAY_HARNESS_MEMORY は、opencode には効きません")
|
|
79
|
+
writeOpencodeConfig(cwd, env.RELAY_OPENCODE_MODEL, specified)
|
|
80
|
+
return { command: ["opencode", "acp"], cwd, mcp }
|
|
81
|
+
}
|
|
82
|
+
}
|
|
83
|
+
}
|
|
84
|
+
|
|
85
|
+
/** Claude Code の Agent SDK の options。指定のない項目は、その環境の claude の既定になる */
|
|
86
|
+
export function claudeOptions(opts: HarnessOptions): Record<string, unknown> {
|
|
87
|
+
return {
|
|
88
|
+
// ユーザー設定(~/.claude/settings.json)の allow ルールや hooks を読み込ませない
|
|
89
|
+
...(opts.inheritSettings ? {} : { settingSources: ["project", "local"] }),
|
|
90
|
+
settings: {
|
|
91
|
+
// ユーザーや上位ディレクトリの CLAUDE.md・AGENTS.md などを読み込ませない
|
|
92
|
+
...(opts.inheritSettings ? {} : { claudeMdExcludes: CLAUDE_MD_EXCLUDES }),
|
|
93
|
+
// ユーザー設定で切っていても、指定があれば有効にする(ここで渡す値は、ユーザー・project の設定より優先される)
|
|
94
|
+
autoMemoryEnabled: opts.memory,
|
|
95
|
+
// ツールを実行するたびに承認を求める。指定しないと、claude-agent-acp は auto モード(分類器による自動承認)で始める。
|
|
96
|
+
// mcp__chat だけは承認なし(送り先は中継が、登録したルームと許可した DM に限る。ADR 0008)。
|
|
97
|
+
// どちらも、設定の読み込みを管理者の環境に合わせても外さない(ADR 0017)
|
|
98
|
+
permissions: { defaultMode: "default", allow: ["mcp__chat"] },
|
|
99
|
+
},
|
|
100
|
+
}
|
|
101
|
+
}
|
|
102
|
+
|
|
103
|
+
/**
|
|
104
|
+
* 作業ディレクトリに opencode.json を書く。管理者が指定した作業ディレクトリでは、管理者の書いた設定を上書きしない(ADR 0017)。
|
|
105
|
+
* そこでは、前回の起動で中継が書いたもの(中身が同じもの)だけを、そのまま使う
|
|
106
|
+
*/
|
|
107
|
+
function writeOpencodeConfig(cwd: string, model: string | undefined, specified: boolean): void {
|
|
108
|
+
// 既定ではほぼすべてを承認なしで実行するので、すべて尋ねたうえで、読み取りとチャット用ツールだけを許す。
|
|
109
|
+
// 組み込みの build エージェントの規則(* を許可)より後に効くよう、エージェントの規則として書く(後の規則ほど優先される)
|
|
110
|
+
const config = {
|
|
111
|
+
$schema: "https://opencode.ai/config.json",
|
|
112
|
+
...(model ? { model } : {}),
|
|
113
|
+
agents: {
|
|
114
|
+
build: {
|
|
115
|
+
permissions: [
|
|
116
|
+
{ action: "*", resource: "*", effect: "ask" },
|
|
117
|
+
...["read", "glob", "grep", "subagent"].map((action) => ({ action, resource: "*", effect: "allow" })),
|
|
118
|
+
{ action: "chat_*", resource: "*", effect: "allow" },
|
|
119
|
+
// 選択肢での質問は中継しない。チャットで尋ねさせる
|
|
120
|
+
{ action: "question", resource: "*", effect: "deny" },
|
|
121
|
+
// 作業ディレクトリの外は、読み取りでも尋ねる
|
|
122
|
+
{ action: "external_directory", resource: "*", effect: "ask" },
|
|
123
|
+
],
|
|
124
|
+
},
|
|
125
|
+
},
|
|
126
|
+
}
|
|
127
|
+
const text = JSON.stringify(config, null, 2) + "\n"
|
|
128
|
+
const path = join(cwd, "opencode.json")
|
|
129
|
+
if (specified) {
|
|
130
|
+
// opencode.jsonc は、中継の書く権限の設定より優先されるかもしれない(未確認)
|
|
131
|
+
if (existsSync(join(cwd, "opencode.jsonc"))) throw new Error(`作業ディレクトリに opencode.jsonc があるため、起動しません: ${cwd}`)
|
|
132
|
+
if (existsSync(path) && readFileSync(path, "utf8") !== text) {
|
|
133
|
+
throw new Error(`作業ディレクトリの opencode.json が中継の書く内容と違うため、起動しません(上書きしません。中継が前回書いたものなら、消してから起動してください): ${path}`)
|
|
134
|
+
}
|
|
135
|
+
}
|
|
136
|
+
writeFileSync(path, text)
|
|
137
|
+
}
|
|
@@ -0,0 +1,327 @@
|
|
|
1
|
+
// ハーネスを ACP で動かす(ADR 0006)。中継が ACP のクライアントになり、ハーネスを子プロセスとして起動する。
|
|
2
|
+
// セッションは 1 つ。チャット用ツールの MCP サーバーを session/new(再開なら session/resume か session/load)で渡し、発言は session/prompt で渡し、作業中に届いた発言は、対応していれば _session/steering で差し込む(ADR 0018)。
|
|
3
|
+
|
|
4
|
+
import { dirname, isAbsolute, sep } from "node:path"
|
|
5
|
+
import * as acp from "@agentclientprotocol/sdk"
|
|
6
|
+
import type { Log, PermissionRequest, Progress, Session, Verdict } from "../core/relay.ts"
|
|
7
|
+
import { RotatingFile } from "./log-file.ts"
|
|
8
|
+
import { protectedBy, targetsOf } from "./protect.ts"
|
|
9
|
+
import { VERSION } from "../version.ts"
|
|
10
|
+
|
|
11
|
+
export type HarnessConfig = {
|
|
12
|
+
command: string[]
|
|
13
|
+
env?: Record<string, string>
|
|
14
|
+
/** false のときは env で明示した変数だけを子に渡す。 */
|
|
15
|
+
inheritEnv?: false
|
|
16
|
+
/** 操作と対象を省略した承認を受け付けないハーネスに指定する。 */
|
|
17
|
+
requireFullPermissionDisplay?: true
|
|
18
|
+
/** 中継の環境変数のうち、ハーネスに渡さないもの(RELAY_*・DOTENV_* のほかに) */
|
|
19
|
+
withheld?: string[]
|
|
20
|
+
/** セッションの作業ディレクトリ(絶対パス) */
|
|
21
|
+
cwd: string
|
|
22
|
+
mcp: { url: string; token: string }
|
|
23
|
+
/** 再開するセッションの ID。なければ新しく作る。作業ディレクトリ(cwd)で作ったセッションだけを再開する */
|
|
24
|
+
sessionId?: string
|
|
25
|
+
/** session/new・session/resume・session/load の _meta(ハーネス固有の設定。Claude Code の設定の読み込みなど) */
|
|
26
|
+
meta?: Record<string, unknown>
|
|
27
|
+
/**
|
|
28
|
+
* セッションのモード(ACP の session mode)。違うモードで始まったら、最初の発言の前に切り替える。安全境界。
|
|
29
|
+
* 再開でも会話記録のモードは引き継がない(権限は会話ではなく、中継の起動設定に属する。docs/relay.md)
|
|
30
|
+
*/
|
|
31
|
+
mode?: string
|
|
32
|
+
/** ハーネスの stderr を追記するファイル。画面には出さない。10MB を超えそうになったら <path>.1 に移して新しく始める */
|
|
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[]
|
|
45
|
+
}
|
|
46
|
+
|
|
47
|
+
const MAX_STDERR_BYTES = 10 * 1024 * 1024
|
|
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
|
+
|
|
54
|
+
/**
|
|
55
|
+
* ハーネスの stdin を、ACP の SDK に渡す stream にする。書き込みの失敗(ハーネスが読まずに終了したときの EPIPE など)は
|
|
56
|
+
* Promise で返し、SDK に接続を閉じさせる。受けずに捨てると、受け手のない reject になり、中継のプロセスごと終了する
|
|
57
|
+
*/
|
|
58
|
+
export function stdinStream(sink: Bun.FileSink): WritableStream<Uint8Array> {
|
|
59
|
+
return new WritableStream<Uint8Array>({
|
|
60
|
+
async write(chunk) {
|
|
61
|
+
await sink.write(chunk)
|
|
62
|
+
await sink.flush()
|
|
63
|
+
},
|
|
64
|
+
async close() {
|
|
65
|
+
await sink.end()
|
|
66
|
+
},
|
|
67
|
+
})
|
|
68
|
+
}
|
|
69
|
+
|
|
70
|
+
export async function startHarness(
|
|
71
|
+
cfg: HarnessConfig,
|
|
72
|
+
onPermission: (req: PermissionRequest) => Promise<Verdict>,
|
|
73
|
+
log: Log,
|
|
74
|
+
): Promise<{ sessionId: string; session: Session; exited: Promise<number>; stop: () => void }> {
|
|
75
|
+
// stderr はファイルへ直接つながず、中継が受けて書く。サイズを数えてローテーションするため
|
|
76
|
+
const stderrLog = new RotatingFile(cfg.stderrPath, MAX_STDERR_BYTES)
|
|
77
|
+
const proc = Bun.spawn(cfg.command, {
|
|
78
|
+
cwd: cfg.cwd,
|
|
79
|
+
// 中継の秘密情報(LINE のトークンなど)をハーネスへ渡さない。渡すと、エージェントが送信先の制限を迂回できる
|
|
80
|
+
env: cfg.inheritEnv === false ? (cfg.env ?? {}) : { ...withoutRelaySecrets(process.env, cfg.withheld ?? []), ...cfg.env },
|
|
81
|
+
stdin: "pipe",
|
|
82
|
+
stdout: "pipe",
|
|
83
|
+
stderr: "pipe",
|
|
84
|
+
})
|
|
85
|
+
const stderrDrained = (async () => {
|
|
86
|
+
let failed = false
|
|
87
|
+
try {
|
|
88
|
+
// 書けなくても読み続ける。読むのをやめると、パイプが詰まってハーネスが止まる
|
|
89
|
+
for await (const chunk of proc.stderr) {
|
|
90
|
+
try {
|
|
91
|
+
stderrLog.write(chunk)
|
|
92
|
+
} catch (err) {
|
|
93
|
+
if (!failed) log.error("harness.log に書けませんでした", { error: String(err) })
|
|
94
|
+
failed = true
|
|
95
|
+
}
|
|
96
|
+
}
|
|
97
|
+
} finally {
|
|
98
|
+
stderrLog.close()
|
|
99
|
+
}
|
|
100
|
+
})()
|
|
101
|
+
const stream = acp.ndJsonStream(stdinStream(proc.stdin), proc.stdout as ReadableStream<Uint8Array>)
|
|
102
|
+
|
|
103
|
+
let turnText = ""
|
|
104
|
+
// session/load が応答の前に再送する履歴は、新しい出力として扱わない
|
|
105
|
+
let replaying = false
|
|
106
|
+
/** ツールの表示名。更新(tool_call_update)に名前がないときに使う */
|
|
107
|
+
const toolTitles = new Map<string, string>()
|
|
108
|
+
const app = acp
|
|
109
|
+
.client({ name: "agent-chat-relay" })
|
|
110
|
+
.onRequest("session/request_permission", ({ params }) => answerPermission(params, cfg, onPermission, turnText, log))
|
|
111
|
+
.onNotification("session/update", ({ params }) => {
|
|
112
|
+
if (replaying) return
|
|
113
|
+
const u = params.update
|
|
114
|
+
if (u.sessionUpdate === "agent_message_chunk" && u.content.type === "text") turnText += u.content.text
|
|
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)
|
|
119
|
+
})
|
|
120
|
+
|
|
121
|
+
const ready = Promise.withResolvers<{ sessionId: string; session: Session }>()
|
|
122
|
+
const done = Promise.withResolvers<void>()
|
|
123
|
+
void app
|
|
124
|
+
.connectWith(stream, async (ctx) => {
|
|
125
|
+
const init = await ctx.request("initialize", {
|
|
126
|
+
protocolVersion: acp.PROTOCOL_VERSION,
|
|
127
|
+
clientCapabilities: {},
|
|
128
|
+
clientInfo: { name: "agent-chat-relay", version: VERSION },
|
|
129
|
+
})
|
|
130
|
+
if (!init.agentCapabilities?.mcpCapabilities?.http) {
|
|
131
|
+
throw new Error("このハーネスは HTTP の MCP サーバーに対応していません")
|
|
132
|
+
}
|
|
133
|
+
const { sessionId, modes, start } = await openSession(ctx, init.agentCapabilities, cfg, log, (on) => (replaying = on))
|
|
134
|
+
let mode = modes?.currentModeId
|
|
135
|
+
if (cfg.mode && mode !== cfg.mode) {
|
|
136
|
+
if (!modes?.availableModes.some((m) => m.id === cfg.mode)) throw new Error(`モード ${cfg.mode} を使えません(今は ${mode})`)
|
|
137
|
+
await ctx.request("session/set_mode", { sessionId, modeId: cfg.mode })
|
|
138
|
+
log.info(`モードを ${mode} から ${cfg.mode} に切り替えました`)
|
|
139
|
+
mode = cfg.mode
|
|
140
|
+
}
|
|
141
|
+
const steering = (init._meta as { steering?: { supported?: unknown } } | null | undefined)?.steering?.supported === true
|
|
142
|
+
log.info(start === "new" ? "セッションを開始しました" : "セッションを再開しました", {
|
|
143
|
+
sessionId,
|
|
144
|
+
start,
|
|
145
|
+
agent: init.agentInfo?.name,
|
|
146
|
+
version: init.agentInfo?.version,
|
|
147
|
+
protocol: init.protocolVersion,
|
|
148
|
+
mode,
|
|
149
|
+
steering,
|
|
150
|
+
})
|
|
151
|
+
const session: Session = {
|
|
152
|
+
async prompt(text) {
|
|
153
|
+
turnText = ""
|
|
154
|
+
const res = await ctx.request("session/prompt", { sessionId, prompt: [{ type: "text", text }] })
|
|
155
|
+
// reply を使わずに書いた文章はチャットに届かない。気づけるようにログに出す
|
|
156
|
+
if (turnText.trim()) log.info("ターンの出力(チャットには届いていない)", { stopReason: res.stopReason, text: turnText.trim().slice(0, 300) })
|
|
157
|
+
},
|
|
158
|
+
// 標準化前の拡張(ADR 0018)。宣言しているハーネスでだけ使う
|
|
159
|
+
...(steering ? { steer: (text: string) => steer(ctx, sessionId, text, log) } : {}),
|
|
160
|
+
}
|
|
161
|
+
ready.resolve({ sessionId, session })
|
|
162
|
+
await done.promise
|
|
163
|
+
})
|
|
164
|
+
.catch((err) => {
|
|
165
|
+
ready.reject(err)
|
|
166
|
+
// 始められなかったハーネスを残さない
|
|
167
|
+
proc.kill()
|
|
168
|
+
})
|
|
169
|
+
|
|
170
|
+
// stderr を書き終えてから終了を通知する(異常終了のとき、呼び出し側がログの末尾を読む)
|
|
171
|
+
const exited = Promise.all([proc.exited, stderrDrained.catch(() => {})]).then(([code]) => {
|
|
172
|
+
done.resolve()
|
|
173
|
+
ready.reject(new Error(`ハーネスが終了しました(終了コード ${code})`))
|
|
174
|
+
return code
|
|
175
|
+
})
|
|
176
|
+
return { ...await ready.promise, exited, stop: () => proc.kill() }
|
|
177
|
+
}
|
|
178
|
+
|
|
179
|
+
type Opened = { sessionId: string; modes?: acp.SessionModeState | null; start: "new" | "resume" | "load" }
|
|
180
|
+
|
|
181
|
+
/**
|
|
182
|
+
* セッションを新しく作るか、cfg.sessionId のセッションを再開する(docs/relay.md の「セッションの再開」)。
|
|
183
|
+
* resume を優先し(履歴を再送しない)、失敗しても load には切り替えず、新しくも作らない
|
|
184
|
+
*/
|
|
185
|
+
async function openSession(
|
|
186
|
+
ctx: acp.ClientContext,
|
|
187
|
+
caps: acp.AgentCapabilities | undefined,
|
|
188
|
+
cfg: HarnessConfig,
|
|
189
|
+
log: Log,
|
|
190
|
+
setReplaying: (on: boolean) => void,
|
|
191
|
+
): Promise<Opened> {
|
|
192
|
+
// 再開でも、起動ごとの MCP の認証情報と _meta(設定の読み込み)を毎回渡す
|
|
193
|
+
const setup: acp.NewSessionRequest = {
|
|
194
|
+
cwd: cfg.cwd,
|
|
195
|
+
mcpServers: [{ type: "http", name: "chat", url: cfg.mcp.url, headers: [{ name: "Authorization", value: `Bearer ${cfg.mcp.token}` }] }],
|
|
196
|
+
...(cfg.meta ? { _meta: cfg.meta } : {}),
|
|
197
|
+
}
|
|
198
|
+
const sessionId = cfg.sessionId
|
|
199
|
+
if (sessionId === undefined) return { ...(await ctx.request("session/new", setup)), start: "new" }
|
|
200
|
+
|
|
201
|
+
const start = caps?.sessionCapabilities?.resume ? "resume" : caps?.loadSession ? "load" : undefined
|
|
202
|
+
if (!start) throw new Error("このハーネスは、セッションの再開(session/resume・session/load)に対応していません")
|
|
203
|
+
// 作業ディレクトリで作ったセッションだけを再開する。一覧で確認できなければハーネスに任せる
|
|
204
|
+
if (!caps?.sessionCapabilities?.list) {
|
|
205
|
+
log.info("ハーネスがセッションの一覧に対応していないため、作業ディレクトリのセッションかどうかは確かめずに再開します", { sessionId })
|
|
206
|
+
} else if (!(await listed(ctx, sessionId, cfg.cwd))) {
|
|
207
|
+
throw new Error(`作業ディレクトリのセッションに ${sessionId} がありません。再開できるのは、中継の作業ディレクトリ(${cfg.cwd})で作ったセッションだけです`)
|
|
208
|
+
}
|
|
209
|
+
try {
|
|
210
|
+
if (start === "resume") return { sessionId, modes: (await ctx.request("session/resume", { sessionId, ...setup })).modes, start }
|
|
211
|
+
setReplaying(true)
|
|
212
|
+
try {
|
|
213
|
+
return { sessionId, modes: (await ctx.request("session/load", { sessionId, ...setup }))?.modes, start }
|
|
214
|
+
} finally {
|
|
215
|
+
setReplaying(false)
|
|
216
|
+
}
|
|
217
|
+
} catch (err) {
|
|
218
|
+
throw new Error(`セッション ${sessionId} を再開できませんでした(session/${start}): ${err instanceof Error ? err.message : String(err)}`)
|
|
219
|
+
}
|
|
220
|
+
}
|
|
221
|
+
|
|
222
|
+
/** 作業ディレクトリを cwd にした session/list に、その ID があるか。全ページを読む */
|
|
223
|
+
/**
|
|
224
|
+
* 作業中のターンに発言を差し込む(`_session/steering`。ADR 0018)。
|
|
225
|
+
* idleBehavior: promptRequired を付け、ターンが終わっていたら、ハーネスに新しいターンを始めさせず、発言を中継の手元に残す
|
|
226
|
+
*/
|
|
227
|
+
async function steer(ctx: acp.ClientContext, sessionId: string, text: string, log: Log): Promise<boolean> {
|
|
228
|
+
const res = await ctx.request<{ outcome?: string }>("_session/steering", {
|
|
229
|
+
sessionId,
|
|
230
|
+
prompt: [{ type: "text", text }],
|
|
231
|
+
_meta: { steering: { idleBehavior: "promptRequired" } },
|
|
232
|
+
})
|
|
233
|
+
if (res?.outcome === "injected") {
|
|
234
|
+
log.info("作業中のターンに、届いた発言を差し込みました")
|
|
235
|
+
return true
|
|
236
|
+
}
|
|
237
|
+
if (res?.outcome === "promptRequired") return false
|
|
238
|
+
// それ以外(startedNewTurn など)は、発言がどう扱われたか中継からは分からない
|
|
239
|
+
throw new Error(`_session/steering の結果が想定外です:${JSON.stringify(res)}`)
|
|
240
|
+
}
|
|
241
|
+
|
|
242
|
+
async function listed(ctx: acp.ClientContext, sessionId: string, cwd: string): Promise<boolean> {
|
|
243
|
+
const seen = new Set<string>()
|
|
244
|
+
let cursor: string | undefined
|
|
245
|
+
for (;;) {
|
|
246
|
+
const page = await ctx.request("session/list", { cwd, ...(cursor ? { cursor } : {}) })
|
|
247
|
+
if (page.sessions.some((s) => s.sessionId === sessionId)) return true
|
|
248
|
+
cursor = page.nextCursor ?? undefined
|
|
249
|
+
// 最後のページか、同じカーソルが戻ってきたら終える
|
|
250
|
+
if (cursor === undefined || seen.has(cursor)) return false
|
|
251
|
+
seen.add(cursor)
|
|
252
|
+
}
|
|
253
|
+
}
|
|
254
|
+
|
|
255
|
+
function withoutRelaySecrets(env: Record<string, string | undefined>, withheld: string[]): Record<string, string | undefined> {
|
|
256
|
+
return Object.fromEntries(Object.entries(env).filter(([k]) => !/^(RELAY_|DOTENV_)/.test(k) && !withheld.includes(k)))
|
|
257
|
+
}
|
|
258
|
+
|
|
259
|
+
/**
|
|
260
|
+
* 承認者に示す「常に許可」の選択肢(ADR 0015)。複数あれば先頭の 1 つ。
|
|
261
|
+
* モードの切り替え(Claude Code では計画の承認から auto などに移る)と、ファイルの編集(セッションのあいだ編集をすべて許す)には示さない
|
|
262
|
+
*/
|
|
263
|
+
export function alwaysOption(kind: acp.ToolKind | null | undefined, options: acp.PermissionOption[]): acp.PermissionOption | undefined {
|
|
264
|
+
if (kind === "switch_mode" || kind === "edit") return undefined
|
|
265
|
+
return options.find((o) => o.kind === "allow_always")
|
|
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
|
+
}
|
|
@@ -0,0 +1,34 @@
|
|
|
1
|
+
// ハーネスの stderr を書くファイル。
|
|
2
|
+
|
|
3
|
+
import { closeSync, fstatSync, mkdirSync, openSync, renameSync, writeSync } from "node:fs"
|
|
4
|
+
import { dirname } from "node:path"
|
|
5
|
+
|
|
6
|
+
/** 追記用のファイル。max バイトを超えそうになったら <path>.1 に移し(前の .1 は消える)、新しく始める */
|
|
7
|
+
export class RotatingFile {
|
|
8
|
+
private fd: number
|
|
9
|
+
private size: number
|
|
10
|
+
|
|
11
|
+
constructor(
|
|
12
|
+
private readonly path: string,
|
|
13
|
+
private readonly max: number,
|
|
14
|
+
) {
|
|
15
|
+
mkdirSync(dirname(path), { recursive: true, mode: 0o700 })
|
|
16
|
+
this.fd = openSync(path, "a", 0o600)
|
|
17
|
+
this.size = fstatSync(this.fd).size
|
|
18
|
+
}
|
|
19
|
+
|
|
20
|
+
write(chunk: Uint8Array): void {
|
|
21
|
+
if (this.size > 0 && this.size + chunk.length > this.max) {
|
|
22
|
+
closeSync(this.fd)
|
|
23
|
+
renameSync(this.path, `${this.path}.1`)
|
|
24
|
+
this.fd = openSync(this.path, "a", 0o600)
|
|
25
|
+
this.size = 0
|
|
26
|
+
}
|
|
27
|
+
writeSync(this.fd, chunk)
|
|
28
|
+
this.size += chunk.length
|
|
29
|
+
}
|
|
30
|
+
|
|
31
|
+
close(): void {
|
|
32
|
+
closeSync(this.fd)
|
|
33
|
+
}
|
|
34
|
+
}
|
|
@@ -0,0 +1,51 @@
|
|
|
1
|
+
import { homedir } from "node:os"
|
|
2
|
+
import { join, resolve } from "node:path"
|
|
3
|
+
import { fileURLToPath } from "node:url"
|
|
4
|
+
import type { Log, PermissionRequest, Verdict } from "../../core/relay.ts"
|
|
5
|
+
import { BUN_ISOLATED, type HarnessOptions } from "../config.ts"
|
|
6
|
+
import { startHarness, type HarnessConfig, type HarnessHooks } from "../harness.ts"
|
|
7
|
+
import { preparePiState } from "./state.ts"
|
|
8
|
+
|
|
9
|
+
const ADAPTER = fileURLToPath(new URL("../../vendor/pi/adapter.js", import.meta.url))
|
|
10
|
+
|
|
11
|
+
type PiLaunch = Pick<HarnessConfig, "cwd" | "sessionId" | "stderrPath"> & { home: string; options: HarnessOptions }
|
|
12
|
+
|
|
13
|
+
/** コネクターを起動する前に設定・台帳を確認する。 */
|
|
14
|
+
export function preparePiLaunch({ home, options, cwd, sessionId, stderrPath }: PiLaunch, log: Log) {
|
|
15
|
+
if (options.memory) throw new Error("pi では自動メモリを指定できません")
|
|
16
|
+
const state = preparePiState(home, cwd)
|
|
17
|
+
if (sessionId !== undefined) state.requireSession(sessionId)
|
|
18
|
+
state.checkModelFiles()
|
|
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>, hooks: HarnessHooks = {}) => {
|
|
21
|
+
if (inherited) log.error("警告:pi の端末・プロジェクト設定を引き継ぎます。信頼済みの拡張などが実行承認を通らずに動くことがあります")
|
|
22
|
+
const launched = await startHarness({
|
|
23
|
+
command: [...BUN_ISOLATED, ADAPTER],
|
|
24
|
+
cwd: state.workspace, mcp, sessionId, stderrPath, ...hooks,
|
|
25
|
+
inheritEnv: false,
|
|
26
|
+
requireFullPermissionDisplay: true,
|
|
27
|
+
env: {
|
|
28
|
+
HOME: state.childHome,
|
|
29
|
+
PATH: "/usr/bin:/bin",
|
|
30
|
+
TMPDIR: state.temp,
|
|
31
|
+
PI_OFFLINE: "1",
|
|
32
|
+
PI_TELEMETRY: "0",
|
|
33
|
+
PI_ACP_MANAGED_CHAT_WORKSPACE: state.workspace,
|
|
34
|
+
// pi の承認依頼はパスを文の中にしか持たず、中継の本体では守れない。拡張で照合する(ADR 0030)
|
|
35
|
+
PI_ACP_MANAGED_PROTECT: JSON.stringify(hooks.protect ?? []),
|
|
36
|
+
PI_CODING_AGENT_DIR: state.agentDir,
|
|
37
|
+
...(inherited ? { PI_ACP_INHERITED_AGENT_DIR: inherited } : {}),
|
|
38
|
+
},
|
|
39
|
+
}, onPermission, log)
|
|
40
|
+
if (sessionId === undefined) {
|
|
41
|
+
try {
|
|
42
|
+
state.registerSession(launched.sessionId)
|
|
43
|
+
} catch {
|
|
44
|
+
launched.stop()
|
|
45
|
+
await launched.exited
|
|
46
|
+
throw new Error("中継の pi セッション台帳に記録できませんでした")
|
|
47
|
+
}
|
|
48
|
+
}
|
|
49
|
+
return launched
|
|
50
|
+
}
|
|
51
|
+
}
|