oh-my-opencode 4.17.1 → 4.18.1

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

@@ -1,19 +1,30 @@
+import { existsSync, realpathSync } from "node:fs";
+import { basename, delimiter, dirname, isAbsolute } from "node:path";
 import { jsonRpcId, runJsonRpcStdioServer, successResponse } from "@oh-my-opencode/mcp-stdio-core";
 import { isPlainRecord } from "@oh-my-opencode/mcp-stdio-core/record";
 import { handleLspMcpRequest } from "@oh-my-opencode/lsp-core/mcp";
-import { callToolViaDaemon, currentRequestContext, } from "./daemon-client.js";
+import { createStandaloneMcpRequestContext, runWithRequestContext } from "@oh-my-opencode/lsp-core/request-context";
+import { callToolViaDaemon } from "./daemon-client.js";
 import { daemonPaths } from "./paths.js";
 export async function runMcpStdioProxy(options = {}) {
     const input = options.input ?? process.stdin;
     const output = options.output ?? process.stdout;
     const paths = options.paths ?? daemonPaths();
-    const context = options.context ?? currentRequestContext();
+    const env = options.env ?? process.env;
+    const cwd = options.cwd ?? inferOpenCodeProjectCwd(env["LSP_TOOLS_MCP_PROJECT_CONFIG"]);
+    const contextEnv = cwd === undefined ? env : canonicalizeContextEnv(env);
+    const contextInput = {
+        env: contextEnv,
+        ...(cwd === undefined ? {} : { cwd }),
+        ...(options.homeDir === undefined ? {} : { homeDir: options.homeDir }),
+    };
+    const context = options.context ?? createStandaloneMcpRequestContext(contextInput);
     const callOptions = { paths, context, ...(options.ensure ? { ensure: options.ensure } : {}) };
     await runJsonRpcStdioServer({
         input,
         output,
         idleTimeoutMs: 0,
-        handler: handleProxyRequest,
+        handler: (request, requestOptions) => runWithRequestContext(context, () => handleProxyRequest(request, requestOptions)),
         handlerOptions: callOptions,
         onHandlerError: (error) => {
             process.stderr.write(`[lsp-daemon] proxy error: ${error instanceof Error ? error.message : String(error)}\n`);
@@ -36,3 +47,43 @@ function asToolCall(parsed) {
     const args = params["arguments"];
     return { id: jsonRpcId(parsed["id"]), name: params["name"], args: isPlainRecord(args) ? args : {} };
 }
+function inferOpenCodeProjectCwd(projectConfigEnv) {
+    if (!projectConfigEnv)
+        return undefined;
+    for (const entry of projectConfigEnv.split(delimiter)) {
+        const projectRoot = projectRootFromOpenCodeConfigPath(entry);
+        if (projectRoot)
+            return projectRoot;
+    }
+    return undefined;
+}
+function canonicalizeContextEnv(env) {
+    return {
+        ...env,
+        LSP_TOOLS_MCP_PROJECT_CONFIG: canonicalizePathList(env["LSP_TOOLS_MCP_PROJECT_CONFIG"]),
+        LSP_TOOLS_MCP_USER_CONFIG: canonicalizePath(env["LSP_TOOLS_MCP_USER_CONFIG"]),
+        LSP_TOOLS_MCP_INSTALL_DECISIONS: canonicalizePath(env["LSP_TOOLS_MCP_INSTALL_DECISIONS"]),
+    };
+}
+function canonicalizePathList(value) {
+    if (value === undefined)
+        return undefined;
+    return value
+        .split(delimiter)
+        .map((entry) => canonicalizePath(entry) ?? entry)
+        .join(delimiter);
+}
+function canonicalizePath(value) {
+    if (value === undefined || !isAbsolute(value) || !existsSync(value))
+        return value;
+    return realpathSync(value);
+}
+function projectRootFromOpenCodeConfigPath(path) {
+    if (basename(path) !== "lsp.json" && basename(path) !== "lsp-client.json")
+        return undefined;
+    const configDir = dirname(path);
+    const configDirName = basename(configDir);
+    if (configDirName !== ".opencode" && configDirName !== ".omo")
+        return undefined;
+    return dirname(configDir);
+}

package/packages/lsp-daemon/dist/request-routing.d.ts

@@ -1,9 +1,14 @@
-import { type JsonRpcResponse } from "@oh-my-opencode/lsp-core/mcp";
 import { type RequestContext } from "@oh-my-opencode/lsp-core/request-context";
+import type { DaemonOwner } from "./ownership.js";
 export declare const CONTEXT_KEY = "_context";
 export interface RoutedRequest {
     input: unknown;
     context: RequestContext | undefined;
 }
 export declare function extractRequestContext(raw: unknown): RoutedRequest;
-export declare function handleDaemonMessage(raw: unknown): Promise<JsonRpcResponse | undefined>;
+export type DaemonRouteState = {
+    readonly token: string;
+    readonly owner: DaemonOwner;
+    readonly activeRequests?: Map<string, AbortController>;
+};
+export declare function handleDaemonMessage(raw: unknown, state: DaemonRouteState): Promise<unknown>;

package/packages/lsp-daemon/dist/request-routing.js

@@ -1,42 +1,91 @@
 import { handleLspMcpRequest } from "@oh-my-opencode/lsp-core/mcp";
-import { runWithRequestContext } from "@oh-my-opencode/lsp-core/request-context";
+import { parseLspRequestContext, runWithRequestContext } from "@oh-my-opencode/lsp-core/request-context";
 import { isPlainRecord } from "@oh-my-opencode/mcp-stdio-core/record";
+import { authenticateMessage, OMO_DAEMON_PROTOCOL_VERSION } from "./ipc-protocol.js";
 export const CONTEXT_KEY = "_context";
+class InvalidDaemonRequestError extends Error {
+    constructor() {
+        super(...arguments);
+        this.name = "InvalidDaemonRequestError";
+    }
+}
 export function extractRequestContext(raw) {
     if (!isPlainRecord(raw) || raw["method"] !== "tools/call")
         return { input: raw, context: undefined };
     const params = raw["params"];
     if (!isPlainRecord(params))
-        return { input: raw, context: undefined };
+        throw new InvalidDaemonRequestError("Daemon tools/call params must be an object.");
     const args = params["arguments"];
     if (!isPlainRecord(args))
-        return { input: raw, context: undefined };
+        throw new InvalidDaemonRequestError("Daemon tools/call arguments must be an object.");
+    if (!Object.hasOwn(args, CONTEXT_KEY)) {
+        throw new InvalidDaemonRequestError("Daemon tools/call arguments must include _context.");
+    }
     const context = parseContext(args[CONTEXT_KEY]);
-    if (!context)
-        return { input: raw, context: undefined };
     const cleanedArgs = { ...args };
     delete cleanedArgs[CONTEXT_KEY];
     const cleaned = { ...raw, params: { ...params, arguments: cleanedArgs } };
     return { input: cleaned, context };
 }
-export function handleDaemonMessage(raw) {
-    const { input, context } = extractRequestContext(raw);
-    if (context)
-        return runWithRequestContext(context, () => handleLspMcpRequest(input));
-    return handleLspMcpRequest(input);
+export function handleDaemonMessage(raw, state) {
+    const authenticated = authenticateMessage(raw, state.token);
+    if ("error" in authenticated)
+        return Promise.resolve(authenticated);
+    if (authenticated.method === "omo/ping") {
+        return Promise.resolve({
+            jsonrpc: "2.0",
+            id: authenticated.id,
+            result: { protocolVersion: OMO_DAEMON_PROTOCOL_VERSION, ...state.owner },
+        });
+    }
+    if (authenticated.method === "$/cancelRequest") {
+        const targetId = cancellationTargetId(authenticated.input);
+        if (targetId !== undefined)
+            state.activeRequests?.get(String(targetId))?.abort();
+        return Promise.resolve(undefined);
+    }
+    let routed;
+    try {
+        routed = extractRequestContext(authenticated.input);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "invalid daemon request";
+        return Promise.resolve({
+            jsonrpc: "2.0",
+            id: authenticated.id,
+            error: { code: -32602, message, data: { code: "invalid_daemon_request" } },
+        });
+    }
+    const { input, context } = routed;
+    const key = routeRequestKey(authenticated.id);
+    if (key === undefined || !state.activeRequests) {
+        if (context)
+            return runWithRequestContext(context, () => handleLspMcpRequest(input));
+        return handleLspMcpRequest(input);
+    }
+    const controller = new AbortController();
+    state.activeRequests.set(key, controller);
+    const options = { signal: controller.signal };
+    const run = context
+        ? runWithRequestContext(context, () => handleLspMcpRequest(input, options))
+        : handleLspMcpRequest(input, options);
+    return run.finally(() => {
+        if (state.activeRequests?.get(key) === controller)
+            state.activeRequests.delete(key);
+    });
 }
-function parseContext(value) {
-    if (!isPlainRecord(value))
+function routeRequestKey(id) {
+    return typeof id === "string" || typeof id === "number" ? String(id) : undefined;
+}
+function cancellationTargetId(input) {
+    const params = input["params"];
+    if (!isPlainRecord(params))
         return undefined;
-    const context = {};
-    const cwd = value["cwd"];
-    if (typeof cwd === "string")
-        context.cwd = cwd;
-    const env = value["env"];
-    if (isStringRecord(env))
-        context.env = env;
-    return context.cwd === undefined && context.env === undefined ? undefined : context;
+    const id = params["id"];
+    return typeof id === "string" || typeof id === "number" ? id : undefined;
 }
-function isStringRecord(value) {
-    return isPlainRecord(value) && Object.values(value).every((item) => typeof item === "string");
+function parseContext(value) {
+    if (!isPlainRecord(value))
+        throw new InvalidDaemonRequestError("LSP request _context must be an object.");
+    return parseLspRequestContext(value);
 }

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

@@ -1,9 +1,16 @@
-import { startDaemonServer } from "./daemon-server.js";
+import { DaemonAlreadyRunningError, startDaemonServer } from "./daemon-server.js";
 import { daemonPaths } from "./paths.js";
 export async function runDaemon() {
     process.on("uncaughtException", (error) => logNonFatal("uncaughtException", error));
     process.on("unhandledRejection", (reason) => logNonFatal("unhandledRejection", reason));
-    await startDaemonServer(daemonPaths());
+    try {
+        await startDaemonServer(daemonPaths());
+    }
+    catch (error) {
+        if (error instanceof DaemonAlreadyRunningError)
+            return;
+        throw error;
+    }
 }
 function logNonFatal(kind, error) {
     const message = error instanceof Error ? (error.stack ?? error.message) : String(error);

package/packages/lsp-daemon/dist/runtime-contract.d.ts

@@ -0,0 +1,21 @@
+export declare const OMO_LSP_DAEMON_DIR = "OMO_LSP_DAEMON_DIR";
+export declare const OMO_LSP_DAEMON_CLI = "OMO_LSP_DAEMON_CLI";
+export declare const OMO_LSP_DAEMON_VERSION = "OMO_LSP_DAEMON_VERSION";
+export interface DaemonRuntime {
+    readonly cliPath: string;
+    readonly version: string;
+}
+export type DaemonRuntimeDefaults = DaemonRuntime;
+export type InvalidRuntimeOverrideReason = "paired_values_required" | "cli_must_be_absolute" | "cli_not_found" | "cli_not_file" | "packaged_cli_must_be_absolute";
+export declare class InvalidRuntimeOverrideError extends Error {
+    readonly code = "invalid_runtime_override";
+    readonly reason: InvalidRuntimeOverrideReason;
+    constructor(reason: InvalidRuntimeOverrideReason, message: string);
+}
+export declare class InvalidDaemonVersionError extends Error {
+    readonly code = "invalid_daemon_version";
+    readonly version: string;
+    constructor(version: string);
+}
+export declare function validateDaemonVersion(version: string): string;
+export declare function resolveDaemonRuntime(env: NodeJS.ProcessEnv, defaults: DaemonRuntimeDefaults): DaemonRuntime;

package/packages/lsp-daemon/dist/runtime-contract.js

@@ -0,0 +1,58 @@
+import { statSync } from "node:fs";
+import { isAbsolute } from "node:path";
+export const OMO_LSP_DAEMON_DIR = "OMO_LSP_DAEMON_DIR";
+export const OMO_LSP_DAEMON_CLI = "OMO_LSP_DAEMON_CLI";
+export const OMO_LSP_DAEMON_VERSION = "OMO_LSP_DAEMON_VERSION";
+const DAEMON_VERSION_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._+-]{0,127}$/;
+export class InvalidRuntimeOverrideError extends Error {
+    constructor(reason, message) {
+        super(message);
+        this.code = "invalid_runtime_override";
+        this.name = "InvalidRuntimeOverrideError";
+        this.reason = reason;
+    }
+}
+export class InvalidDaemonVersionError extends Error {
+    constructor(version) {
+        super("LSP daemon version must match [A-Za-z0-9][A-Za-z0-9._+-]{0,127}");
+        this.code = "invalid_daemon_version";
+        this.name = "InvalidDaemonVersionError";
+        this.version = version;
+    }
+}
+export function validateDaemonVersion(version) {
+    if (!DAEMON_VERSION_PATTERN.test(version))
+        throw new InvalidDaemonVersionError(version);
+    return version;
+}
+export function resolveDaemonRuntime(env, defaults) {
+    const cliOverride = env[OMO_LSP_DAEMON_CLI];
+    const versionOverride = env[OMO_LSP_DAEMON_VERSION];
+    const hasCliOverride = cliOverride !== undefined;
+    const hasVersionOverride = versionOverride !== undefined;
+    if (hasCliOverride !== hasVersionOverride) {
+        throw new InvalidRuntimeOverrideError("paired_values_required", `${OMO_LSP_DAEMON_CLI} and ${OMO_LSP_DAEMON_VERSION} must be set together`);
+    }
+    if (!hasCliOverride || !hasVersionOverride) {
+        if (!isAbsolute(defaults.cliPath)) {
+            throw new InvalidRuntimeOverrideError("packaged_cli_must_be_absolute", "Packaged LSP daemon CLI path must be absolute");
+        }
+        return { cliPath: defaults.cliPath, version: validateDaemonVersion(defaults.version) };
+    }
+    if (!isAbsolute(cliOverride)) {
+        throw new InvalidRuntimeOverrideError("cli_must_be_absolute", `${OMO_LSP_DAEMON_CLI} must be an absolute path to an existing regular file`);
+    }
+    let cliStats;
+    try {
+        cliStats = statSync(cliOverride);
+    }
+    catch (error) {
+        if (!(error instanceof Error))
+            throw error;
+        throw new InvalidRuntimeOverrideError("cli_not_found", `${OMO_LSP_DAEMON_CLI} must name an existing regular file`);
+    }
+    if (!cliStats.isFile()) {
+        throw new InvalidRuntimeOverrideError("cli_not_file", `${OMO_LSP_DAEMON_CLI} must name an existing regular file`);
+    }
+    return { cliPath: cliOverride, version: validateDaemonVersion(versionOverride) };
+}

package/packages/lsp-daemon/dist/socket-jsonrpc.js

@@ -15,7 +15,12 @@ export function createLineDecoder(onMessage, onParseError) {
                         onMessage(JSON.parse(raw));
                     }
                     catch (error) {
-                        onParseError?.(raw, error);
+                        if (error instanceof Error) {
+                            onParseError?.(raw, error);
+                        }
+                        else {
+                            throw error;
+                        }
                     }
                 }
                 index = buffer.indexOf("\n");

package/packages/lsp-daemon/package.json

@@ -5,8 +5,16 @@
 	"type": "module",
 	"packageManager": "npm@11.16.0",
 	"license": "MIT",
-	"main": "./dist/index.js",
-	"types": "./dist/index.d.ts",
+	"exports": {
+		"./client": {
+			"types": "./dist/client.d.ts",
+			"default": "./dist/client.js"
+		},
+		"./cli": {
+			"types": "./dist/cli.d.ts",
+			"default": "./dist/cli.js"
+		}
+	},
 	"bin": {
 		"omo-lsp-daemon": "./dist/cli.js"
 	},
@@ -17,7 +25,8 @@
 		"README.md"
 	],
 	"scripts": {
-		"build": "tsc -p tsconfig.build.json && bun build src/cli.ts src/index.ts --outdir dist --target node --format esm && node scripts/stamp-dist-version.mjs",
+		"build": "node scripts/clean-dist.mjs && tsc -p tsconfig.build.json && bun build src/cli.ts src/index.ts src/client.ts --outdir dist --target node --format esm && node scripts/stamp-dist-version.mjs",
+		"smoke:client-package": "node scripts/client-package-smoke.mjs",
 		"test": "vitest --run",
 		"test:watch": "vitest",
 		"typecheck": "tsc --noEmit",