oh-my-opencode 4.8.1 → 4.9.0

package/packages/lsp-daemon/dist/daemon-client.d.ts

@@ -0,0 +1,19 @@
+import type { ToolExecutionResult } from "@code-yeongyu/lsp-tools-mcp/dist/tools.js";
+import { type DaemonPaths } from "./paths.js";
+export declare class DaemonRequestError extends Error {
+    readonly requestWritten: boolean;
+    constructor(message: string, requestWritten: boolean);
+}
+export interface DaemonToolContext {
+    cwd?: string;
+    env?: Record<string, string>;
+}
+export interface CallToolOptions {
+    context?: DaemonToolContext;
+    paths?: DaemonPaths;
+    requestTimeoutMs?: number;
+    ensure?: (paths: DaemonPaths) => Promise<void>;
+}
+export declare function callToolViaDaemon(name: string, args: Record<string, unknown>, options?: CallToolOptions): Promise<ToolExecutionResult>;
+export declare function callDiagnosticsViaDaemon(filePath: string, options?: CallToolOptions): Promise<ToolExecutionResult>;
+export declare function currentRequestContext(env?: NodeJS.ProcessEnv): DaemonToolContext;

package/packages/lsp-daemon/dist/daemon-client.js

@@ -0,0 +1,114 @@
+import { connect } from "node:net";
+import { ensureDaemonRunning } from "./ensure-daemon.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 REQUEST_ID = 1;
+export class DaemonRequestError extends Error {
+    constructor(message, requestWritten) {
+        super(message);
+        this.name = "DaemonRequestError";
+        this.requestWritten = requestWritten;
+    }
+}
+export async function callToolViaDaemon(name, args, options = {}) {
+    const paths = options.paths ?? daemonPaths();
+    const ensure = options.ensure ?? ensureDaemonRunning;
+    const timeoutMs = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+    const requestArgs = withContext(args, options.context);
+    let lastError;
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+        try {
+            await ensure(paths);
+            return await sendToolCall(paths.socket, name, requestArgs, timeoutMs);
+        }
+        catch (error) {
+            lastError = error;
+            if (error instanceof DaemonRequestError && error.requestWritten)
+                break;
+        }
+    }
+    return daemonUnreachableResult(paths, lastError);
+}
+export function callDiagnosticsViaDaemon(filePath, options = {}) {
+    return callToolViaDaemon("diagnostics", { filePath, severity: "error" }, options);
+}
+const FORWARDED_ENV_KEYS = [
+    "LSP_TOOLS_MCP_PROJECT_CONFIG",
+    "LSP_TOOLS_MCP_USER_CONFIG",
+    "LSP_TOOLS_MCP_INSTALL_DECISIONS",
+];
+export function currentRequestContext(env = process.env) {
+    const forwarded = {};
+    for (const key of FORWARDED_ENV_KEYS) {
+        const value = env[key];
+        if (value !== undefined)
+            forwarded[key] = value;
+    }
+    return { cwd: process.cwd(), env: forwarded };
+}
+function withContext(args, context) {
+    if (!context || (context.cwd === undefined && context.env === undefined))
+        return args;
+    return { ...args, [CONTEXT_KEY]: context };
+}
+function daemonUnreachableResult(paths, error) {
+    const text = [
+        `LSP daemon unreachable: ${errorText(error)}.`,
+        "The MCP server is a thin proxy and never runs language servers in-process.",
+        `Socket: ${paths.socket}`,
+        `Logs: ${paths.log}`,
+        "The daemon is auto-started on demand and will be retried on the next request.",
+    ].join("\n");
+    return { content: [{ type: "text", text }], isError: true };
+}
+function sendToolCall(socketPath, name, args, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const socket = connect(socketPath);
+        let settled = false;
+        let requestWritten = false;
+        const finish = (run) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            socket.destroy();
+            run();
+        };
+        const timer = setTimeout(() => finish(() => reject(new DaemonRequestError("daemon request timed out", requestWritten))), timeoutMs);
+        timer.unref();
+        const decoder = createLineDecoder((message) => {
+            const result = toToolResult(message);
+            if (result)
+                finish(() => resolve(result));
+            else
+                finish(() => reject(new DaemonRequestError("invalid daemon response", requestWritten)));
+        });
+        socket.once("connect", () => {
+            requestWritten = true;
+            socket.write(encodeJsonLine({ jsonrpc: "2.0", id: REQUEST_ID, method: "tools/call", params: { name, arguments: args } }));
+        });
+        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) {
+    if (!isRecord(message) || message["id"] !== REQUEST_ID)
+        return null;
+    const result = message["result"];
+    if (!isRecord(result) || !Array.isArray(result["content"]))
+        return null;
+    return {
+        content: result["content"],
+        isError: result["isError"] === true,
+        details: result["details"],
+    };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function errorText(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/packages/lsp-daemon/dist/daemon-server.d.ts

@@ -0,0 +1,12 @@
+import { type Server } from "node:net";
+import type { DaemonPaths } from "./paths.js";
+export interface DaemonServerOptions {
+    idleShutdownMs?: number;
+    idleCheckIntervalMs?: number;
+    onIdleShutdown?: () => void;
+}
+export interface DaemonServerHandle {
+    readonly server: Server;
+    close(): Promise<void>;
+}
+export declare function startDaemonServer(paths: DaemonPaths, options?: DaemonServerOptions): Promise<DaemonServerHandle>;

package/packages/lsp-daemon/dist/daemon-server.js

@@ -0,0 +1,106 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { createServer } from "node:net";
+import { join } from "node:path";
+import { disposeDefaultLspManager, getLspManager } from "@code-yeongyu/lsp-tools-mcp/dist/lsp/manager.js";
+import { unlinkQuietly } from "./lock.js";
+import { handleDaemonMessage } from "./request-routing.js";
+import { createLineDecoder, encodeJsonLine } from "./socket-jsonrpc.js";
+const DEFAULT_IDLE_SHUTDOWN_MS = 30 * 60_000;
+const DEFAULT_IDLE_CHECK_INTERVAL_MS = 60_000;
+export async function startDaemonServer(paths, options = {}) {
+    const idleShutdownMs = options.idleShutdownMs ?? DEFAULT_IDLE_SHUTDOWN_MS;
+    const idleCheckIntervalMs = options.idleCheckIntervalMs ?? DEFAULT_IDLE_CHECK_INTERVAL_MS;
+    mkdirSync(paths.dir, { recursive: true });
+    unlinkQuietly(paths.socket);
+    const connections = new Set();
+    let lastActiveAt = Date.now();
+    const touch = () => {
+        lastActiveAt = Date.now();
+    };
+    const server = createServer((socket) => {
+        connections.add(socket);
+        touch();
+        const decoder = createLineDecoder((message) => {
+            touch();
+            void respond(socket, message);
+        });
+        socket.on("data", (chunk) => decoder.push(chunk));
+        socket.on("error", () => socket.destroy());
+        socket.on("close", () => {
+            connections.delete(socket);
+            touch();
+        });
+    });
+    server.on("error", (error) => logServerError(error));
+    const endpointPath = join(paths.dir, "daemon.endpoint");
+    await listen(server, paths.socket);
+    writeFileSync(paths.pid, `${process.pid}\n`);
+    writeFileSync(endpointPath, paths.socket);
+    let closed = false;
+    const close = async () => {
+        if (closed)
+            return;
+        closed = true;
+        clearInterval(idleTimer);
+        for (const socket of connections)
+            socket.destroy();
+        connections.clear();
+        await closeServer(server);
+        unlinkQuietly(paths.socket);
+        unlinkQuietly(paths.pid);
+        unlinkQuietly(endpointPath);
+        await disposeDefaultLspManager();
+    };
+    const idleTimer = setInterval(() => {
+        if (connections.size > 0)
+            return;
+        if (getLspManager().clientCount() > 0) {
+            touch();
+            return;
+        }
+        if (Date.now() - lastActiveAt < idleShutdownMs)
+            return;
+        if (options.onIdleShutdown) {
+            options.onIdleShutdown();
+            return;
+        }
+        void close().then(() => process.exit(0));
+    }, idleCheckIntervalMs);
+    idleTimer.unref();
+    installSignalHandlers(close);
+    return { server, close };
+}
+async function respond(socket, message) {
+    try {
+        const response = await handleDaemonMessage(message);
+        if (response && socket.writable)
+            socket.write(encodeJsonLine(response));
+    }
+    catch (error) {
+        logServerError(error);
+    }
+}
+function listen(server, socketPath) {
+    return new Promise((resolve, reject) => {
+        const onError = (error) => reject(error);
+        server.once("error", onError);
+        server.listen(socketPath, () => {
+            server.removeListener("error", onError);
+            resolve();
+        });
+    });
+}
+function closeServer(server) {
+    return new Promise((resolve) => server.close(() => resolve()));
+}
+function installSignalHandlers(close) {
+    const handler = () => {
+        void close().then(() => process.exit(0));
+    };
+    process.once("SIGTERM", handler);
+    process.once("SIGINT", handler);
+}
+function logServerError(error) {
+    const message = error instanceof Error ? (error.stack ?? error.message) : String(error);
+    process.stderr.write(`[lsp-daemon] ${message}\n`);
+}

package/packages/lsp-daemon/dist/ensure-daemon.d.ts

@@ -0,0 +1,21 @@
+import { type LockHandle } from "./lock.js";
+import type { DaemonPaths } from "./paths.js";
+export declare class DaemonUnreachableError extends Error {
+    constructor(socketPath: string);
+}
+export interface EnsureDaemonDeps {
+    probe(socketPath: string): Promise<boolean>;
+    acquireLock(lockPath: string): LockHandle | null;
+    cleanupStaleSocket(socketPath: string): void;
+    spawnDaemon(paths: DaemonPaths): void;
+    sleep(ms: number): Promise<void>;
+    now(): number;
+}
+export interface EnsureDaemonOptions {
+    readyTimeoutMs?: number;
+    pollIntervalMs?: number;
+}
+export declare function ensureDaemonRunning(paths: DaemonPaths, deps?: EnsureDaemonDeps, options?: EnsureDaemonOptions): Promise<void>;
+export declare function probeSocket(socketPath: string, timeoutMs?: number): Promise<boolean>;
+export declare function spawnDaemonProcess(paths: DaemonPaths): void;
+export declare function defaultEnsureDaemonDeps(): EnsureDaemonDeps;

package/packages/lsp-daemon/dist/ensure-daemon.js

@@ -0,0 +1,97 @@
+import { spawn } from "node:child_process";
+import { closeSync, existsSync, mkdirSync, openSync } from "node:fs";
+import { connect } from "node:net";
+import { dirname } from "node:path";
+import { execPath } from "node:process";
+import { fileURLToPath } from "node:url";
+import { tryAcquireLock, unlinkQuietly } from "./lock.js";
+const PROBE_TIMEOUT_MS = 500;
+const DEFAULT_READY_TIMEOUT_MS = 5_000;
+const DEFAULT_POLL_INTERVAL_MS = 100;
+export class DaemonUnreachableError extends Error {
+    constructor(socketPath) {
+        super(`LSP daemon did not become reachable at ${socketPath}`);
+        this.name = "DaemonUnreachableError";
+    }
+}
+export async function ensureDaemonRunning(paths, deps = defaultEnsureDaemonDeps(), options = {}) {
+    const readyTimeoutMs = options.readyTimeoutMs ?? DEFAULT_READY_TIMEOUT_MS;
+    const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+    if (await deps.probe(paths.socket))
+        return;
+    const lock = deps.acquireLock(paths.lock);
+    if (!lock) {
+        await waitUntilReachable(paths.socket, deps, readyTimeoutMs, pollIntervalMs);
+        return;
+    }
+    try {
+        if (await deps.probe(paths.socket))
+            return;
+        deps.cleanupStaleSocket(paths.socket);
+        deps.spawnDaemon(paths);
+        await waitUntilReachable(paths.socket, deps, readyTimeoutMs, pollIntervalMs);
+    }
+    finally {
+        lock.release();
+    }
+}
+async function waitUntilReachable(socketPath, deps, readyTimeoutMs, pollIntervalMs) {
+    const deadline = deps.now() + readyTimeoutMs;
+    for (;;) {
+        if (await deps.probe(socketPath))
+            return;
+        if (deps.now() >= deadline)
+            throw new DaemonUnreachableError(socketPath);
+        await deps.sleep(pollIntervalMs);
+    }
+}
+export function probeSocket(socketPath, timeoutMs = PROBE_TIMEOUT_MS) {
+    return new Promise((resolve) => {
+        const socket = connect(socketPath);
+        const finish = (ok) => {
+            socket.destroy();
+            resolve(ok);
+        };
+        const timer = setTimeout(() => finish(false), timeoutMs);
+        timer.unref?.();
+        socket.once("connect", () => {
+            clearTimeout(timer);
+            finish(true);
+        });
+        socket.once("error", () => {
+            clearTimeout(timer);
+            finish(false);
+        });
+    });
+}
+export function spawnDaemonProcess(paths) {
+    mkdirSync(dirname(paths.log), { recursive: true });
+    const logFd = openSync(paths.log, "a");
+    try {
+        const cliPath = fileURLToPath(new URL("./cli.js", import.meta.url));
+        const child = spawn(execPath, [cliPath, "daemon"], {
+            detached: true,
+            stdio: ["ignore", logFd, logFd],
+        });
+        child.unref();
+    }
+    finally {
+        closeSync(logFd);
+    }
+}
+export function defaultEnsureDaemonDeps() {
+    return {
+        probe: (socketPath) => probeSocket(socketPath),
+        acquireLock: (lockPath) => tryAcquireLock(lockPath),
+        cleanupStaleSocket: (socketPath) => {
+            if (existsSync(socketPath))
+                unlinkQuietly(socketPath);
+        },
+        spawnDaemon: (paths) => spawnDaemonProcess(paths),
+        sleep: (ms) => new Promise((resolve) => {
+            const timer = setTimeout(resolve, ms);
+            timer.unref?.();
+        }),
+        now: () => Date.now(),
+    };
+}

package/packages/lsp-daemon/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { disposeDefaultLspManager } from "@code-yeongyu/lsp-tools-mcp/dist/lsp/manager.js";
+export { type CallToolOptions, callDiagnosticsViaDaemon, callToolViaDaemon, currentRequestContext, type DaemonToolContext, } from "./daemon-client.js";
+export { ensureDaemonRunning } from "./ensure-daemon.js";
+export { type DaemonPaths, daemonPaths } from "./paths.js";
+export { runMcpStdioProxy } from "./proxy.js";