oh-my-opencode 4.19.0 → 4.19.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-opencode",
-  "version": "4.19.0",
+  "version": "4.19.2",
   "description": "The Best AI Agent Harness - Batteries-Included OpenCode Plugin with Multi-Model Orchestration, Parallel Background Agents, and Crafted LSP/AST Tools",
   "main": "./dist/index.js",
   "types": "dist/index.d.ts",
@@ -209,21 +209,21 @@
     "bun-types": "1.3.14",
     "node-pty": "^1.1.0",
     "puppeteer-core": "^25.3.0",
-    "typescript": "^6.0.3"
+    "typescript": "^7.0.2"
   },
   "optionalDependencies": {
-    "oh-my-opencode-darwin-arm64": "4.19.0",
-    "oh-my-opencode-darwin-x64": "4.19.0",
-    "oh-my-opencode-darwin-x64-baseline": "4.19.0",
-    "oh-my-opencode-linux-arm64": "4.19.0",
-    "oh-my-opencode-linux-arm64-musl": "4.19.0",
-    "oh-my-opencode-linux-x64": "4.19.0",
-    "oh-my-opencode-linux-x64-baseline": "4.19.0",
-    "oh-my-opencode-linux-x64-musl": "4.19.0",
-    "oh-my-opencode-linux-x64-musl-baseline": "4.19.0",
-    "oh-my-opencode-windows-arm64": "4.19.0",
-    "oh-my-opencode-windows-x64": "4.19.0",
-    "oh-my-opencode-windows-x64-baseline": "4.19.0"
+    "oh-my-opencode-darwin-arm64": "4.19.2",
+    "oh-my-opencode-darwin-x64": "4.19.2",
+    "oh-my-opencode-darwin-x64-baseline": "4.19.2",
+    "oh-my-opencode-linux-arm64": "4.19.2",
+    "oh-my-opencode-linux-arm64-musl": "4.19.2",
+    "oh-my-opencode-linux-x64": "4.19.2",
+    "oh-my-opencode-linux-x64-baseline": "4.19.2",
+    "oh-my-opencode-linux-x64-musl": "4.19.2",
+    "oh-my-opencode-linux-x64-musl-baseline": "4.19.2",
+    "oh-my-opencode-windows-arm64": "4.19.2",
+    "oh-my-opencode-windows-x64": "4.19.2",
+    "oh-my-opencode-windows-x64-baseline": "4.19.2"
   },
   "overrides": {
     "@earendil-works/pi-agent-core": "0.80.3",

package/packages/git-bash-mcp/dist/cli.js

@@ -163,16 +163,35 @@ function bufferFromChunk(chunk) {
 
 // ../mcp-stdio-core/src/server.ts
 var DEFAULT_IDLE_TIMEOUT_MS = 10 * 60000;
+var DEFAULT_PARENT_POLL_INTERVAL_MS = 30000;
 var noopLog = () => {};
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return !hasErrorCode(error, "ESRCH");
+  }
+}
 async function runJsonRpcStdioServer(config) {
   const log = config.log ?? noopLog;
   const idleTimeoutMs = config.idleTimeoutMs ?? DEFAULT_IDLE_TIMEOUT_MS;
-  const idleTimer = createIdleTimer(idleTimeoutMs, log, config.onIdleTimeout);
+  let isClosed = false;
+  const idleTimer = createIdleTimer(idleTimeoutMs, log, () => {
+    isClosed = true;
+    config.onIdleTimeout?.();
+  });
+  const watchdog = createParentWatchdog(config.parentWatchdog, (parentPid, pollIntervalMs) => {
+    isClosed = true;
+    log("parent_exit", { parent_pid: parentPid, poll_interval_ms: pollIntervalMs });
+    config.onParentExit?.();
+    config.input.destroy();
+  });
   log("stdio_started", { cwd: process.cwd(), idle_timeout_ms: idleTimeoutMs });
   idleTimer.arm();
   try {
     for await (const message of readStdioJsonRpcMessages(config.input)) {
-      if (idleTimer.closed())
+      if (isClosed)
         break;
       idleTimer.arm();
       if (message.kind === "parse_error") {
@@ -183,8 +202,12 @@ async function runJsonRpcStdioServer(config) {
       if (!await handleRequest(message, config, log))
         break;
     }
+  } catch (error) {
+    if (!(isClosed && hasErrorCode(error, "ERR_STREAM_PREMATURE_CLOSE")))
+      throw error;
   } finally {
     idleTimer.clear();
+    watchdog.clear();
     log("stdio_stopped");
   }
 }
@@ -240,9 +263,33 @@ function isTerminalOutputError(error) {
     return false;
   return error.code === "EPIPE" || error.code === "ERR_STREAM_DESTROYED" || error.code === "ERR_STREAM_WRITE_AFTER_END";
 }
-function createIdleTimer(idleTimeoutMs, log, onIdleTimeout) {
+function hasErrorCode(error, code) {
+  return error instanceof Error && "code" in error && error.code === code;
+}
+function createParentWatchdog(config, onDeadParent) {
+  if (config === undefined)
+    return { clear: () => {} };
+  const pollIntervalMs = config.pollIntervalMs ?? DEFAULT_PARENT_POLL_INTERVAL_MS;
+  if (pollIntervalMs <= 0)
+    return { clear: () => {} };
+  const parentPid = config.parentPid ?? process.ppid;
+  const probeAlive = config.probeAlive ?? isProcessAlive;
+  let fired = false;
+  const timer = setInterval(() => {
+    if (fired || probeAlive(parentPid))
+      return;
+    fired = true;
+    onDeadParent(parentPid, pollIntervalMs);
+  }, pollIntervalMs);
+  timer.unref();
+  return {
+    clear: () => {
+      clearInterval(timer);
+    }
+  };
+}
+function createIdleTimer(idleTimeoutMs, log, onTimeout) {
   let timer = null;
-  let isClosed = false;
   return {
     arm: () => {
       if (timer !== null)
@@ -250,9 +297,8 @@ function createIdleTimer(idleTimeoutMs, log, onIdleTimeout) {
       if (idleTimeoutMs <= 0)
         return;
       timer = setTimeout(() => {
-        isClosed = true;
         log("idle_timeout", { idle_timeout_ms: idleTimeoutMs });
-        onIdleTimeout?.();
+        onTimeout();
       }, idleTimeoutMs);
       timer.unref();
     },
@@ -261,8 +307,7 @@ function createIdleTimer(idleTimeoutMs, log, onIdleTimeout) {
         return;
       clearTimeout(timer);
       timer = null;
-    },
-    closed: () => isClosed
+    }
   };
 }
 // ../utils/src/runtime/git-bash.ts
@@ -444,6 +489,7 @@ async function runMcpStdioServer(input, output, options = {}) {
     handler: handleGitBashMcpRequest,
     handlerOptions: options,
     idleTimeoutMs: 0,
+    parentWatchdog: options.parentWatchdog ?? {},
     log: options.lifecycleLog,
     parseErrorResponse: () => errorResponse(null, -32601, "Method not found")
   });

package/packages/lsp-core/src/lsp/client-diagnostics-freshness.integration.test.ts

@@ -107,7 +107,7 @@ describe("LspClient diagnostics freshness", () => {
 					},
 				],
 			},
-			{ diagnosticsFreshnessTimeoutMs: 30, versionlessPublishQuiescenceMs: 5 },
+			{ diagnosticsFreshnessTimeoutMs: 100, versionlessPublishQuiescenceMs: 5 },
 		);
 		await stale.client.openFile(stale.source);
 		writeFileSync(stale.source, "const stale = 1;\n", "utf-8");
@@ -130,7 +130,7 @@ describe("LspClient diagnostics freshness", () => {
 					},
 				],
 			},
-			{ diagnosticsFreshnessTimeoutMs: 30, versionlessPublishQuiescenceMs: 5 },
+			{ diagnosticsFreshnessTimeoutMs: 100, versionlessPublishQuiescenceMs: 5 },
 		);
 		await future.client.openFile(future.source);
 		writeFileSync(future.source, "const future = 1;\n", "utf-8");
@@ -258,4 +258,64 @@ describe("LspClient diagnostics freshness", () => {
 		expect(result.transientError?.kind).toBe("freshness_timeout");
 		expect(cancel?.params).toEqual({ id: request?.id });
 	});
+
+	it("#given a server without pull support that never publishes diagnostics #when diagnostics run on a clean file #then the request resolves clean after the freshness window instead of reporting a timeout", async () => {
+		const context = await harness.makeClient(
+			{},
+			{ diagnosticsFreshnessTimeoutMs: 60, versionlessPublishQuiescenceMs: 5 },
+		);
+
+		const startedAt = Date.now();
+		const result = await context.client.diagnostics(context.source);
+		const elapsedMs = Date.now() - startedAt;
+
+		expect(result.transientError).toBeUndefined();
+		expect(result.items).toEqual([]);
+		// The full freshness window is still honored so a slow publisher can win.
+		expect(elapsedMs).toBeGreaterThanOrEqual(45);
+	});
+
+	it("#given a pull-supported server that cached diagnostics for an older document version #when the file changes and a later pull is rejected as unsupported without any publish #then the fallback resolves empty instead of returning the stale cached diagnostics", async () => {
+		const context = await harness.makeClient(
+			{
+				capabilities: { diagnosticProvider: { interFileDependencies: false, workspaceDiagnostics: false } },
+				diagnosticResponses: [
+					{ report: { kind: "full", resultId: "v1", items: [diagnostic("stale-pull")] } },
+					{ error: { code: -32601, message: "Method not found" } },
+				],
+			},
+			{ diagnosticsFreshnessTimeoutMs: 60, versionlessPublishQuiescenceMs: 5 },
+		);
+
+		const first = await context.client.diagnostics(context.source);
+		expect(first.items).toEqual([diagnostic("stale-pull")]);
+
+		writeFileSync(context.source, "const changed = 1;\n");
+		await context.client.openFile(context.source);
+
+		const second = await context.client.diagnostics(context.source);
+		expect(second.transientError).toBeUndefined();
+		expect(second.items).toEqual([]);
+	});
+
+	it("#given a pull-supported server with a current cached pull report #when a later pull is rejected as unsupported without any publish and the document is unchanged #then the fallback resolves with the current cached diagnostics", async () => {
+		const context = await harness.makeClient(
+			{
+				capabilities: { diagnosticProvider: { interFileDependencies: false, workspaceDiagnostics: false } },
+				diagnosticResponses: [
+					{ report: { kind: "full", resultId: "v1", items: [diagnostic("cached-full")] } },
+					{ error: { code: -32601, message: "Method not found" } },
+				],
+			},
+			{ diagnosticsFreshnessTimeoutMs: 60, versionlessPublishQuiescenceMs: 5 },
+		);
+
+		const first = await context.client.diagnostics(context.source);
+		expect(first.items).toEqual([diagnostic("cached-full")]);
+
+		const second = await context.client.diagnostics(context.source);
+		expect(second.transientError).toBeUndefined();
+		expect(second.items).toEqual([diagnostic("cached-full")]);
+	});
+
 });

package/packages/lsp-core/src/lsp/client.ts

@@ -237,7 +237,20 @@ export class LspClient extends LspClientConnection {
 			if (!pushFallbackOnly) continue;
 
 			const remainingMs = deadlineAt - Date.now();
-			if (remainingMs <= 0) return this.freshnessTimeout(absPath);
+			if (remainingMs <= 0) {
+				// A server that never advertised pull diagnostics (or rejected the pull
+				// method) and has never published for this document stays silent for a
+				// clean file (e.g. Marksman, #6131). Resolve with the version-current
+				// pull cache or explicit empty instead of a freshness timeout; a stale
+				// pull cache from an older document version is never returned. Servers
+				// that have published before keep timing out via publishGeneration > 0,
+				// and a hung advertised pull keeps timing out because pull stays supported.
+				if (!this.isDiagnosticPullSupported() && snapshot.publishGeneration === 0) {
+					const cached = this.documents.getPullCache(snapshot);
+					return { items: cached === null ? [] : [...cached.diagnostics] };
+				}
+				return this.freshnessTimeout(absPath);
+			}
 			const waitMs = push.status === "wait" ? Math.min(push.waitMs, remainingMs) : remainingMs;
 			await waitForDiagnosticsActivity(this.documents.waitForDiagnosticsActivity(snapshot, waitMs), signal);
 		}

package/packages/lsp-core/src/lsp/fixtures/diagnostics-freshness-contract-probe.ts

@@ -182,9 +182,9 @@ try {
 		outcome: "silent",
 		items: silentResult.items.map((entry) => entry.message),
 		transientError: silentResult.transientError ?? null,
-		ok: silentResult.items.length === 0 && silentResult.transientError?.kind === "freshness_timeout",
+		ok: silentResult.items.length === 0 && silentResult.transientError === undefined,
 	};
-	requireProbe(silentEvidence.ok, "silent diagnostics were labeled clean instead of timing out transiently");
+	requireProbe(silentEvidence.ok, "silent no-pull server that never published did not resolve clean after the freshness window");
 
 	const closedServer = await harness.makeClient(
 		{

package/packages/lsp-core/src/mcp.ts

@@ -10,6 +10,7 @@ import {
 	type JsonRpcResponse,
 	type JsonRpcResult,
 	type McpToolDescriptor,
+	type ParentWatchdogConfig,
 } from "@oh-my-opencode/mcp-stdio-core";
 import { coerceToolArguments, executeLspTool, LSP_MCP_TOOLS } from "./tools.js";
 import { createStandaloneMcpRequestContext, runWithRequestContext } from "./request-context.js";
@@ -23,6 +24,12 @@ export interface HandleLspMcpRequestOptions {
 	readonly signal?: AbortSignal;
 }
 
+export interface LspMcpStdioServerOptions {
+	// Test seam: production callers leave this unset so the watchdog uses its
+	// defaults (parentPid = process.ppid, 30s poll).
+	readonly parentWatchdog?: ParentWatchdogConfig;
+}
+
 export async function handleLspMcpRequest(
 	input: unknown,
 	options: HandleLspMcpRequestOptions = {},
@@ -58,12 +65,14 @@ export async function handleLspMcpRequest(
 export async function runMcpStdioServer(
 	input: Readable = process.stdin,
 	output: Writable = process.stdout,
+	options: LspMcpStdioServerOptions = {},
 ): Promise<void> {
 	const requestContext = createStandaloneMcpRequestContext();
 	await runJsonRpcStdioServer({
 		input,
 		output,
 		idleTimeoutMs: 0,
+		parentWatchdog: options.parentWatchdog ?? {},
 		handler: (request) => runWithRequestContext(requestContext, () => handleLspMcpRequest(request)),
 		handlerOptions: undefined,
 	});