@nowcrew/daemon 0.6.34 → 0.6.35

package/dist/remote/claude-channel.js

@@ -1,164 +0,0 @@
-import { readFile } from "node:fs/promises";
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { CallToolRequestSchema, ListToolsRequestSchema, NotificationSchema, } from "@modelcontextprotocol/sdk/types.js";
-import { WebSocket } from "ws";
-import { z } from "zod";
-import { z as z4 } from "zod/v4";
-import { ChannelToGatewaySchema, GatewayToChannelSchema, REMOTE_PROTOCOL_VERSION, } from "./protocol.js";
-const PermissionRequestSchema = NotificationSchema.extend({
-    method: z4.literal("notifications/claude/channel/permission_request"),
-    params: z4.object({
-        request_id: z4.string().regex(/^[a-km-z]{5}$/),
-        tool_name: z4.string(),
-        description: z4.string(),
-        input_preview: z4.string(),
-    }),
-});
-const ChannelEnvironmentSchema = z.object({
-    NOWCREW_REMOTE_URL: z.string().url(),
-    NOWCREW_REMOTE_TOKEN_FILE: z.string().min(1),
-    NOWCREW_REMOTE_SESSION_ID: z.string().uuid(),
-    NOWCREW_REMOTE_GENERATION: z.string().uuid(),
-    NOWCREW_REMOTE_CWD: z.string().min(1),
-}).passthrough();
-export function createClaudeChannelServer(sendToGateway) {
-    const mcp = new Server({ name: "nowcrew", version: "1.0.0" }, {
-        capabilities: {
-            experimental: {
-                "claude/channel": {},
-                "claude/channel/permission": {},
-            },
-            tools: {},
-        },
-        instructions: "Messages from the user's authenticated NowCrew phone arrive as <channel source=\"nowcrew\" request_id=\"...\">. "
-            + "Handle them as direct user requests in this session. Render the complete user-facing answer normally in the terminal, "
-            + "then call the reply tool exactly once with the same complete answer and request_id so the phone stays synchronized.",
-    });
-    mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
-        tools: [{
-                name: "reply",
-                description: "Send the complete user-facing answer back to the authenticated NowCrew phone",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        request_id: { type: "string", format: "uuid" },
-                        text: { type: "string", minLength: 1 },
-                    },
-                    required: ["request_id", "text"],
-                    additionalProperties: false,
-                },
-            }],
-    }));
-    mcp.setRequestHandler(CallToolRequestSchema, async (request) => {
-        if (request.params.name !== "reply")
-            throw new Error(`unknown tool: ${request.params.name}`);
-        const args = z.object({ request_id: z.string().uuid(), text: z.string().min(1).max(200_000) })
-            .parse(request.params.arguments);
-        sendToGateway({ type: "reply", ...args });
-        return { content: [{ type: "text", text: "sent" }] };
-    });
-    mcp.setNotificationHandler(PermissionRequestSchema, ({ params }) => {
-        sendToGateway({
-            type: "permission",
-            requestId: params.request_id,
-            tool: params.tool_name,
-            description: params.description,
-            preview: params.input_preview,
-        });
-    });
-    return mcp;
-}
-export async function runClaudeChannel(env = process.env) {
-    const parsed = ChannelEnvironmentSchema.parse(env);
-    const token = (await readFile(parsed.NOWCREW_REMOTE_TOKEN_FILE, "utf8")).trim();
-    const url = new URL("/ws/channel", parsed.NOWCREW_REMOTE_URL);
-    url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
-    let socket = null;
-    const queued = [];
-    const send = (value) => {
-        if (socket?.readyState === WebSocket.OPEN)
-            socket.send(JSON.stringify(value));
-        else
-            queued.push(value);
-    };
-    const mcp = createClaudeChannelServer((value) => {
-        const record = value;
-        if (record.type === "reply") {
-            send(ChannelToGatewaySchema.parse({
-                type: "channel.reply",
-                protocolVersion: REMOTE_PROTOCOL_VERSION,
-                sessionId: parsed.NOWCREW_REMOTE_SESSION_ID,
-                requestId: record.request_id,
-                text: record.text,
-            }));
-            return;
-        }
-        send(ChannelToGatewaySchema.parse({
-            type: "channel.permission",
-            protocolVersion: REMOTE_PROTOCOL_VERSION,
-            sessionId: parsed.NOWCREW_REMOTE_SESSION_ID,
-            requestId: record.requestId,
-            tool: record.tool,
-            description: record.description,
-            preview: record.preview,
-        }));
-    });
-    await mcp.connect(new StdioServerTransport());
-    let stopped = false;
-    const connect = () => {
-        if (stopped)
-            return;
-        const next = new WebSocket(url, { headers: { authorization: `Bearer ${token}` } });
-        socket = next;
-        next.on("open", () => {
-            next.send(JSON.stringify(ChannelToGatewaySchema.parse({
-                type: "channel.register",
-                protocolVersion: REMOTE_PROTOCOL_VERSION,
-                sessionId: parsed.NOWCREW_REMOTE_SESSION_ID,
-                cwd: parsed.NOWCREW_REMOTE_CWD,
-                pid: process.ppid,
-                generation: parsed.NOWCREW_REMOTE_GENERATION,
-            })));
-            for (const value of queued.splice(0))
-                next.send(JSON.stringify(value));
-        });
-        next.on("message", (raw) => {
-            const frame = GatewayToChannelSchema.safeParse(JSON.parse(raw.toString()));
-            if (!frame.success)
-                return;
-            if (frame.data.type === "channel.prompt") {
-                void mcp.notification({
-                    method: "notifications/claude/channel",
-                    params: {
-                        content: frame.data.text,
-                        meta: { request_id: frame.data.requestId },
-                    },
-                });
-            }
-            else if (frame.data.type === "channel.permission_response") {
-                void mcp.notification({
-                    method: "notifications/claude/channel/permission",
-                    params: {
-                        request_id: frame.data.requestId,
-                        behavior: frame.data.decision,
-                    },
-                });
-            }
-        });
-        next.on("close", () => {
-            if (socket === next)
-                socket = null;
-            if (!stopped)
-                setTimeout(connect, 1_000).unref();
-        });
-        next.on("error", () => { });
-    };
-    connect();
-    const stop = () => {
-        stopped = true;
-        socket?.close();
-    };
-    process.once("SIGTERM", stop);
-    process.once("SIGINT", stop);
-}

package/dist/remote/codex-client.js

@@ -1,451 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { WebSocket } from "ws";
-import { z } from "zod";
-import { MAX_REMOTE_WEBSOCKET_BUFFER_BYTES, } from "./protocol.js";
-export const MAX_CODEX_PENDING_RPCS = 128;
-export const MAX_CODEX_PENDING_INTERACTIONS = 128;
-const ThreadStatusSchema = z.discriminatedUnion("type", [
-    z.object({ type: z.literal("notLoaded") }).passthrough(),
-    z.object({ type: z.literal("idle") }).passthrough(),
-    z.object({ type: z.literal("systemError") }).passthrough(),
-    z.object({ type: z.literal("active"), activeFlags: z.array(z.unknown()).optional() }).passthrough(),
-]);
-const ThreadItemSchema = z.object({
-    type: z.string(),
-    id: z.string().optional(),
-}).passthrough();
-const TurnSchema = z.object({
-    id: z.string(),
-    status: z.string(),
-    items: z.array(ThreadItemSchema),
-    startedAt: z.number().nullable().optional(),
-    completedAt: z.number().nullable().optional(),
-}).passthrough();
-const ThreadSchema = z.object({
-    id: z.string().uuid(),
-    preview: z.string().default(""),
-    createdAt: z.number(),
-    updatedAt: z.number(),
-    recencyAt: z.number().nullable().optional(),
-    status: ThreadStatusSchema,
-    cwd: z.string(),
-    name: z.string().nullable().optional(),
-    turns: z.array(TurnSchema).default([]),
-}).passthrough();
-const ThreadListResponseSchema = z.object({
-    data: z.array(ThreadSchema),
-    nextCursor: z.string().nullable(),
-}).passthrough();
-const ThreadReadResponseSchema = z.object({ thread: ThreadSchema }).passthrough();
-const ThreadResumeResponseSchema = z.object({ thread: ThreadSchema }).passthrough();
-const ApprovalParamsSchema = z.object({
-    threadId: z.string().uuid(),
-    command: z.string().nullable().optional(),
-    reason: z.string().nullable().optional(),
-    grantRoot: z.string().nullable().optional(),
-}).passthrough();
-const QuestionParamsSchema = z.object({
-    threadId: z.string().uuid(),
-    questions: z.array(z.object({
-        id: z.string().min(1),
-        header: z.string(),
-        question: z.string(),
-        isSecret: z.boolean(),
-        options: z.array(z.object({
-            label: z.string(),
-            description: z.string(),
-        }).passthrough()).nullable(),
-    }).passthrough()).min(1).max(3),
-}).passthrough();
-function isoFromSeconds(value) {
-    return new Date((value ?? Date.now() / 1_000) * 1_000).toISOString();
-}
-function textInputs(content) {
-    if (!Array.isArray(content))
-        return "";
-    return content.flatMap((entry) => {
-        const value = entry;
-        if (value.type === "text" && typeof value.text === "string")
-            return [value.text];
-        if (value.type === "localImage" && typeof value.path === "string")
-            return [`[Image: ${value.path}]`];
-        return [];
-    }).join("\n").trim();
-}
-function itemToTimeline(raw, createdAt) {
-    const item = raw;
-    const id = typeof item.id === "string" ? `codex:${item.id}` : `codex:${randomUUID()}`;
-    if (item.type === "userMessage") {
-        const text = textInputs(item.content);
-        return text ? { id, kind: "message", role: "user", text, createdAt } : null;
-    }
-    if (item.type === "agentMessage" && typeof item.text === "string" && item.text.trim()) {
-        return { id, kind: "message", role: "assistant", text: item.text, createdAt };
-    }
-    if (item.type === "plan" && typeof item.text === "string") {
-        return { id, kind: "tool", name: "Plan", summary: item.text.slice(0, 12_000), status: "updated", createdAt };
-    }
-    if (item.type === "commandExecution" && typeof item.command === "string") {
-        const output = typeof item.aggregatedOutput === "string" ? `\n\n${item.aggregatedOutput}` : "";
-        return {
-            id,
-            kind: "tool",
-            name: "Command",
-            summary: `${item.command}${output}`.slice(0, 12_000),
-            status: typeof item.status === "string" ? item.status : "completed",
-            createdAt,
-        };
-    }
-    if (item.type === "fileChange") {
-        return {
-            id,
-            kind: "tool",
-            name: "File change",
-            summary: JSON.stringify(item.changes ?? []).slice(0, 12_000),
-            status: typeof item.status === "string" ? item.status : "completed",
-            createdAt,
-        };
-    }
-    if (item.type === "mcpToolCall" || item.type === "dynamicToolCall") {
-        const server = typeof item.server === "string" ? `${item.server}.` : "";
-        const tool = typeof item.tool === "string" ? item.tool : "tool";
-        return {
-            id,
-            kind: "tool",
-            name: `${server}${tool}`,
-            summary: JSON.stringify(item.arguments ?? {}).slice(0, 12_000),
-            status: typeof item.status === "string" ? item.status : "completed",
-            createdAt,
-        };
-    }
-    return null;
-}
-function threadSummary(thread) {
-    return {
-        id: thread.id,
-        runtime: "codex",
-        title: thread.name?.trim() || thread.preview.trim().slice(0, 240) || "Codex session",
-        cwd: thread.cwd,
-        updatedAt: isoFromSeconds(thread.recencyAt ?? thread.updatedAt),
-        controlState: "live",
-        busy: thread.status.type === "active",
-        source: "app_server",
-    };
-}
-function threadTimeline(thread) {
-    const items = [];
-    for (const turn of thread.turns) {
-        const createdAt = isoFromSeconds(turn.startedAt ?? turn.completedAt ?? thread.updatedAt);
-        for (const raw of turn.items) {
-            const mapped = itemToTimeline(raw, createdAt);
-            if (mapped)
-                items.push(mapped);
-        }
-    }
-    return items.length > 400 ? items.slice(items.length - 400) : items;
-}
-function ipcWebSocketUrl(socketPath) {
-    if (!socketPath.startsWith("/"))
-        throw new Error("Codex app-server socket path must be absolute");
-    if (socketPath.includes(":"))
-        throw new Error("Codex app-server socket path cannot contain ':'");
-    return `ws+unix://${socketPath}:/`;
-}
-export class CodexAppServerClient {
-    socket;
-    nextId = 1;
-    pending = new Map();
-    interactions = new Map();
-    listeners = new Set();
-    submissionTails = new Map();
-    closedError = null;
-    constructor(socket) {
-        this.socket = socket;
-        socket.on("message", (raw) => this.receive(raw.toString()));
-        socket.once("close", () => this.fail(new Error("Codex app-server connection closed")));
-        socket.once("error", (error) => this.fail(error));
-    }
-    static async connect(socketPath, timeoutMs = 5_000) {
-        const socket = new WebSocket(ipcWebSocketUrl(socketPath), {
-            perMessageDeflate: false,
-            maxPayload: MAX_REMOTE_WEBSOCKET_BUFFER_BYTES,
-        });
-        await new Promise((resolve, reject) => {
-            const timer = setTimeout(() => {
-                socket.terminate();
-                reject(new Error(`Timed out connecting to Codex app-server at ${socketPath}`));
-            }, timeoutMs);
-            socket.once("open", () => {
-                clearTimeout(timer);
-                resolve();
-            });
-            socket.once("error", (error) => {
-                clearTimeout(timer);
-                reject(error);
-            });
-        });
-        const client = new CodexAppServerClient(socket);
-        await client.request("initialize", {
-            clientInfo: { name: "nowcrew_remote", title: "NowCrew Remote", version: "1.0.0" },
-            capabilities: { experimentalApi: true, requestAttestation: false },
-        });
-        client.notify("initialized");
-        return client;
-    }
-    async listSessions() {
-        const threads = [];
-        let cursor = null;
-        for (let page = 0; page < 2; page += 1) {
-            const response = ThreadListResponseSchema.parse(await this.request("thread/list", {
-                limit: 100,
-                ...(cursor === null ? {} : { cursor }),
-            }));
-            threads.push(...response.data);
-            cursor = response.nextCursor;
-            if (!cursor)
-                break;
-        }
-        return threads.map(threadSummary).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
-    }
-    async timeline(sessionId) {
-        try {
-            const response = ThreadReadResponseSchema.parse(await this.request("thread/read", {
-                threadId: sessionId,
-                includeTurns: true,
-            }));
-            return threadTimeline(response.thread);
-        }
-        catch (error) {
-            if (error instanceof Error && /not found|does not exist/i.test(error.message))
-                return null;
-            throw error;
-        }
-    }
-    async submit(sessionId, input) {
-        const previous = this.submissionTails.get(sessionId) ?? Promise.resolve();
-        const execution = previous.catch(() => { }).then(() => this.submitNow(sessionId, input));
-        const tail = execution.then(() => { }, () => { });
-        this.submissionTails.set(sessionId, tail);
-        try {
-            return await execution;
-        }
-        finally {
-            if (this.submissionTails.get(sessionId) === tail)
-                this.submissionTails.delete(sessionId);
-        }
-    }
-    async submitNow(sessionId, input) {
-        const resumed = ThreadResumeResponseSchema.parse(await this.request("thread/resume", { threadId: sessionId }));
-        const active = [...resumed.thread.turns].reverse().find((turn) => turn.status === "inProgress");
-        const params = {
-            threadId: sessionId,
-            clientUserMessageId: input.idempotencyKey,
-            input: [{ type: "text", text: input.text, text_elements: [] }],
-        };
-        if (active) {
-            await this.request("turn/steer", { ...params, expectedTurnId: active.id });
-        }
-        else {
-            await this.request("turn/start", params);
-        }
-        return { requestId: input.idempotencyKey };
-    }
-    resolveApproval(sessionId, requestId, decision) {
-        const pending = this.takeInteraction(sessionId, requestId, "approval");
-        if (!pending)
-            return false;
-        this.respond(pending.rpcId, { decision: decision === "allow" ? "accept" : "decline" });
-        return true;
-    }
-    resolveQuestion(sessionId, requestId, input) {
-        const pending = this.takeInteraction(sessionId, requestId, "question");
-        if (!pending)
-            return false;
-        this.respond(pending.rpcId, {
-            answers: Object.fromEntries(Object.entries(input.answers).map(([id, answers]) => [id, { answers }])),
-        });
-        return true;
-    }
-    onEvent(listener) {
-        this.listeners.add(listener);
-        return () => this.listeners.delete(listener);
-    }
-    async close() {
-        if (this.socket.readyState === WebSocket.CLOSED)
-            return;
-        await new Promise((resolve) => {
-            const timer = setTimeout(() => {
-                this.socket.terminate();
-                resolve();
-            }, 1_000);
-            this.socket.once("close", () => {
-                clearTimeout(timer);
-                resolve();
-            });
-            this.socket.close(1000, "NowCrew gateway stopping");
-        });
-    }
-    request(method, params, timeoutMs = 30_000) {
-        if (this.closedError)
-            return Promise.reject(this.closedError);
-        if (this.pending.size >= MAX_CODEX_PENDING_RPCS) {
-            return Promise.reject(new Error("Codex app-server RPC queue is full"));
-        }
-        const id = this.nextId++;
-        return new Promise((resolve, reject) => {
-            const timer = setTimeout(() => {
-                this.pending.delete(id);
-                reject(new Error(`Codex app-server ${method} timed out`));
-            }, timeoutMs);
-            this.pending.set(id, { resolve, reject, timer });
-            try {
-                this.send({ id, method, params });
-            }
-            catch (error) {
-                clearTimeout(timer);
-                this.pending.delete(id);
-                reject(error instanceof Error ? error : new Error(String(error)));
-            }
-        });
-    }
-    notify(method, params) {
-        this.send({ method, ...(params === undefined ? {} : { params }) });
-    }
-    respond(id, result) {
-        this.send({ id, result });
-    }
-    send(value) {
-        if (this.socket.readyState !== WebSocket.OPEN)
-            throw this.closedError ?? new Error("Codex app-server is not open");
-        const serialized = JSON.stringify(value);
-        if (this.socket.bufferedAmount + Buffer.byteLength(serialized, "utf8") > MAX_REMOTE_WEBSOCKET_BUFFER_BYTES) {
-            const error = new Error("Codex app-server outbound buffer limit exceeded");
-            this.fail(error);
-            this.socket.close(1013, "outbound buffer limit");
-            throw error;
-        }
-        this.socket.send(serialized);
-    }
-    receive(raw) {
-        let message;
-        try {
-            message = JSON.parse(raw);
-        }
-        catch {
-            return;
-        }
-        if (message.id !== undefined && message.method !== undefined) {
-            this.receiveServerRequest(message.id, message.method, message.params);
-            return;
-        }
-        if (message.id !== undefined) {
-            const pending = this.pending.get(message.id);
-            if (!pending)
-                return;
-            this.pending.delete(message.id);
-            clearTimeout(pending.timer);
-            if (message.error)
-                pending.reject(new Error(`Codex app-server RPC failed: ${message.error.message ?? "unknown error"}`));
-            else
-                pending.resolve(message.result);
-            return;
-        }
-        if (message.method)
-            this.receiveNotification(message.method, message.params);
-    }
-    receiveServerRequest(id, method, params) {
-        if (method === "item/commandExecution/requestApproval" || method === "item/fileChange/requestApproval") {
-            const parsed = ApprovalParamsSchema.safeParse(params);
-            if (!parsed.success) {
-                this.respond(id, { decision: "decline" });
-                return;
-            }
-            if (this.interactions.size >= MAX_CODEX_PENDING_INTERACTIONS) {
-                this.respond(id, { decision: "decline" });
-                return;
-            }
-            const requestId = randomUUID();
-            this.interactions.set(requestId, { rpcId: id, sessionId: parsed.data.threadId, type: "approval" });
-            const tool = method.includes("commandExecution") ? "Command" : "File change";
-            const preview = parsed.data.command ?? parsed.data.grantRoot ?? parsed.data.reason ?? tool;
-            this.emit({
-                type: "timeline.appended",
-                sessionId: parsed.data.threadId,
-                item: { id: `codex-approval:${requestId}`, kind: "approval", requestId, tool, preview, createdAt: new Date().toISOString() },
-            });
-            return;
-        }
-        if (method === "item/tool/requestUserInput") {
-            const parsed = QuestionParamsSchema.safeParse(params);
-            if (!parsed.success) {
-                this.respond(id, { answers: {} });
-                return;
-            }
-            if (this.interactions.size >= MAX_CODEX_PENDING_INTERACTIONS) {
-                this.respond(id, { answers: {} });
-                return;
-            }
-            const requestId = randomUUID();
-            this.interactions.set(requestId, { rpcId: id, sessionId: parsed.data.threadId, type: "question" });
-            this.emit({
-                type: "timeline.appended",
-                sessionId: parsed.data.threadId,
-                item: {
-                    id: `codex-question:${requestId}`,
-                    kind: "question",
-                    requestId,
-                    questions: parsed.data.questions.map((question) => ({
-                        id: question.id,
-                        header: question.header,
-                        question: question.question,
-                        isSecret: question.isSecret,
-                        options: question.options,
-                    })),
-                    createdAt: new Date().toISOString(),
-                },
-            });
-            return;
-        }
-        this.send({ id, error: { code: -32001, message: `NowCrew does not support ${method}` } });
-    }
-    receiveNotification(method, params) {
-        if (["thread/started", "thread/status/changed", "thread/name/updated", "turn/started", "turn/completed"].includes(method)) {
-            this.emit({ type: "sessions.changed" });
-        }
-        if (method !== "item/completed")
-            return;
-        const parsed = z.object({
-            threadId: z.string().uuid(),
-            item: ThreadItemSchema,
-            completedAtMs: z.number().optional(),
-        }).passthrough().safeParse(params);
-        if (!parsed.success)
-            return;
-        const item = itemToTimeline(parsed.data.item, new Date(parsed.data.completedAtMs ?? Date.now()).toISOString());
-        if (item)
-            this.emit({ type: "timeline.appended", sessionId: parsed.data.threadId, item });
-    }
-    takeInteraction(sessionId, requestId, type) {
-        const pending = this.interactions.get(requestId);
-        if (!pending || pending.sessionId !== sessionId || pending.type !== type)
-            return null;
-        this.interactions.delete(requestId);
-        return pending;
-    }
-    emit(event) {
-        for (const listener of this.listeners)
-            listener(event);
-    }
-    fail(error) {
-        if (this.closedError)
-            return;
-        this.closedError = error;
-        for (const pending of this.pending.values()) {
-            clearTimeout(pending.timer);
-            pending.reject(error);
-        }
-        this.pending.clear();
-        this.interactions.clear();
-        this.emit({ type: "sessions.changed" });
-    }
-}

package/dist/remote/codex-runtime.js

@@ -1,77 +0,0 @@
-import { once } from "node:events";
-import { lstat, mkdir, unlink } from "node:fs/promises";
-import { dirname } from "node:path";
-import spawn from "cross-spawn";
-import { CodexAppServerClient } from "./codex-client.js";
-async function connect(socketPath, timeoutMs) {
-    try {
-        return await CodexAppServerClient.connect(socketPath, timeoutMs);
-    }
-    catch {
-        return null;
-    }
-}
-async function removeStaleSocket(socketPath) {
-    try {
-        const info = await lstat(socketPath);
-        if (!info.isSocket())
-            throw new Error(`Refusing to replace non-socket path: ${socketPath}`);
-        await unlink(socketPath);
-    }
-    catch (error) {
-        if (error.code !== "ENOENT")
-            throw error;
-    }
-}
-export async function startCodexRuntime(socketPath, bin = process.env.NOWCREW_CODEX_BIN ?? "codex") {
-    const existing = await connect(socketPath, 500);
-    if (existing) {
-        return { adapter: existing, socketPath, close: () => existing.close() };
-    }
-    await mkdir(dirname(socketPath), { recursive: true, mode: 0o700 });
-    await removeStaleSocket(socketPath);
-    const child = spawn(bin, ["app-server", "--listen", `unix://${socketPath}`], {
-        env: process.env,
-        stdio: ["ignore", "ignore", "pipe"],
-    });
-    let stderr = "";
-    child.stderr?.on("data", (chunk) => {
-        stderr = `${stderr}${String(chunk)}`.slice(-4_000);
-    });
-    let adapter = null;
-    for (let attempt = 0; attempt < 50; attempt += 1) {
-        if (child.exitCode !== null || child.signalCode !== null)
-            break;
-        await new Promise((resolve) => setTimeout(resolve, 100));
-        adapter = await connect(socketPath, 500);
-        if (adapter)
-            break;
-    }
-    if (!adapter) {
-        if (child.exitCode === null && child.signalCode === null)
-            child.kill("SIGTERM");
-        throw new Error(`Codex app-server did not start at ${socketPath}${stderr ? `: ${stderr.trim()}` : ""}`);
-    }
-    return {
-        adapter,
-        socketPath,
-        async close() {
-            await adapter.close();
-            if (child.exitCode !== null || child.signalCode !== null)
-                return;
-            const closed = once(child, "close").then(() => undefined);
-            child.kill("SIGTERM");
-            let timer;
-            const stopped = await Promise.race([
-                closed.then(() => true),
-                new Promise((resolve) => { timer = setTimeout(() => resolve(false), 1_000); }),
-            ]);
-            if (timer)
-                clearTimeout(timer);
-            if (!stopped && child.exitCode === null && child.signalCode === null) {
-                child.kill("SIGKILL");
-                await closed;
-            }
-        },
-    };
-}