Skip to content

The one and only agent harness for complex codebases. Project memory, planning, execution, and verified completion inside Codex.

8.6 KB
Raw Blame
import { connect } from "node:net";
import { homedir } from "node:os";
import { join } from "node:path";
import { setTimeout as delay } from "node:timers/promises";
import { parseLspRequestContext } from "@oh-my-opencode/lsp-core/request-context";
import { isPlainRecord } from "@oh-my-opencode/mcp-stdio-core/record";
import { daemonFailureResult } from "./daemon-failure-result.js";
import { DaemonAuthenticationRejectedError, DaemonRequestCancelledError, DaemonRequestError, DaemonRequestTimedOutError, } from "./daemon-request-error.js";
import { DaemonUnreachableError, ensureDaemonRunning, probeDaemon } from "./ensure-daemon.js";
import { authEnvelope, isAuthErrorResponse, readAuthToken } from "./ipc-protocol.js";
import { daemonPaths } from "./paths.js";
import { CONTEXT_KEY } from "./request-routing.js";
import { createLineDecoder, encodeJsonLine } from "./socket-jsonrpc.js";
const DEFAULT_REQUEST_TIMEOUT_MS = 30_000;
const STARTUP_BACKOFF_MS = [0, 100, 300];
let nextProxyRequestId = 1;
export async function callToolViaDaemon(name, args, options) {
    const context = requireContext(options.context);
    const paths = options.paths ?? daemonPaths();
    const ensure = options.ensure ??
        ((ensurePaths, signal) => ensureDaemonRunning(ensurePaths, undefined, signal === undefined ? {} : { signal }));
    const timeoutMs = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
    const requestArgs = withContext(args, context);
    const probe = options.probe ?? ((probePaths, signal) => probeDaemon(probePaths, undefined, signal));
    const sleep = options.sleep ?? ((ms, signal) => delay(ms, undefined, { signal }));
    let lastError;
    let authRefreshUsed = false;
    for (const [attempt, backoffMs] of STARTUP_BACKOFF_MS.entries()) {
        try {
            if (backoffMs > 0)
                await sleep(backoffMs, options.signal);
            if (options.signal?.aborted)
                throw new DaemonRequestCancelledError(false);
            if (attempt === 0) {
                await ensureDaemonAvailable(paths, ensure, options.signal);
            }
            else if (!(await probe(paths, options.signal))) {
                throw new DaemonUnreachableError(paths.socket);
            }
            const token = readAuthToken(paths);
            if (!token)
                throw new DaemonRequestError("daemon auth token missing", false);
            const sendOptions = options.signal === undefined ? { timeoutMs } : { timeoutMs, signal: options.signal };
            return await sendToolCall(paths, token, name, requestArgs, sendOptions);
        }
        catch (error) {
            if (options.signal?.aborted) {
                lastError = new DaemonRequestCancelledError(false);
                break;
            }
            lastError = error;
            if (error instanceof DaemonAuthenticationRejectedError && !authRefreshUsed) {
                authRefreshUsed = true;
                continue;
            }
            if (error instanceof DaemonRequestCancelledError)
                break;
            if (error instanceof DaemonRequestError && (error.requestWritten || !isRetryableTool(name)))
                break;
        }
    }
    return daemonFailureResult(paths, lastError);
}
export function callDiagnosticsViaDaemon(filePath, options) {
    return callToolViaDaemon("diagnostics", { filePath, severity: "error" }, options);
}
export function callFormatViaDaemon(filePath, options) {
    return callToolViaDaemon("format", { filePath }, options);
}
export function currentRequestContext(env = process.env) {
    const cwd = process.cwd();
    const home = env["HOME"] ?? homedir();
    return parseLspRequestContext({
        cwd,
        projectConfigPaths: [join(cwd, ".codex", "lsp-client.json")],
        userConfigPath: join(home, ".codex", "lsp-client.json"),
        installDecisionsPath: join(home, ".codex", "lsp-install-decisions.json"),
        capabilities: { installDecisionTool: true },
    });
}
function requireContext(context) {
    if (!context)
        throw new DaemonRequestError("daemon tool context is required", false);
    return parseLspRequestContext(context);
}
function withContext(args, context) {
    return { ...args, [CONTEXT_KEY]: context };
}
function ensureDaemonAvailable(paths, ensure, signal) {
    if (!signal)
        return ensure(paths);
    return new Promise((resolve, reject) => {
        let settled = false;
        const finish = (run) => {
            if (settled)
                return;
            settled = true;
            signal.removeEventListener("abort", onAbort);
            run();
        };
        const onAbort = () => finish(() => reject(new DaemonRequestCancelledError(false)));
        if (signal.aborted) {
            onAbort();
            return;
        }
        signal.addEventListener("abort", onAbort, { once: true });
        Promise.resolve()
            .then(() => ensure(paths, signal))
            .then(() => finish(() => resolve()), (error) => finish(() => reject(signal.aborted ? new DaemonRequestCancelledError(false) : error)));
    });
}
function sendToolCall(paths, token, name, args, options) {
    return new Promise((resolve, reject) => {
        const socket = connect(paths.socket);
        const requestId = allocateProxyRequestId();
        let settled = false;
        let requestWritten = false;
        let cancelAfterWrite = false;
        const cancelPayload = () => encodeJsonLine({
            jsonrpc: "2.0",
            method: "$/cancelRequest",
            params: { _omo: authEnvelope(token), id: requestId },
        });
        const finish = (run) => {
            if (settled)
                return;
            settled = true;
            clearTimeout(timer);
            options.signal?.removeEventListener("abort", onAbort);
            destroyAfterCancel();
            run();
        };
        const sendCancel = () => {
            if (!requestWritten) {
                cancelAfterWrite = true;
                return;
            }
            if (!socket.writable)
                return;
            socket.write(cancelPayload());
        };
        const destroyAfterCancel = () => {
            socket.destroy();
        };
        const onAbort = () => {
            sendCancel();
            finish(() => reject(new DaemonRequestCancelledError(requestWritten)));
        };
        const timer = setTimeout(() => {
            sendCancel();
            finish(() => reject(new DaemonRequestTimedOutError(requestWritten, options.timeoutMs)));
        }, options.timeoutMs);
        timer.unref();
        if (options.signal?.aborted) {
            onAbort();
            return;
        }
        options.signal?.addEventListener("abort", onAbort, { once: true });
        const decoder = createLineDecoder((message) => {
            if (isAuthErrorResponse(message)) {
                finish(() => reject(new DaemonAuthenticationRejectedError()));
                return;
            }
            const result = toToolResult(message, requestId);
            if (result)
                finish(() => resolve(result));
            else
                finish(() => reject(new DaemonRequestError("invalid daemon response", requestWritten)));
        });
        socket.once("connect", () => {
            const payload = encodeJsonLine({
                jsonrpc: "2.0",
                id: requestId,
                method: "tools/call",
                params: { _omo: authEnvelope(token), name, arguments: args },
            });
            socket.write(payload, () => {
                requestWritten = true;
                if (cancelAfterWrite && socket.writable)
                    socket.write(cancelPayload());
            });
        });
        socket.on("data", (chunk) => decoder.push(chunk));
        socket.once("error", (error) => finish(() => reject(new DaemonRequestError(error.message, requestWritten))));
        socket.once("close", () => finish(() => reject(new DaemonRequestError("daemon connection closed", requestWritten))));
    });
}
function toToolResult(message, requestId) {
    if (!isPlainRecord(message) || message["id"] !== requestId)
        return null;
    const result = message["result"];
    if (!isPlainRecord(result) || !Array.isArray(result["content"]))
        return null;
    return {
        content: result["content"],
        isError: result["isError"] === true,
        details: result["details"],
    };
}
function allocateProxyRequestId() {
    const id = nextProxyRequestId;
    nextProxyRequestId += 1;
    if (nextProxyRequestId > Number.MAX_SAFE_INTEGER)
        nextProxyRequestId = 1;
    return id;
}
function isRetryableTool(name) {
    return name !== "rename" && name !== "lsp_rename";
}