tailii-host 0.1.1 → 0.4.0

package/dist/codex/codexAppServer.js

@@ -0,0 +1,1297 @@
+// codexAppServer.ts
+// Tailii host が共有 Codex App Server を再利用・起動し、thread ID を先に確定する最小クライアント。
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import * as fs from "node:fs";
+import * as net from "node:net";
+import * as os from "node:os";
+import * as path from "node:path";
+import WebSocket from "ws";
+import { ensureDirectory0700 } from "../shared/paths.js";
+const THREAD_TITLE_MODEL = "gpt-5.6-luna";
+const THREAD_TITLE_PROMPT_MAX_LENGTH = 2_000;
+const THREAD_TITLE_MAX_LENGTH = 36;
+const THREAD_TITLE_FALLBACK_MAX_LENGTH = 60;
+const DEFAULT_TITLE_GENERATION_TIMEOUT_MS = 30_000;
+const THREAD_TITLE_OUTPUT_SCHEMA = {
+    type: "object",
+    properties: {
+        title: { type: "string", minLength: 1, maxLength: THREAD_TITLE_MAX_LENGTH },
+        description: { type: "string", minLength: 1 },
+    },
+    required: ["title", "description"],
+    additionalProperties: false,
+};
+const THREAD_TITLE_CONFIG = {
+    model_reasoning_effort: "low",
+    "features.enable_fanout": false,
+    "features.hooks": false,
+    "features.multi_agent": false,
+    "features.multi_agent_v2": false,
+    "features.plugins": false,
+    "features.tool_suggest": false,
+    "features.apps": false,
+    apps: {
+        _default: {
+            enabled: false,
+            destructive_enabled: false,
+            open_world_enabled: false,
+        },
+    },
+    web_search: "disabled",
+};
+/** Unix socket 上のWebSocketを使うJSON-RPC接続。 */
+class WebSocketCodexAppServerConnection {
+    socket;
+    requestTimeoutMs;
+    nextId = 1;
+    pending = new Map();
+    notificationHandlers = new Set();
+    serverRequestHandlers = new Set();
+    disconnectHandlers = new Set();
+    disconnected = false;
+    constructor(socket, requestTimeoutMs) {
+        this.socket = socket;
+        this.requestTimeoutMs = requestTimeoutMs;
+        socket.on("message", (data) => this.onMessage(data));
+        socket.on("close", () => this.disconnect(new Error("Codex App Server connection closed")));
+        socket.on("error", (error) => this.disconnect(error));
+    }
+    static connect(socketPath, requestTimeoutMs = 5_000) {
+        return new Promise((resolve, reject) => {
+            const socket = new WebSocket("ws://localhost/", {
+                createConnection: () => net.createConnection(socketPath),
+                // CodexのUnix control socketはWebSocket拡張を交渉しない。ws既定の
+                // permessage-deflateを送るとRust側がhandshakeを拒否する。
+                perMessageDeflate: false,
+            });
+            const onError = (error) => {
+                socket.removeListener("open", onOpen);
+                reject(error);
+            };
+            const onOpen = () => {
+                socket.removeListener("error", onError);
+                resolve(new WebSocketCodexAppServerConnection(socket, requestTimeoutMs));
+            };
+            socket.once("error", onError);
+            socket.once("open", onOpen);
+        });
+    }
+    async initialize() {
+        await this.request("initialize", {
+            clientInfo: { name: "tailii_host", title: "Tailii Host", version: "0.1.1" },
+            capabilities: { experimentalApi: true },
+        });
+        this.notify("initialized", undefined);
+    }
+    request(method, params, timeoutMs) {
+        const id = this.nextId;
+        this.nextId += 1;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`Codex App Server request timed out: ${method}`));
+            }, timeoutMs ?? this.requestTimeoutMs);
+            this.pending.set(id, { resolve, reject, timer });
+            this.socket.send(JSON.stringify({ id, method, params }));
+        });
+    }
+    close() {
+        this.socket.close();
+    }
+    onNotification(handler) {
+        this.notificationHandlers.add(handler);
+        return () => this.notificationHandlers.delete(handler);
+    }
+    onServerRequest(handler) {
+        this.serverRequestHandlers.add(handler);
+        return () => this.serverRequestHandlers.delete(handler);
+    }
+    onDisconnect(handler) {
+        this.disconnectHandlers.add(handler);
+        return () => this.disconnectHandlers.delete(handler);
+    }
+    respond(id, result) {
+        this.socket.send(JSON.stringify({ id, result }));
+    }
+    respondError(id, code, message) {
+        this.socket.send(JSON.stringify({ id, error: { code, message } }));
+    }
+    notify(method, params) {
+        const message = { method };
+        if (params !== undefined)
+            message["params"] = params;
+        this.socket.send(JSON.stringify(message));
+    }
+    onMessage(data) {
+        let parsed;
+        try {
+            parsed = JSON.parse(data.toString());
+        }
+        catch {
+            return;
+        }
+        if (typeof parsed !== "object" || parsed === null)
+            return;
+        const message = parsed;
+        const id = message["id"];
+        const method = message["method"];
+        // 双方向 JSON-RPC では client request と server request の id 名前空間が別なので、
+        // `method` の有無を先に見る。数値 id だけで response と判定すると衝突し得る。
+        if (typeof method === "string") {
+            const notification = {
+                method,
+                params: message["params"],
+            };
+            if (typeof id === "number" || typeof id === "string") {
+                for (const handler of this.serverRequestHandlers)
+                    handler({ ...notification, id });
+            }
+            else {
+                for (const handler of this.notificationHandlers)
+                    handler(notification);
+            }
+            return;
+        }
+        if (typeof id !== "number")
+            return;
+        const pending = this.pending.get(id);
+        if (!pending)
+            return;
+        this.pending.delete(id);
+        clearTimeout(pending.timer);
+        const error = message["error"];
+        if (typeof error === "object" && error !== null) {
+            const text = error["message"];
+            pending.reject(new Error(typeof text === "string" ? text : "Codex App Server request failed"));
+            return;
+        }
+        pending.resolve(message["result"]);
+    }
+    rejectPending(error) {
+        for (const pending of this.pending.values()) {
+            clearTimeout(pending.timer);
+            pending.reject(error);
+        }
+        this.pending.clear();
+    }
+    disconnect(error) {
+        if (this.disconnected)
+            return;
+        this.disconnected = true;
+        this.rejectPending(error);
+        for (const handler of this.disconnectHandlers)
+            handler(error);
+    }
+}
+/** 1 thread を購読し、Tailii から turn を開始する長寿命 App Server 接続。 */
+export class CodexAppServerThread {
+    threadId;
+    initialItems;
+    initialActiveTurnId;
+    liveSubscriptionReady;
+    connection;
+    cwd;
+    /** 読み取り専用の readiness 確認だけは、共有 App Server の一時的な混雑を自動回復する。 */
+    // 初回5秒 + 再試行2秒に抑え、上位の15秒 Hub RPC に turn/start の予算を残す。
+    static activeTurnReadMaxAttempts = 2;
+    static activeTurnReadRetryTimeoutMs = 2_000;
+    /** null=未判定、true=stable ID対応、false=旧App ServerなのでIDなしsteerへ固定。 */
+    supportsSteerClientUserMessageId = null;
+    constructor(threadId, initialItems, initialActiveTurnId, 
+    /**
+     * この接続で thread/resume（または作成元 bootstrap）が成功し、live 通知を受け取れるか。
+     * rollout 未生成の新規 thread は resume に失敗するため false。呼び出し側は初回 turn の
+     * 表示を rollout tail へフォールバックし、通知が来ない接続を live 権威にしない。
+     */
+    liveSubscriptionReady, connection, cwd) {
+        this.threadId = threadId;
+        this.initialItems = initialItems;
+        this.initialActiveTurnId = initialActiveTurnId;
+        this.liveSubscriptionReady = liveSubscriptionReady;
+        this.connection = connection;
+        this.cwd = cwd;
+    }
+    async startTurn(text, clientUserMessageId, effort, sandbox, approvalPolicy) {
+        if (text.length === 0)
+            throw new Error("Codex turn text must not be empty");
+        const inherited = sandbox === null || approvalPolicy === null
+            ? await readCodexSecurityDefaults(this.connection, this.cwd)
+            : null;
+        const effectiveSandbox = sandbox === null ? inherited?.sandbox ?? null : sandbox;
+        const effectiveApprovalPolicy = approvalPolicy === null ? inherited?.approvalPolicy ?? null : approvalPolicy;
+        const effectiveApprovalsReviewer = approvalPolicy === null ? inherited?.approvalsReviewer ?? null : null;
+        const response = await this.connection.request("turn/start", {
+            threadId: this.threadId,
+            input: [{ type: "text", text }],
+            ...(clientUserMessageId ? { clientUserMessageId } : {}),
+            ...(effort ? { effort } : {}),
+            ...(effectiveSandbox ? { sandboxPolicy: codexSandboxPolicy(effectiveSandbox) } : {}),
+            ...(effectiveApprovalPolicy ? { approvalPolicy: effectiveApprovalPolicy } : {}),
+            ...(effectiveApprovalsReviewer ? { approvalsReviewer: effectiveApprovalsReviewer } : {}),
+        });
+        const turnId = extractTurnId(response);
+        if (turnId === null)
+            throw new Error("Codex App Server turn/start response omitted turn.id");
+        return turnId;
+    }
+    async readActiveTurnId() {
+        for (let attempt = 1;; attempt += 1) {
+            try {
+                const response = await this.connection.request("thread/read", {
+                    threadId: this.threadId,
+                    includeTurns: true,
+                }, attempt === 1 ? undefined : CodexAppServerThread.activeTurnReadRetryTimeoutMs);
+                return extractActiveTurnId(response);
+            }
+            catch (error) {
+                // 新規 thread の最初の rollout 行がまだ無い間は、idle とは断定できない。
+                // controller は手元の ID を維持するか、初回 turn/start へ進む。
+                if (isUnmaterializedThreadError(error, this.threadId))
+                    return undefined;
+                // thread/read は副作用が無い。未 materialize thread の初回送信と
+                // 別セッションの処理が共有 App Server 上で重なった場合のみ、
+                // 5秒 timeout を有界リトライする。turn/start / turn/steer は受理済みか
+                // 不明なため、この自動リトライの対象にしない。
+                if (!isRequestTimeout(error, "thread/read") ||
+                    attempt >= CodexAppServerThread.activeTurnReadMaxAttempts) {
+                    throw error;
+                }
+            }
+        }
+    }
+    /** 親履歴で欠落する sub-agent の終端状態を、子 thread 自身から読み直す。 */
+    async readThreadStatus(threadId) {
+        for (let attempt = 1; attempt <= CodexAppServerThread.activeTurnReadMaxAttempts; attempt += 1) {
+            try {
+                const response = objectRecord(await this.connection.request("thread/read", { threadId, includeTurns: false }, CodexAppServerThread.activeTurnReadRetryTimeoutMs));
+                const thread = objectRecord(response?.["thread"]);
+                if (thread === null || thread["status"] === undefined)
+                    return undefined;
+                const timestampMs = codexTimestampMs(thread["createdAt"] ?? thread["updatedAt"] ?? thread["recencyAt"]);
+                return {
+                    status: thread["status"],
+                    ...(timestampMs === undefined ? {} : { timestampMs }),
+                };
+            }
+            catch (error) {
+                if (isRequestTimeout(error, "thread/read") &&
+                    attempt < CodexAppServerThread.activeTurnReadMaxAttempts) {
+                    continue;
+                }
+                // workflow snapshot の補完経路なので、子 rollout の一時的不在で親会話を開けなくしない。
+                return undefined;
+            }
+        }
+        return undefined;
+    }
+    async steerTurn(turnId, text, clientUserMessageId) {
+        if (text.length === 0)
+            throw new Error("Codex turn text must not be empty");
+        const params = {
+            threadId: this.threadId,
+            input: [{ type: "text", text }],
+            expectedTurnId: turnId,
+        };
+        if (!clientUserMessageId || this.supportsSteerClientUserMessageId === false) {
+            await this.connection.request("turn/steer", params);
+            return;
+        }
+        try {
+            await this.connection.request("turn/steer", { ...params, clientUserMessageId });
+            this.supportsSteerClientUserMessageId = true;
+        }
+        catch (error) {
+            // codex-cli 0.144系にはこの additive field が無い。未知フィールド拒否だけは
+            // 同じactive turnへIDなしで再試行し、別turnを開始するcontroller fallbackへ落とさない。
+            // timeout/切断など「受理済みか不明」な失敗は再試行せず、そのまま上位へ返す。
+            if (!isUnsupportedSteerClientUserMessageIdError(error))
+                throw error;
+            await this.connection.request("turn/steer", params);
+            this.supportsSteerClientUserMessageId = false;
+        }
+    }
+    async interruptTurn(turnId) {
+        await this.connection.request("turn/interrupt", {
+            threadId: this.threadId,
+            turnId,
+        });
+    }
+    close() {
+        this.connection.close();
+    }
+}
+function isUnsupportedSteerClientUserMessageIdError(error) {
+    if (!(error instanceof Error))
+        return false;
+    const message = error.message.toLowerCase();
+    if (!message.includes("clientusermessageid"))
+        return false;
+    return [
+        "unknown field",
+        "unknown parameter",
+        "unexpected field",
+        "invalid params",
+        "invalid parameter",
+        "not supported",
+        "unsupported",
+    ].some((marker) => message.includes(marker));
+}
+function isRequestTimeout(error, method) {
+    return error instanceof Error &&
+        error.message === `Codex App Server request timed out: ${method}`;
+}
+async function readCodexSecurityDefaults(connection, cwd) {
+    let rawResponse;
+    try {
+        rawResponse = await connection.request("config/read", {
+            includeLayers: false,
+            cwd,
+        });
+    }
+    catch {
+        // 旧 App Server や制限付きで起動された常駐プロセスでは、現在の thread 設定へ委ねる。
+        return { approvalPolicy: null, approvalsReviewer: null, sandbox: null };
+    }
+    const response = objectRecord(rawResponse);
+    const config = objectRecord(response?.["config"]);
+    const rawApprovalPolicy = config?.["approval_policy"];
+    const approvalPolicy = rawApprovalPolicy === "untrusted" ||
+        rawApprovalPolicy === "on-request" ||
+        rawApprovalPolicy === "never"
+        ? rawApprovalPolicy
+        : null;
+    const reviewer = config?.["approvals_reviewer"];
+    const approvalsReviewer = reviewer === "user" || reviewer === "auto_review" || reviewer === "guardian_subagent"
+        ? reviewer
+        : null;
+    const rawSandbox = config?.["sandbox_mode"];
+    const sandbox = rawSandbox === "read-only" ||
+        rawSandbox === "workspace-write" ||
+        rawSandbox === "danger-full-access"
+        ? rawSandbox
+        : null;
+    return { approvalPolicy, approvalsReviewer, sandbox };
+}
+function objectRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : null;
+}
+function codexSandboxPolicy(sandbox) {
+    switch (sandbox) {
+        case "read-only": return { type: "readOnly", networkAccess: false };
+        case "workspace-write": return {
+            type: "workspaceWrite", writableRoots: [], networkAccess: false,
+            excludeTmpdirEnvVar: false, excludeSlashTmp: false,
+        };
+        case "danger-full-access": return { type: "dangerFullAccess" };
+    }
+}
+/** 1 CODEX_HOMEにつき1つのApp Serverを共有し、論理threadを作成する。 */
+export class CodexAppServerManager {
+    socketPath;
+    remoteEndpoint;
+    codexHome;
+    codexPath;
+    connect;
+    launch;
+    pollIntervalMs;
+    startupTimeoutMs;
+    titleGenerationTimeoutMs;
+    startupLockPath;
+    /** 最初の turn 前（rollout 未作成）の thread を生存させる作成元購読。openThread が引き継ぐ。 */
+    bootstrapConnections = new Map();
+    constructor(options = {}) {
+        this.codexHome = options.codexHome ?? path.join(os.homedir(), ".codex");
+        this.codexPath = options.codexPath ?? "codex";
+        this.socketPath =
+            options.socketPath ?? path.join(this.codexHome, "app-server-control", "app-server-control.sock");
+        this.remoteEndpoint = options.remoteEndpoint ?? "unix://";
+        this.connect =
+            options.connect ?? ((socketPath, requestTimeoutMs) => WebSocketCodexAppServerConnection.connect(socketPath, requestTimeoutMs));
+        this.launch = options.launch ?? defaultLaunch;
+        this.pollIntervalMs = options.pollIntervalMs ?? 100;
+        this.startupTimeoutMs = options.startupTimeoutMs ?? 10_000;
+        this.titleGenerationTimeoutMs =
+            options.titleGenerationTimeoutMs ?? DEFAULT_TITLE_GENERATION_TIMEOUT_MS;
+        this.startupLockPath = path.join(path.dirname(this.socketPath), "tailii-start.lock");
+    }
+    /** serverを再利用または排他的に起動し、利用可能になるまで待つ。 */
+    async ensureRunning() {
+        if (await this.probe())
+            return;
+        ensureDirectory0700(path.dirname(this.startupLockPath));
+        let lockFd = null;
+        try {
+            lockFd = this.acquireStartupLock();
+            if (lockFd === null) {
+                if (await this.waitUntilReady())
+                    return;
+                throw new Error("Codex App Server startup is already in progress but did not become ready");
+            }
+            // lock取得待ちの間に別processが起動済みかもしれないので再確認する。
+            if (await this.probe())
+                return;
+            await this.launch(this.codexPath, ["app-server", "--listen", this.remoteEndpoint], { ...process.env, CODEX_HOME: this.codexHome });
+            if (!(await this.waitUntilReady())) {
+                throw new Error("Codex App Server failed to become ready");
+            }
+        }
+        finally {
+            if (lockFd !== null) {
+                try {
+                    fs.closeSync(lockFd);
+                }
+                catch {
+                    // 無視。
+                }
+                try {
+                    fs.unlinkSync(this.startupLockPath);
+                }
+                catch {
+                    // 無視。
+                }
+            }
+        }
+    }
+    /** 稼働中の server にだけ接続する。停止中・不達時は起動せず null を返す。 */
+    async connectIfRunning(requestTimeoutMs = 2_000) {
+        let connection = null;
+        try {
+            connection = await this.connect(this.socketPath, requestTimeoutMs);
+            await connection.initialize();
+            return connection;
+        }
+        catch {
+            connection?.close();
+            return null;
+        }
+    }
+    /** 稼働中の server から thread/list を最大200件取得する。停止中なら null。 */
+    async listThreads(maxThreads = 200) {
+        const connection = await this.connectIfRunning();
+        if (connection === null)
+            return null;
+        try {
+            const threads = [];
+            const seenCursors = new Set();
+            let cursor = null;
+            do {
+                const limit = Math.min(100, maxThreads - threads.length);
+                if (limit <= 0)
+                    break;
+                const response = await connection.request("thread/list", {
+                    limit,
+                    sortKey: "updated_at",
+                    sortDirection: "desc",
+                    ...(cursor !== null ? { cursor } : {}),
+                });
+                const page = parseThreadListPage(response);
+                threads.push(...page.data.slice(0, limit));
+                cursor = page.nextCursor;
+                if (cursor !== null) {
+                    if (seenCursors.has(cursor))
+                        throw new Error("Codex App Server thread/list cursor loop");
+                    seenCursors.add(cursor);
+                }
+            } while (cursor !== null && threads.length < maxThreads);
+            return threads;
+        }
+        finally {
+            connection.close();
+        }
+    }
+    /**
+     * Codex App Server の正式な会話名を設定する。
+     *
+     * loaded thread と persisted rollout の両方を同じ API で更新できる。
+     * schema上は空文字もstringだが、実App Serverは `thread name must not be empty` で拒否する。
+     */
+    async setThreadName(threadId, name) {
+        const normalizedThreadId = threadId.trim();
+        if (normalizedThreadId.length === 0) {
+            throw new Error("Codex thread id must not be empty");
+        }
+        if (name.trim().length === 0) {
+            throw new Error("Codex thread name must not be empty");
+        }
+        await this.ensureRunning();
+        const connection = await this.connect(this.socketPath);
+        try {
+            await connection.initialize();
+            await connection.request("thread/name/set", {
+                threadId: normalizedThreadId,
+                name,
+            });
+        }
+        finally {
+            connection.close();
+        }
+    }
+    /** 現在共有中の App Server から Remote Control 状態を読む。 */
+    async remoteControlStatus() {
+        return this.remoteControlRequest("remoteControl/status/read", {}, parseRemoteControlStatus);
+    }
+    /** 現在共有中の App Server 自体で Remote Control を有効化する。 */
+    async enableRemoteControl() {
+        return this.remoteControlRequest("remoteControl/enable", {}, parseRemoteControlStatus);
+    }
+    /** 現在共有中の App Server 自体で Remote Control を無効化する。 */
+    async disableRemoteControl() {
+        return this.remoteControlRequest("remoteControl/disable", {}, parseRemoteControlStatus);
+    }
+    /** 短命なペアリングコードを発行する。呼び出し側は URL 化後も永続化しない。 */
+    async startRemoteControlPairing() {
+        return this.remoteControlRequest("remoteControl/pairing/start", { manualCode: true }, parseRemoteControlPairing);
+    }
+    /** 新規threadをApp Serverで作り、TUI起動前に安定IDを返す。 */
+    async startThread(options) {
+        if (!path.isAbsolute(options.cwd))
+            throw new Error("Codex thread cwd must be absolute");
+        await this.ensureRunning();
+        const connection = await this.connect(this.socketPath);
+        let succeeded = false;
+        try {
+            await connection.initialize();
+            const params = {
+                cwd: options.cwd,
+            };
+            if (options.model)
+                params["model"] = options.model;
+            if (options.sandbox)
+                params["sandbox"] = options.sandbox;
+            const response = await connection.request("thread/start", params);
+            const threadId = extractThreadId(response);
+            if (threadId === null)
+                throw new Error("Codex App Server thread/start response omitted thread.id");
+            // turn が1件も無い thread は rollout がまだ存在せず、作成元購読を閉じると直後の
+            // remote TUI/thread/resume が "no rollout found" になる。openThread まで保持して引き継ぐ。
+            this.bootstrapConnections.get(threadId)?.close();
+            this.bootstrapConnections.set(threadId, connection);
+            succeeded = true;
+            return threadId;
+        }
+        finally {
+            if (!succeeded)
+                connection.close();
+        }
+    }
+    /**
+     * Codex Desktop と同じ短命 thread で初回 prompt の短いタイトルを生成し、対象 thread へ保存する。
+     * `gpt-5.6-luna` を優先し、App Server が利用不能と判断した場合は既定モデルへ委ねる。
+     */
+    async generateThreadTitle(options) {
+        if (!path.isAbsolute(options.cwd))
+            throw new Error("Codex thread cwd must be absolute");
+        await this.ensureRunning();
+        const connection = await this.connect(this.socketPath);
+        let ephemeralThreadId = null;
+        try {
+            await connection.initialize();
+            const target = await readThreadTitleTarget(connection, options.threadId, options.prompt);
+            if (target.name !== null)
+                return { title: null, source: null };
+            const prompt = target.prompt.trim().slice(0, THREAD_TITLE_PROMPT_MAX_LENGTH);
+            if (prompt.length === 0)
+                return { title: null, source: null };
+            const fallbackTitle = normalizeFallbackThreadTitle(prompt);
+            let generatedTitle = null;
+            try {
+                const response = await connection.request("thread/start", {
+                    model: THREAD_TITLE_MODEL,
+                    modelProvider: null,
+                    allowProviderModelFallback: true,
+                    cwd: options.cwd,
+                    approvalPolicy: "never",
+                    permissions: ":read-only",
+                    runtimeWorkspaceRoots: [],
+                    config: THREAD_TITLE_CONFIG,
+                    personality: null,
+                    ephemeral: true,
+                    threadSource: "system",
+                    experimentalRawEvents: false,
+                    dynamicTools: null,
+                    serviceTier: null,
+                });
+                ephemeralThreadId = extractThreadId(response);
+                if (ephemeralThreadId === null) {
+                    throw new Error("Codex title thread/start response omitted thread.id");
+                }
+                generatedTitle = await runThreadTitleTurn(connection, ephemeralThreadId, buildThreadTitlePrompt(prompt), this.titleGenerationTimeoutMs);
+            }
+            catch {
+                // Desktop と同様、生成経路の失敗は初回 prompt の先頭60文字へフォールバックする。
+            }
+            const title = generatedTitle ?? fallbackTitle;
+            const source = generatedTitle === null ? "promptFallback" : "model";
+            // 生成中の手動 rename や別 client の命名を上書きしない。
+            if (await readThreadName(connection, options.threadId) !== null) {
+                return { title: null, source: null };
+            }
+            await connection.request("thread/name/set", {
+                threadId: options.threadId,
+                name: title,
+            });
+            return { title, source };
+        }
+        finally {
+            if (ephemeralThreadId !== null) {
+                try {
+                    await connection.request("thread/unsubscribe", { threadId: ephemeralThreadId });
+                }
+                catch {
+                    // 短命接続を閉じれば通常会話には影響しない。
+                }
+            }
+            connection.close();
+        }
+    }
+    /** ログイン中アカウントで利用可能なCodexモデルをApp Server APIから取得する。 */
+    async listModels() {
+        await this.ensureRunning();
+        const connection = await this.connect(this.socketPath);
+        try {
+            await connection.initialize();
+            const rawModels = [];
+            const seenCursors = new Set();
+            let cursor = null;
+            do {
+                const response = await connection.request("model/list", {
+                    limit: 100,
+                    includeHidden: false,
+                    ...(cursor !== null ? { cursor } : {}),
+                });
+                const page = parseModelListPage(response);
+                rawModels.push(...page.data);
+                cursor = page.nextCursor;
+                if (cursor !== null) {
+                    if (seenCursors.has(cursor))
+                        throw new Error("Codex App Server model/list cursor loop");
+                    seenCursors.add(cursor);
+                }
+            } while (cursor !== null);
+            // model/list がAPIキャッシュを更新した後に読む。App Serverの公開Model型には
+            // context windowが無いため、同じCodex API応答の永続キャッシュから実効値を結合する。
+            const cachedWindows = readModelContextWindows(path.join(this.codexHome, "models_cache.json"));
+            const seenModels = new Set();
+            return rawModels.flatMap((raw) => {
+                if (raw["hidden"] === true)
+                    return [];
+                const model = stringValue(raw["model"]) ?? stringValue(raw["id"]);
+                if (model === null || seenModels.has(model))
+                    return [];
+                seenModels.add(model);
+                const directWindow = positiveInteger(raw["contextWindow"]);
+                const contextWindow = directWindow ?? cachedWindows.get(model);
+                const supportedReasoningEfforts = Array.isArray(raw["supportedReasoningEfforts"])
+                    ? raw["supportedReasoningEfforts"].flatMap((value) => {
+                        if (typeof value !== "object" || value === null || Array.isArray(value))
+                            return [];
+                        const effort = stringValue(value["reasoningEffort"]);
+                        return effort === null ? [] : [effort];
+                    })
+                    : [];
+                const defaultReasoningEffort = stringValue(raw["defaultReasoningEffort"]);
+                return [{
+                        id: model,
+                        displayName: stringValue(raw["displayName"]) ?? model,
+                        description: stringValue(raw["description"]) ?? "",
+                        ...(contextWindow !== undefined ? { contextWindow } : {}),
+                        ...(defaultReasoningEffort !== null ? { defaultReasoningEffort } : {}),
+                        ...(supportedReasoningEfforts.length > 0 ? { supportedReasoningEfforts } : {}),
+                        isDefault: raw["isDefault"] === true,
+                    }];
+            });
+        }
+        finally {
+            connection.close();
+        }
+    }
+    /** 既存 thread を購読する長寿命接続を開く。turn と native approval はこの接続を流れる。 */
+    async openThread(options) {
+        await this.ensureRunning();
+        const bootstrap = this.bootstrapConnections.get(options.threadId) ?? null;
+        if (bootstrap !== null)
+            this.bootstrapConnections.delete(options.threadId);
+        const connection = bootstrap ?? (await this.connect(this.socketPath));
+        const removeNotification = connection.onNotification((notification) => {
+            options.onNotification?.(notification);
+        });
+        const removeServerRequest = connection.onServerRequest((request) => {
+            const handler = options.onServerRequest;
+            if (handler === undefined) {
+                connection.respondError(request.id, -32601, `unsupported server request: ${request.method}`);
+                return;
+            }
+            void handler(request).then((result) => connection.respond(request.id, result), (error) => connection.respondError(request.id, -32000, String(error)));
+        });
+        const removeDisconnect = connection.onDisconnect?.((error) => options.onDisconnect?.(error)) ?? (() => { });
+        try {
+            let initialItems = [];
+            let initialActiveTurnId = null;
+            let liveSubscriptionReady = bootstrap !== null;
+            if (bootstrap === null) {
+                await connection.initialize();
+                try {
+                    const response = await connection.request("thread/resume", {
+                        threadId: options.threadId,
+                        // Hub の rollout backfill と live 通知の厳密な境界に履歴 item ID を使う。
+                        excludeTurns: false,
+                    });
+                    initialItems = extractThreadItems(response);
+                    initialActiveTurnId = extractActiveTurnId(response);
+                    liveSubscriptionReady = true;
+                }
+                catch (error) {
+                    // thread/start から最初の user turn まで rollout は未作成で、別接続からの
+                    // thread/resume は "no rollout found" になる。ただし共有 App Server 内の
+                    // live thread 自体は存在し、この接続から turn/start を直接送れば materialize
+                    // できる。engine と Session Hub は別プロセスなので、この場合だけ履歴ゼロとして
+                    // 接続を維持し、最初の turn/start へ進ませる。
+                    if (!isUnmaterializedThreadError(error, options.threadId))
+                        throw error;
+                }
+            }
+            return new CodexAppServerThread(options.threadId, initialItems, initialActiveTurnId, liveSubscriptionReady, connection, options.cwd ?? null);
+        }
+        catch (error) {
+            removeNotification();
+            removeServerRequest();
+            removeDisconnect();
+            connection.close();
+            throw error;
+        }
+    }
+    async probe() {
+        const connection = await this.connectIfRunning();
+        if (connection === null)
+            return false;
+        connection.close();
+        return true;
+    }
+    async remoteControlRequest(method, params, parse) {
+        try {
+            await this.ensureRunning();
+            const connection = await this.connectIfRunning(22_000);
+            if (connection === null)
+                return null;
+            try {
+                return parse(await connection.request(method, params));
+            }
+            finally {
+                connection.close();
+            }
+        }
+        catch {
+            return null;
+        }
+    }
+    async waitUntilReady() {
+        const deadline = Date.now() + this.startupTimeoutMs;
+        do {
+            if (await this.probe())
+                return true;
+            await new Promise((resolve) => setTimeout(resolve, this.pollIntervalMs));
+        } while (Date.now() <= deadline);
+        return false;
+    }
+    /** lockが他の生存processに所有されていればnull。死んだownerのlockは1回だけ回収する。 */
+    acquireStartupLock() {
+        for (let attempt = 0; attempt < 2; attempt += 1) {
+            try {
+                const fd = fs.openSync(this.startupLockPath, "wx", 0o600);
+                fs.writeFileSync(fd, JSON.stringify({ pid: process.pid, createdAt: Date.now() }));
+                return fd;
+            }
+            catch (error) {
+                if (error.code !== "EEXIST")
+                    throw error;
+                const ownerPid = readLockPid(this.startupLockPath);
+                if (ownerPid !== null && processIsAlive(ownerPid))
+                    return null;
+                try {
+                    fs.unlinkSync(this.startupLockPath);
+                }
+                catch {
+                    return null;
+                }
+            }
+        }
+        return null;
+    }
+}
+async function readThreadName(connection, threadId) {
+    let response;
+    try {
+        response = objectRecord(await connection.request("thread/read", {
+            threadId,
+            includeTurns: false,
+        }));
+    }
+    catch (error) {
+        // turn/start が成功していても rollout の最初の行が flush されるまでは
+        // thread/read が空ファイルとして失敗する。thread/list のメタデータはこの間も
+        // name を返せるため、手動 rename の上書き防止を維持したまま命名を続行する。
+        if (!isUnmaterializedThreadError(error, threadId))
+            throw error;
+        return readThreadNameFromList(connection, threadId);
+    }
+    const thread = objectRecord(response?.["thread"]);
+    if (thread === null)
+        throw new Error("Codex App Server thread/read response omitted thread");
+    const name = thread["name"];
+    if (name === null || name === undefined)
+        return null;
+    if (typeof name !== "string") {
+        throw new Error("Codex App Server thread/read returned an invalid thread name");
+    }
+    return name.trim().length > 0 ? name.trim() : null;
+}
+async function readThreadTitleTarget(connection, threadId, fallbackPrompt) {
+    let response;
+    try {
+        response = await connection.request("thread/read", {
+            threadId,
+            includeTurns: true,
+        });
+    }
+    catch (error) {
+        // 作成直後は初回 turn/start 応答後もしばらく rollout が空の場合がある。
+        // controller から渡された最初の入力を使い、既存 name だけ thread/list で保護する。
+        if (!isUnmaterializedThreadError(error, threadId))
+            throw error;
+        return {
+            name: await readThreadNameFromList(connection, threadId),
+            prompt: fallbackPrompt,
+        };
+    }
+    const record = objectRecord(response);
+    const thread = objectRecord(record?.["thread"]);
+    if (thread === null)
+        throw new Error("Codex App Server thread/read response omitted thread");
+    const rawName = thread["name"];
+    if (rawName !== null && rawName !== undefined && typeof rawName !== "string") {
+        throw new Error("Codex App Server thread/read returned an invalid thread name");
+    }
+    const name = typeof rawName === "string" && rawName.trim().length > 0 ? rawName.trim() : null;
+    const firstUserPrompt = extractThreadItems(response)
+        .map(extractUserMessageText)
+        .find((value) => value !== null && value.trim().length > 0);
+    return {
+        name,
+        prompt: firstUserPrompt ?? fallbackPrompt,
+    };
+}
+async function readThreadNameFromList(connection, threadId) {
+    const page = parseThreadListPage(await connection.request("thread/list", {
+        limit: 100,
+        sortKey: "updated_at",
+        sortDirection: "desc",
+    }));
+    const thread = page.data.find((candidate) => candidate.id === threadId);
+    if (thread === undefined) {
+        throw new Error(`Codex App Server thread/list omitted target thread ${threadId}`);
+    }
+    return thread.name;
+}
+function extractUserMessageText(item) {
+    if (item["type"] !== "userMessage")
+        return null;
+    const content = item["content"];
+    if (!Array.isArray(content))
+        return null;
+    const text = content.flatMap((part) => {
+        const record = objectRecord(part);
+        if (record === null || record["type"] !== "text")
+            return [];
+        return typeof record["text"] === "string" ? [record["text"]] : [];
+    }).join("\n").trim();
+    return text.length > 0 ? text : null;
+}
+async function runThreadTitleTurn(connection, threadId, prompt, timeoutMs) {
+    let turnId = null;
+    let responseText = "";
+    let settled = false;
+    let resolveCompletion = () => { };
+    const completion = new Promise((resolve) => {
+        resolveCompletion = resolve;
+    });
+    const finish = (title) => {
+        if (settled)
+            return;
+        settled = true;
+        resolveCompletion(title);
+    };
+    const removeNotification = connection.onNotification((notification) => {
+        const params = objectRecord(notification.params);
+        if (params?.["threadId"] !== threadId)
+            return;
+        const notificationTurnId = stringValue(params["turnId"]) ?? stringValue(objectRecord(params["turn"])?.["id"]);
+        if (turnId !== null && notificationTurnId !== null && notificationTurnId !== turnId)
+            return;
+        if (notification.method === "turn/started") {
+            if (notificationTurnId !== null)
+                turnId = notificationTurnId;
+            return;
+        }
+        if (notification.method === "item/agentMessage/delta") {
+            const delta = params["delta"];
+            if (typeof delta === "string")
+                responseText += delta;
+            return;
+        }
+        if (notification.method === "item/completed") {
+            const item = objectRecord(params["item"]);
+            if (item?.["type"] === "agentMessage" && typeof item["text"] === "string") {
+                responseText = item["text"];
+            }
+            return;
+        }
+        if (notification.method === "error") {
+            finish(null);
+            return;
+        }
+        if (notification.method === "turn/completed") {
+            const turn = objectRecord(params["turn"]);
+            finish(turn?.["status"] === "completed" ? parseThreadTitleResult(responseText) : null);
+        }
+    });
+    const timer = setTimeout(() => {
+        if (turnId !== null) {
+            void connection.request("turn/interrupt", { threadId, turnId }).catch(() => { });
+        }
+        finish(null);
+    }, Math.max(1, timeoutMs));
+    try {
+        const response = await connection.request("turn/start", {
+            threadId,
+            clientUserMessageId: randomUUID(),
+            input: [{ type: "text", text: prompt, text_elements: [] }],
+            cwd: null,
+            approvalPolicy: null,
+            permissions: ":read-only",
+            runtimeWorkspaceRoots: [],
+            model: null,
+            effort: null,
+            serviceTier: null,
+            summary: "none",
+            personality: null,
+            outputSchema: THREAD_TITLE_OUTPUT_SCHEMA,
+            collaborationMode: null,
+        });
+        turnId = extractTurnId(response);
+        if (turnId === null)
+            throw new Error("Codex title turn/start response omitted turn.id");
+        return await completion;
+    }
+    finally {
+        clearTimeout(timer);
+        removeNotification();
+    }
+}
+function buildThreadTitlePrompt(prompt) {
+    return [
+        "You are a helpful assistant that creates a short UI title for a coding task.",
+        `Return a concise title of at most ${THREAD_TITLE_MAX_LENGTH} characters and a compact, search-oriented description of at most 100 characters.`,
+        "Write both the title and description in the same primary language as the user prompt.",
+        "Do not translate them into another language. Preserve product names and identifiers in their original form.",
+        "Start change requests with a precise action word appropriate to the user's language.",
+        "Keep the title under five words when possible.",
+        "Make questions clearly express their intent in the user's language.",
+        "Reuse an explicit short title from the user when one is provided.",
+        "Preserve ticket references such as ABC-123 verbatim.",
+        "Do not use quotes, Markdown, formatting characters, or trailing punctuation.",
+        "Do not answer the prompt or solve the task. Only produce the structured title and description.",
+        "",
+        "User prompt:",
+        prompt,
+    ].join("\n");
+}
+function parseThreadTitleResult(raw) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw.trim());
+    }
+    catch {
+        return null;
+    }
+    const result = objectRecord(parsed);
+    const title = result?.["title"];
+    const description = result?.["description"];
+    if (typeof title !== "string" ||
+        title.length === 0 ||
+        title.length > THREAD_TITLE_MAX_LENGTH ||
+        typeof description !== "string" ||
+        description.trim().length === 0) {
+        return null;
+    }
+    return sanitizeGeneratedThreadTitle(title);
+}
+function sanitizeGeneratedThreadTitle(raw) {
+    let title = raw
+        .replaceAll("\r\n", "\n")
+        .split("\n")
+        .find((line) => line.trim().length > 0)
+        ?.trim() ?? "";
+    title = title.replace(/^title[:\s]+/i, "");
+    title = title.replace(/^[`"'“”‘’]+|[`"'“”‘’]+$/g, "");
+    title = title.replace(/\s+/g, " ").trim();
+    title = title.replace(/[.?!]+$/, "").trim();
+    if (title.length === 0)
+        return null;
+    return title.length > THREAD_TITLE_MAX_LENGTH
+        ? `${title.slice(0, THREAD_TITLE_MAX_LENGTH - 1).trimEnd()}…`
+        : title;
+}
+function normalizeFallbackThreadTitle(raw) {
+    const title = raw.replaceAll("\n", " ").replaceAll("\r", " ").trim();
+    return title.slice(0, THREAD_TITLE_FALLBACK_MAX_LENGTH);
+}
+function isUnmaterializedThreadError(error, threadId) {
+    if (!(error instanceof Error))
+        return false;
+    if (error.message === `no rollout found for thread id ${threadId}`)
+        return true;
+    const notMaterializedYet = `thread ${threadId} is not materialized yet; ` +
+        "includeTurns is unavailable before first user message";
+    if (error.message === notMaterializedYet)
+        return true;
+    return error.message.includes(threadId) &&
+        error.message.includes("failed to read session metadata") &&
+        error.message.endsWith("is empty");
+}
+function parseRemoteControlStatus(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return null;
+    const record = value;
+    const status = record["status"];
+    if (status !== "disabled" &&
+        status !== "connecting" &&
+        status !== "connected" &&
+        status !== "errored") {
+        return null;
+    }
+    const environmentId = record["environmentId"];
+    if (environmentId !== null && environmentId !== undefined && typeof environmentId !== "string") {
+        return null;
+    }
+    return {
+        status,
+        hasEnvironment: typeof environmentId === "string" && environmentId.length > 0,
+    };
+}
+function parseRemoteControlPairing(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return null;
+    const record = value;
+    const pairingCode = record["pairingCode"];
+    const manualPairingCode = record["manualPairingCode"];
+    const environmentId = record["environmentId"];
+    const expiresAt = record["expiresAt"];
+    if (typeof pairingCode !== "string" ||
+        pairingCode.length === 0 ||
+        Buffer.byteLength(pairingCode, "utf8") > 2_048 ||
+        (manualPairingCode !== null && typeof manualPairingCode !== "string") ||
+        typeof environmentId !== "string" ||
+        environmentId.length === 0 ||
+        !Number.isSafeInteger(expiresAt) ||
+        expiresAt <= 0) {
+        return null;
+    }
+    return {
+        pairingCode,
+        manualPairingCode,
+        expiresAt: expiresAt,
+    };
+}
+function extractThreadItems(response) {
+    const result = [];
+    if (typeof response !== "object" || response === null)
+        return result;
+    const thread = response["thread"];
+    if (typeof thread !== "object" || thread === null)
+        return result;
+    const turns = thread["turns"];
+    if (!Array.isArray(turns))
+        return result;
+    for (const turn of turns) {
+        if (typeof turn !== "object" || turn === null)
+            continue;
+        const items = turn["items"];
+        if (!Array.isArray(items))
+            continue;
+        for (const item of items) {
+            if (typeof item !== "object" || item === null || Array.isArray(item))
+                continue;
+            result.push(item);
+        }
+    }
+    return result;
+}
+/** thread/resume が返す turn 一覧から、別 client が開始した実行中 turn を復元する。 */
+function extractActiveTurnId(response) {
+    if (typeof response !== "object" || response === null)
+        return null;
+    const thread = response["thread"];
+    if (typeof thread !== "object" || thread === null)
+        return null;
+    const turns = thread["turns"];
+    if (!Array.isArray(turns))
+        return null;
+    for (let index = turns.length - 1; index >= 0; index -= 1) {
+        const turn = turns[index];
+        if (typeof turn !== "object" || turn === null || Array.isArray(turn))
+            continue;
+        const record = turn;
+        if (record["status"] !== "inProgress")
+            continue;
+        const id = record["id"];
+        if (typeof id === "string" && id.length > 0)
+            return id;
+    }
+    return null;
+}
+function defaultLaunch(executable, args, env) {
+    const child = spawn(executable, args, { detached: true, env, stdio: "ignore" });
+    child.once("error", () => {
+        // readiness probeが最終的な構造化エラーを返すため、EventEmitterの未処理errorだけ防ぐ。
+    });
+    child.unref();
+}
+function extractThreadId(response) {
+    if (typeof response !== "object" || response === null)
+        return null;
+    const thread = response["thread"];
+    if (typeof thread !== "object" || thread === null)
+        return null;
+    const id = thread["id"];
+    return typeof id === "string" && id.length > 0 ? id : null;
+}
+function extractTurnId(response) {
+    if (typeof response !== "object" || response === null)
+        return null;
+    const turn = response["turn"];
+    if (typeof turn !== "object" || turn === null)
+        return null;
+    const id = turn["id"];
+    return typeof id === "string" && id.length > 0 ? id : null;
+}
+function parseModelListPage(response) {
+    if (typeof response !== "object" || response === null || Array.isArray(response)) {
+        throw new Error("Codex App Server model/list response is not an object");
+    }
+    const record = response;
+    const data = record["data"];
+    if (!Array.isArray(data))
+        throw new Error("Codex App Server model/list response omitted data");
+    const models = data.filter((value) => typeof value === "object" && value !== null && !Array.isArray(value));
+    if (models.length !== data.length) {
+        throw new Error("Codex App Server model/list returned an invalid model");
+    }
+    const rawCursor = record["nextCursor"];
+    if (rawCursor !== null && rawCursor !== undefined && typeof rawCursor !== "string") {
+        throw new Error("Codex App Server model/list returned an invalid cursor");
+    }
+    return { data: models, nextCursor: typeof rawCursor === "string" && rawCursor.length > 0 ? rawCursor : null };
+}
+function parseThreadListPage(response) {
+    if (typeof response !== "object" || response === null || Array.isArray(response)) {
+        throw new Error("Codex App Server thread/list response is not an object");
+    }
+    const record = response;
+    const rawData = record["data"];
+    if (!Array.isArray(rawData))
+        throw new Error("Codex App Server thread/list response omitted data");
+    const data = rawData.map((value) => {
+        if (typeof value !== "object" || value === null || Array.isArray(value)) {
+            throw new Error("Codex App Server thread/list returned an invalid thread");
+        }
+        const thread = value;
+        const id = stringValue(thread["id"]);
+        const updatedAt = thread["updatedAt"];
+        if (id === null || typeof updatedAt !== "number" || !Number.isFinite(updatedAt)) {
+            throw new Error("Codex App Server thread/list returned an invalid thread");
+        }
+        return {
+            id,
+            name: stringValue(thread["name"]),
+            preview: stringValue(thread["preview"]),
+            updatedAt: Math.floor(updatedAt),
+            cwd: stringValue(thread["cwd"]),
+            source: thread["source"],
+            parentThreadId: stringValue(thread["parentThreadId"]),
+        };
+    });
+    const rawCursor = record["nextCursor"];
+    if (rawCursor !== null && rawCursor !== undefined && typeof rawCursor !== "string") {
+        throw new Error("Codex App Server thread/list returned an invalid cursor");
+    }
+    return { data, nextCursor: typeof rawCursor === "string" && rawCursor.length > 0 ? rawCursor : null };
+}
+/** models_cacheのraw上限へ有効率を掛け、実行時token_countと同じ分母へ揃える。 */
+function readModelContextWindows(cachePath) {
+    const result = new Map();
+    let parsed;
+    try {
+        parsed = JSON.parse(fs.readFileSync(cachePath, "utf8"));
+    }
+    catch {
+        return result;
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+        return result;
+    const models = parsed["models"];
+    if (!Array.isArray(models))
+        return result;
+    for (const value of models) {
+        if (typeof value !== "object" || value === null || Array.isArray(value))
+            continue;
+        const model = value;
+        const slug = stringValue(model["slug"]);
+        const rawWindow = positiveInteger(model["context_window"]);
+        if (slug === null || rawWindow === undefined)
+            continue;
+        const percent = model["effective_context_window_percent"];
+        const effective = typeof percent === "number" && Number.isFinite(percent) && percent > 0 && percent <= 100
+            ? Math.floor(rawWindow * percent / 100)
+            : rawWindow;
+        if (effective > 0)
+            result.set(slug, effective);
+    }
+    return result;
+}
+function stringValue(value) {
+    return typeof value === "string" && value.length > 0 ? value : null;
+}
+function positiveInteger(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : undefined;
+}
+/** App Server のUnix秒をprotocolのミリ秒へ揃える。将来ミリ秒値になっても二重変換しない。 */
+function codexTimestampMs(value) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value <= 0)
+        return undefined;
+    return Math.floor(value < 10_000_000_000 ? value * 1_000 : value);
+}
+function readLockPid(lockPath) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(lockPath, "utf8"));
+        if (typeof parsed !== "object" || parsed === null)
+            return null;
+        const pid = parsed["pid"];
+        return typeof pid === "number" && Number.isSafeInteger(pid) && pid > 0 ? pid : null;
+    }
+    catch {
+        return null;
+    }
+}
+function processIsAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === "EPERM";
+    }
+}
+//# sourceMappingURL=codexAppServer.js.map