tailii-host 0.1.0 → 0.3.0

package/dist/codex/codexNativeTurnController.js

@@ -0,0 +1,673 @@
+// Codex App Server の長寿命 thread 接続、native approval、turn/start を Tailii へ結線する。
+import * as net from "node:net";
+import { decodeControlMessage, encodeControlMessage, PROTOCOL_V1, PROTOCOL_V2, } from "../protocol.js";
+import { resolveSocketPath } from "../shared/socketPath.js";
+import { sleep } from "../shared/sleep.js";
+import { codexItemToolActivities, codexPlanUpdateActivity, toolActivityContentKey, toolActivityMessage, } from "./codexToolActivity.js";
+import { CodexSubagentTracker } from "./codexSubagentTracker.js";
+const TITLE_GENERATION_MAX_ATTEMPTS = 3;
+const TITLE_GENERATION_RETRY_BASE_MS = 250;
+function isDefinitiveSteerRejection(error) {
+    if (!(error instanceof Error))
+        return false;
+    const message = error.message.toLowerCase();
+    return [
+        "no active turn to steer",
+        "expected active turn id",
+        "cannot steer a review turn",
+        "cannot steer a compact turn",
+        "active turn not steerable",
+        "turn already completed",
+        "turn has already completed",
+    ].some((marker) => message.includes(marker));
+}
+/** App Server の競合エラーから、その時点で実際に active だった turn ID を取り出す。 */
+function activeTurnIdFromMismatch(error) {
+    if (!(error instanceof Error))
+        return null;
+    const match = error.message.match(/expected active turn id [A-Za-z0-9_-]+ but found ([A-Za-z0-9_-]+)/i);
+    return match?.[1] ?? null;
+}
+/** Codex thread ID はUUIDv7。先頭48bitのUnixミリ秒を履歴snapshotの安定時刻に使う。 */
+function codexThreadIdTimestampMs(threadId) {
+    const compact = threadId.replaceAll("-", "");
+    if (!/^[0-9a-fA-F]{32}$/.test(compact) || compact[12]?.toLowerCase() !== "7")
+        return null;
+    const value = Number.parseInt(compact.slice(0, 12), 16);
+    return Number.isSafeInteger(value) && value > 0 ? value : null;
+}
+/**
+ * Tailii から開始した Codex turn を同じ App Server 接続で保持する。
+ * server-initiated approval は既存 per-session serve socket へ渡すため、Codex hook は不要。
+ */
+export class CodexNativeTurnController {
+    appServer;
+    approvalBroker;
+    onProcessing;
+    onModel;
+    onTokenUsage;
+    onQuestion;
+    onQuestionDismiss;
+    onChatItem;
+    onDisconnect;
+    onThreadTitle;
+    open = new Map();
+    pendingUserInput = new Map();
+    constructor(options) {
+        this.appServer = options.appServer;
+        this.approvalBroker = options.approvalBroker ?? requestCodexApprovalViaBroker;
+        this.onProcessing = options.onProcessing ?? (() => { });
+        this.onModel = options.onModel ?? (() => { });
+        this.onTokenUsage = options.onTokenUsage ?? (() => { });
+        this.onQuestion = options.onQuestion ?? (() => { });
+        this.onQuestionDismiss = options.onQuestionDismiss ?? (() => { });
+        this.onChatItem = options.onChatItem ?? (() => { });
+        this.onDisconnect = options.onDisconnect ?? (() => { });
+        this.onThreadTitle = options.onThreadTitle ?? (() => { });
+    }
+    async subscribeSession(options) {
+        const opened = await this.threadFor(options.session, options.threadId, options.cwd);
+        const itemIds = new Set();
+        const contentCounts = new Map();
+        for (const item of opened.thread.initialItems ?? []) {
+            const id = item["id"];
+            if (typeof id === "string" && id.length > 0)
+                itemIds.add(id);
+            const payload = codexItemToChatOutput(item);
+            const key = payload === null ? null : chatContentKey(payload);
+            if (key !== null)
+                contentCounts.set(key, (contentCounts.get(key) ?? 0) + 1);
+        }
+        return {
+            itemIds,
+            contentCounts,
+            liveSubscribed: opened.thread.liveSubscriptionReady !== false,
+        };
+    }
+    async startTurn(options) {
+        const opened = await this.threadFor(options.session, options.threadId, options.cwd);
+        this.onProcessing(options.session, "active");
+        try {
+            // 未materialize fallback 接続は、別 client の実行中 turn を初期 snapshot で
+            // 復元できない。新規 turn/start の前に rollout を読み直し、既存 turn が
+            // materialize 済みなら steer へ戻す。undefined（まだ未生成）だけは従来どおり開始する。
+            if (opened.activeTurnId === null && opened.thread.liveSubscriptionReady === false) {
+                const refreshedTurnId = await opened.thread.readActiveTurnId?.();
+                if (refreshedTurnId !== undefined)
+                    opened.activeTurnId = refreshedTurnId;
+            }
+            const activeTurnId = opened.activeTurnId;
+            if (activeTurnId !== null) {
+                try {
+                    await opened.thread.steerTurn(activeTurnId, options.text, options.clientUserMessageId);
+                    this.generateThreadTitle(opened, options.session, options.text);
+                    return activeTurnId;
+                }
+                catch (error) {
+                    // 接続切替などでローカル ID だけが古い場合、App Server は未受理を明示しつつ
+                    // 実際の active ID を返す。同じ入力をその turn へ一度だけ steer し直せる。
+                    const currentTurnId = activeTurnIdFromMismatch(error);
+                    if (currentTurnId !== null && currentTurnId !== activeTurnId) {
+                        opened.activeTurnId = currentTurnId;
+                        await opened.thread.steerTurn(currentTurnId, options.text, options.clientUserMessageId);
+                        this.generateThreadTitle(opened, options.session, options.text);
+                        return currentTurnId;
+                    }
+                    // App Serverが明示的に「このturnへはsteerできない」と拒否した場合だけ、新規turnへ
+                    // 切り替える。timeout/切断はsteer受理済みか不明なので、turn/startすると二重実行に
+                    // なり得る。到達不明は上位へ返し、clientUserMessageId receiptで後から確定させる。
+                    if (!isDefinitiveSteerRejection(error))
+                        throw error;
+                }
+            }
+            const turnId = await opened.thread.startTurn(options.text, options.clientUserMessageId, options.effort, options.sandbox, options.approvalPolicy);
+            opened.activeTurnId = turnId;
+            this.generateThreadTitle(opened, options.session, options.text);
+            return turnId;
+        }
+        catch (error) {
+            this.onProcessing(options.session, "done");
+            throw error;
+        }
+    }
+    generateThreadTitle(opened, session, prompt) {
+        if (!opened.titleGenerationPending || this.appServer.generateThreadTitle === undefined)
+            return;
+        opened.titleGenerationPending = false;
+        void this.generateThreadTitleWithRetry({
+            threadId: opened.threadId,
+            cwd: opened.cwd,
+            prompt,
+        }).then(({ result, attempts }) => this.onThreadTitle({
+            session,
+            threadId: opened.threadId,
+            title: result.title,
+            source: result.source,
+            attempts,
+            error: null,
+        }), (error) => this.onThreadTitle({
+            session,
+            threadId: opened.threadId,
+            title: null,
+            source: null,
+            attempts: TITLE_GENERATION_MAX_ATTEMPTS,
+            error: String(error),
+        }));
+    }
+    async generateThreadTitleWithRetry(options) {
+        const generate = this.appServer.generateThreadTitle;
+        if (generate === undefined) {
+            return { result: { title: null, source: null }, attempts: 0 };
+        }
+        let lastError = new Error("Codex title generation did not run");
+        for (let attempt = 1; attempt <= TITLE_GENERATION_MAX_ATTEMPTS; attempt += 1) {
+            try {
+                return { result: await generate.call(this.appServer, options), attempts: attempt };
+            }
+            catch (error) {
+                lastError = error;
+                if (attempt < TITLE_GENERATION_MAX_ATTEMPTS) {
+                    await sleep(TITLE_GENERATION_RETRY_BASE_MS * attempt);
+                }
+            }
+        }
+        throw new Error(`Codex title generation failed after ${TITLE_GENERATION_MAX_ATTEMPTS} attempts: ${String(lastError)}`);
+    }
+    async interruptTurn(session) {
+        const opened = this.open.get(session);
+        if (opened === undefined)
+            return;
+        if (opened.activeTurnId === null && opened.thread.liveSubscriptionReady === false) {
+            const refreshedTurnId = await opened.thread.readActiveTurnId?.();
+            if (refreshedTurnId !== undefined)
+                opened.activeTurnId = refreshedTurnId;
+        }
+        const activeTurnId = opened.activeTurnId;
+        if (activeTurnId === null)
+            return;
+        try {
+            await opened.thread.interruptTurn(activeTurnId);
+        }
+        catch (error) {
+            // 中断要求は「このセッションの現在の turn を止める」という利用者操作なので、
+            // App Server が返した実 ID へ同期して一度だけ再試行する。二度目の失敗は伝播する。
+            const currentTurnId = activeTurnIdFromMismatch(error);
+            if (currentTurnId === null || currentTurnId === activeTurnId)
+                throw error;
+            opened.activeTurnId = currentTurnId;
+            await opened.thread.interruptTurn(currentTurnId);
+        }
+    }
+    reconcileCompletedTurn(session, turnId) {
+        const opened = this.open.get(session);
+        if (opened === undefined || opened.activeTurnId !== turnId)
+            return false;
+        opened.activeTurnId = null;
+        this.onProcessing(session, "done");
+        this.resolvePendingQuestionsForSession(session);
+        return true;
+    }
+    closeSession(session) {
+        const opened = this.open.get(session);
+        if (opened === undefined)
+            return;
+        this.open.delete(session);
+        opened.thread.close();
+        this.resolvePendingQuestionsForSession(session);
+        this.onProcessing(session, "done");
+    }
+    close() {
+        for (const session of [...this.open.keys()])
+            this.closeSession(session);
+    }
+    /** iOS の既存 QuestionPromptSheet 回答を native requestUserInput response へ戻す。 */
+    answerQuestion(id, answers) {
+        const pending = this.pendingUserInput.get(id);
+        if (pending === undefined)
+            return false;
+        this.pendingUserInput.delete(id);
+        const wireAnswers = {};
+        for (const answer of answers) {
+            const question = pending.questions[answer.questionIndex];
+            if (question === undefined)
+                continue;
+            const questionId = question["id"];
+            if (typeof questionId !== "string")
+                continue;
+            const rawOptions = Array.isArray(question["options"])
+                ? question["options"].map(asRecord).filter((value) => value !== null)
+                : [];
+            const values = answer.selectedOptionIndexes.flatMap((index) => {
+                const label = rawOptions[index]?.["label"];
+                return typeof label === "string" ? [label] : [];
+            });
+            const other = answer.otherText?.trim();
+            if (other)
+                values.push(other);
+            wireAnswers[questionId] = { answers: values };
+        }
+        pending.resolve({ answers: wireAnswers });
+        this.onQuestionDismiss(pending.session, id);
+        return true;
+    }
+    async threadFor(session, threadId, cwd) {
+        const existing = this.open.get(session);
+        if (existing?.threadId === threadId)
+            return existing;
+        if (existing !== undefined)
+            this.closeSession(session);
+        const items = new Map();
+        const bufferedNotifications = [];
+        let notificationTargetReady = false;
+        const thread = await this.appServer.openThread({
+            threadId,
+            cwd,
+            onNotification: (notification) => {
+                if (!notificationTargetReady) {
+                    bufferedNotifications.push(notification);
+                    return;
+                }
+                this.handleNotification(session, threadId, items, notification);
+            },
+            onServerRequest: (request) => this.handleServerRequest(session, cwd, items, request),
+            onDisconnect: (error) => {
+                const current = this.open.get(session);
+                if (current?.threadId !== threadId)
+                    return;
+                this.open.delete(session);
+                this.resolvePendingQuestionsForSession(session);
+                this.onProcessing(session, "done");
+                this.onDisconnect(session, error);
+            },
+        });
+        const opened = {
+            threadId,
+            cwd,
+            thread,
+            items,
+            activeTurnId: thread.initialActiveTurnId ?? null,
+            // 名前と最初の user prompt は生成直前の thread/read を権威にする。これにより
+            // TUI attach / resume の競合で initialItems が先に埋まっても、新規会話の命名を落とさない。
+            titleGenerationPending: true,
+            planSeq: 0,
+            subagents: new CodexSubagentTracker(threadId),
+            subagentSeq: 0,
+        };
+        this.open.set(session, opened);
+        if (opened.activeTurnId !== null)
+            this.onProcessing(session, "active");
+        const restoredSubagents = [];
+        for (const item of thread.initialItems ?? []) {
+            restoredSubagents.push(...opened.subagents.ingestItem(item, Date.now()));
+        }
+        // thread/resume の親履歴は subAgentActivity.started だけを返し、子の完了イベントを
+        // 省略する版がある。現在の親 turn が active でも過去の子は既に idle になり得るため、
+        // 子 thread 自身の status を権威にする。読めない子だけは親も idle の場合に終端補正する。
+        const restoredNodeIds = [...new Set(restoredSubagents.map((node) => node.nodeId))];
+        const unresolvedNodeIds = new Set(restoredNodeIds);
+        if (thread.readThreadStatus !== undefined) {
+            const statuses = await Promise.all(restoredNodeIds.map(async (nodeId) => {
+                try {
+                    return { nodeId, status: await thread.readThreadStatus(nodeId) };
+                }
+                catch {
+                    return { nodeId, status: undefined };
+                }
+            }));
+            // status 読み取り中に切断・別threadへの切替が起きた場合、古いsnapshotを配信しない。
+            if (this.open.get(session) !== opened)
+                return opened;
+            for (const { nodeId, status: snapshot } of statuses) {
+                if (snapshot === undefined)
+                    continue;
+                unresolvedNodeIds.delete(nodeId);
+                restoredSubagents.push(...opened.subagents.ingestThreadSnapshot(nodeId, snapshot.status, snapshot.timestampMs ?? Date.now()));
+            }
+        }
+        if (opened.activeTurnId === null) {
+            for (const nodeId of unresolvedNodeIds) {
+                restoredSubagents.push(...opened.subagents.ingestThreadSnapshot(nodeId, { type: "idle" }, codexThreadIdTimestampMs(nodeId) ?? Date.now()));
+            }
+        }
+        const latestRestoredSubagents = new Map(restoredSubagents.map((node) => [node.nodeId, node]));
+        this.publishSubagentNodes(session, opened, [...latestRestoredSubagents.values()]);
+        // snapshot の構築中に届いたlive通知は、snapshot送出後に適用して必ず新しい状態を勝たせる。
+        notificationTargetReady = true;
+        for (const notification of bufferedNotifications) {
+            this.handleNotification(session, threadId, items, notification);
+        }
+        return opened;
+    }
+    handleNotification(session, threadId, items, notification) {
+        const params = asRecord(notification.params);
+        const notificationThreadId = params?.["threadId"];
+        // App Server が接続をまたいで通知する版でも、別 thread の lifecycle が
+        // このセッションの activeTurnId と processing 状態を上書きしないようにする。
+        // item は subagent thread 由来も表示対象になり得るため、ここでは一括破棄しない。
+        const lifecycleMatchesThread = typeof notificationThreadId !== "string" || notificationThreadId === threadId;
+        const current = this.open.get(session);
+        if (current?.threadId === threadId && notification.method === "thread/started") {
+            const startedThread = asRecord(params?.["thread"]);
+            if (startedThread !== null) {
+                this.publishSubagentNodes(session, current, current.subagents.ingestThreadStarted(startedThread, Date.now()));
+            }
+        }
+        if (current?.threadId === threadId && notification.method === "thread/status/changed") {
+            const changedThreadId = params?.["threadId"];
+            if (typeof changedThreadId === "string") {
+                this.publishSubagentNodes(session, current, current.subagents.ingestThreadStatus(changedThreadId, params?.["status"], Date.now()));
+            }
+        }
+        if (current?.threadId === threadId &&
+            (notification.method === "thread/closed" || notification.method === "thread/archived")) {
+            const closedThreadId = params?.["threadId"];
+            if (typeof closedThreadId === "string") {
+                this.publishSubagentNodes(session, current, current.subagents.ingestThreadClosed(closedThreadId, Date.now()));
+            }
+        }
+        if (notification.method === "item/started" || notification.method === "item/completed") {
+            const item = asRecord(params?.["item"]);
+            const id = item?.["id"];
+            if (item !== null && typeof id === "string")
+                items.set(id, item);
+            if (current?.threadId === threadId && item !== null) {
+                this.publishSubagentNodes(session, current, current.subagents.ingestItem(item, Date.now()));
+            }
+            if (notification.method === "item/completed" && item !== null && typeof id === "string") {
+                const payload = codexItemToChatOutput(item);
+                if (payload !== null)
+                    this.onChatItem({ session, itemId: id, payload });
+                // コマンド実行 / ファイル変更は tool_activity カードとして別 itemId で流す
+                // （同一 item から chat 本文と tool カードの両方が出ることは無いが、dedup 集合を分ける）。
+                codexItemToolActivities(item).forEach((activity, index) => {
+                    this.onChatItem({
+                        session,
+                        itemId: `${id}#tool-${index}`,
+                        payload: toolActivityMessage(activity),
+                    });
+                });
+            }
+        }
+        if (notification.method === "turn/plan/updated" && params !== null) {
+            const current = this.open.get(session);
+            if (current?.threadId === threadId) {
+                const turnId = typeof params["turnId"] === "string" ? params["turnId"] : "turn";
+                const itemId = `plan:${turnId}:${current.planSeq}`;
+                const activity = codexPlanUpdateActivity(itemId, params);
+                if (activity !== null) {
+                    current.planSeq += 1;
+                    this.onChatItem({ session, itemId, payload: toolActivityMessage(activity) });
+                }
+            }
+        }
+        if (notification.method === "turn/started" && lifecycleMatchesThread) {
+            const current = this.open.get(session);
+            const startedTurn = asRecord(params?.["turn"])?.["id"];
+            if (current?.threadId === threadId && typeof startedTurn === "string" && startedTurn.length > 0) {
+                current.activeTurnId = startedTurn;
+                this.onProcessing(session, "active");
+            }
+        }
+        if (notification.method === "turn/completed" && lifecycleMatchesThread) {
+            const current = this.open.get(session);
+            const completedTurn = asRecord(params?.["turn"])?.["id"];
+            if (current?.threadId === threadId &&
+                (typeof completedTurn !== "string" ||
+                    current.activeTurnId === null || current.activeTurnId === completedTurn)) {
+                const turnStatus = asRecord(params?.["turn"])?.["status"];
+                this.publishSubagentNodes(session, current, current.subagents.settleRunning(turnStatus === "failed" ? "error" : "completed", Date.now()));
+                current.activeTurnId = null;
+                this.onProcessing(session, "done");
+                this.resolvePendingQuestionsForSession(session);
+            }
+        }
+        if (notification.method === "thread/settings/updated") {
+            const settings = asRecord(params?.["threadSettings"]);
+            const model = settings?.["model"];
+            if (typeof model === "string" && model.length > 0)
+                this.onModel(session, model);
+        }
+        if (notification.method === "model/rerouted" && params?.["threadId"] === threadId) {
+            const model = params["toModel"];
+            if (typeof model === "string" && model.length > 0)
+                this.onModel(session, model);
+        }
+        if (notification.method === "thread/tokenUsage/updated") {
+            const tokenUsage = asRecord(params?.["tokenUsage"]);
+            const last = asRecord(tokenUsage?.["last"]);
+            const contextTokens = nonNegativeInteger(last?.["totalTokens"]);
+            if (contextTokens !== null) {
+                this.onTokenUsage(session, contextTokens, positiveInteger(tokenUsage?.["modelContextWindow"]));
+            }
+        }
+    }
+    publishSubagentNodes(session, opened, nodes) {
+        for (const node of nodes) {
+            const itemId = `subagent:${node.nodeId}:${opened.subagentSeq}`;
+            opened.subagentSeq += 1;
+            this.onChatItem({
+                session,
+                itemId,
+                payload: { type: "subagent_node", v: PROTOCOL_V2, node },
+            });
+        }
+    }
+    async handleServerRequest(session, fallbackCwd, items, request) {
+        if (request.method === "item/commandExecution/requestApproval" ||
+            request.method === "item/fileChange/requestApproval") {
+            const params = asRecord(request.params) ?? {};
+            const itemId = typeof params["itemId"] === "string" ? params["itemId"] : "unknown";
+            const item = items.get(itemId);
+            const command = typeof params["command"] === "string" ? params["command"] : null;
+            const reason = typeof params["reason"] === "string" ? params["reason"] : null;
+            const cwd = typeof params["cwd"] === "string" ? params["cwd"] : fallbackCwd;
+            const isCommand = request.method === "item/commandExecution/requestApproval";
+            const summary = isCommand
+                ? (command ?? reason ?? "コマンドの実行を許可しますか？")
+                : fileChangeSummary(item, reason);
+            const decision = await this.approvalBroker({
+                id: `codex:${String(params["threadId"] ?? "thread")}:${String(request.id)}`,
+                session,
+                tool: isCommand ? "Bash" : "Edit",
+                summary,
+                cwd,
+            });
+            return { decision: decision === "allow" ? "accept" : "decline" };
+        }
+        if (request.method === "item/tool/requestUserInput") {
+            const params = asRecord(request.params) ?? {};
+            const threadId = typeof params["threadId"] === "string" ? params["threadId"] : "thread";
+            const rawQuestions = Array.isArray(params["questions"])
+                ? params["questions"].map(asRecord).filter((value) => value !== null)
+                : [];
+            const id = `codex-question:${threadId}:${String(request.id)}`;
+            const questions = rawQuestions.map((question) => ({
+                header: typeof question["header"] === "string" ? question["header"] : "質問",
+                question: typeof question["question"] === "string" ? question["question"] : "入力してください",
+                multiSelect: false,
+                options: Array.isArray(question["options"])
+                    ? question["options"].flatMap((option) => {
+                        const record = asRecord(option);
+                        const label = record?.["label"];
+                        if (typeof label !== "string")
+                            return [];
+                        return [{
+                                label,
+                                description: typeof record?.["description"] === "string" ? record["description"] : "",
+                            }];
+                    })
+                    : [],
+            }));
+            this.onQuestion({ session, id, questions });
+            return new Promise((resolve) => {
+                this.pendingUserInput.set(id, {
+                    session,
+                    threadId,
+                    questions: rawQuestions,
+                    resolve,
+                });
+            });
+        }
+        if (request.method === "currentTime/read") {
+            return { currentTimeAt: Math.floor(Date.now() / 1000) };
+        }
+        throw new Error(`unsupported Codex App Server request: ${request.method}`);
+    }
+    resolvePendingQuestionsForSession(session) {
+        for (const [id, pending] of this.pendingUserInput) {
+            if (pending.session !== session)
+                continue;
+            this.pendingUserInput.delete(id);
+            pending.resolve({ answers: {} });
+            this.onQuestionDismiss(session, id);
+        }
+    }
+}
+/** rollout の event_msg(user_message / agent_message) と同じ表示範囲へ写像する。 */
+export function codexItemToChatOutput(item) {
+    const id = item["id"];
+    const type = item["type"];
+    if (typeof id !== "string" || id.length === 0)
+        return null;
+    if (type === "userMessage") {
+        const content = item["content"];
+        if (!Array.isArray(content))
+            return null;
+        const text = content.flatMap((part) => {
+            const record = asRecord(part);
+            return record?.["type"] === "text" && typeof record["text"] === "string"
+                ? [record["text"]]
+                : [];
+        }).join("\n");
+        if (text.length === 0)
+            return null;
+        return { type: "chat_output", v: PROTOCOL_V1, streamId: `codex-item-${id}`,
+            role: "user", text, eof: true };
+    }
+    if (type === "agentMessage") {
+        const phase = item["phase"];
+        if (phase !== undefined && phase !== "commentary" && phase !== "final_answer")
+            return null;
+        const text = item["text"];
+        if (typeof text !== "string" || text.length === 0)
+            return null;
+        return { type: "chat_output", v: PROTOCOL_V1, streamId: `codex-item-${id}`,
+            role: "assistant", text, eof: true };
+    }
+    return null;
+}
+export function chatContentKey(payload) {
+    // tool_activity は live（App Server item）と rollout（response_item / patch_apply_end）の
+    // 両系統から同じ内容で生成される。id は系統間で一致しないため内容キーで照合する。
+    if (payload.type === "tool_activity") {
+        return toolActivityContentKey(payload.activity);
+    }
+    if (payload.type !== "chat_output" || (payload.role !== "user" && payload.role !== "assistant")) {
+        return null;
+    }
+    return `${payload.role}\u0000${payload.text}`;
+}
+/** App Server approval を既存 iPhone serve channel へ流し、同じ id の決定だけを待つ。 */
+export async function requestCodexApprovalViaBroker(approval, options = {}) {
+    const socketPath = resolveSocketPath(approval.session);
+    const connectDeadline = Date.now() + (options.connectTimeoutMs ?? 10_000);
+    let socket = null;
+    do {
+        socket = await connectSocket(socketPath);
+        if (socket !== null)
+            break;
+        await sleep(200);
+    } while (Date.now() <= connectDeadline);
+    if (socket === null)
+        return "deny";
+    const request = encodeControlMessage({
+        type: "approval_request",
+        v: PROTOCOL_V1,
+        id: approval.id,
+        tool: approval.tool,
+        summary: approval.summary,
+        cwd: approval.cwd,
+    });
+    return new Promise((resolve) => {
+        let settled = false;
+        let buffer = "";
+        const finish = (decision) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            socket.destroy();
+            resolve(decision);
+        };
+        const timer = setTimeout(() => finish("deny"), options.decisionTimeoutMs ?? 540_000);
+        socket.on("data", (chunk) => {
+            buffer += chunk.toString("utf8");
+            while (true) {
+                const index = buffer.indexOf("\n");
+                if (index < 0)
+                    break;
+                const line = buffer.slice(0, index).replaceAll("\r", "");
+                buffer = buffer.slice(index + 1);
+                if (!line)
+                    continue;
+                try {
+                    const message = decodeControlMessage(line);
+                    if (message.type === "approval_decision" && message.id === approval.id) {
+                        finish(message.decision);
+                        return;
+                    }
+                }
+                catch {
+                    // channel_hello 以外の壊れた行も無視し、正しい決定を待つ。
+                }
+            }
+        });
+        socket.once("error", () => finish("deny"));
+        socket.once("close", () => finish("deny"));
+        socket.write(request + "\n");
+    });
+}
+function connectSocket(socketPath) {
+    return new Promise((resolve) => {
+        const socket = net.createConnection(socketPath);
+        let settled = false;
+        socket.once("connect", () => {
+            if (settled)
+                return;
+            settled = true;
+            resolve(socket);
+        });
+        socket.once("error", () => {
+            if (settled)
+                return;
+            settled = true;
+            socket.destroy();
+            resolve(null);
+        });
+    });
+}
+function fileChangeSummary(item, reason) {
+    const changes = item?.["changes"];
+    if (Array.isArray(changes)) {
+        const paths = changes
+            .map((change) => asRecord(change)?.["path"])
+            .filter((value) => typeof value === "string")
+            .slice(0, 4);
+        if (paths.length > 0)
+            return `ファイル変更: ${paths.join(", ")}`;
+    }
+    return reason ?? "ファイルの変更を許可しますか？";
+}
+function asRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : null;
+}
+function nonNegativeInteger(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : null;
+}
+function positiveInteger(value) {
+    const integer = nonNegativeInteger(value);
+    return integer !== null && integer > 0 ? integer : null;
+}
+//# sourceMappingURL=codexNativeTurnController.js.map