oh-my-opencode 4.5.1 → 4.6.0

package/packages/ast-grep-mcp/dist/cli.js

@@ -3,8 +3,38 @@
 // src/cli.ts
 import { argv, stderr } from "node:process";
 
-// src/mcp.ts
-import { createInterface } from "node:readline";
+// src/mcp-lifecycle-log.ts
+import { appendFileSync, renameSync, statSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+var LOG_FILE_NAME = "omo-ast-grep-mcp.log";
+var MAX_LOG_BYTES = 5 * 1024 * 1024;
+function mcpLifecycleLogPath() {
+  return join(tmpdir(), LOG_FILE_NAME);
+}
+function writeMcpLifecycleLog(event, fields = {}) {
+  const path = mcpLifecycleLogPath();
+  try {
+    rotateLogIfNeeded(path);
+    appendFileSync(path, `${JSON.stringify({ ts: new Date().toISOString(), event, pid: process.pid, ppid: process.ppid, ...fields })}
+`);
+  } catch (error) {
+    if (error instanceof Error)
+      return;
+    return;
+  }
+}
+function rotateLogIfNeeded(path) {
+  try {
+    if (statSync(path).size < MAX_LOG_BYTES)
+      return;
+    renameSync(path, `${path}.1`);
+  } catch (error) {
+    if (error instanceof Error)
+      return;
+    return;
+  }
+}
 
 // ../ast-grep-core/src/language-support.ts
 var CLI_LANGUAGES = [
@@ -310,11 +340,11 @@ function errorMessage(error) {
 }
 // src/sg-cli-path.ts
 import { createRequire } from "module";
-import { dirname, join } from "path";
-import { existsSync, statSync } from "fs";
+import { dirname, join as join2 } from "path";
+import { existsSync, statSync as statSync2 } from "fs";
 function isValidBinary(filePath) {
   try {
-    return statSync(filePath).size > 1e4;
+    return statSync2(filePath).size > 1e4;
   } catch {
     return false;
   }
@@ -339,7 +369,7 @@ function findSgCliPathSync() {
     const require2 = createRequire(import.meta.url);
     const cliPackageJsonPath = require2.resolve("@ast-grep/cli/package.json");
     const cliDirectory = dirname(cliPackageJsonPath);
-    const sgPath = join(cliDirectory, binaryName);
+    const sgPath = join2(cliDirectory, binaryName);
     if (existsSync(sgPath) && isValidBinary(sgPath)) {
       return sgPath;
     }
@@ -351,7 +381,7 @@ function findSgCliPathSync() {
       const packageJsonPath = require2.resolve(`${platformPackage}/package.json`);
       const packageDirectory = dirname(packageJsonPath);
       const astGrepBinaryName = process.platform === "win32" ? "ast-grep.exe" : "ast-grep";
-      const binaryPath = join(packageDirectory, astGrepBinaryName);
+      const binaryPath = join2(packageDirectory, astGrepBinaryName);
       if (existsSync(binaryPath) && isValidBinary(binaryPath)) {
         return binaryPath;
       }
@@ -382,6 +412,192 @@ function getSgCliPath() {
 function setSgCliPath(path) {
   resolvedCliPath = path;
 }
+// src/mcp-stdio-transport.ts
+var HEADER_SEPARATOR = Buffer.from(`\r
+\r
+`);
+async function* readStdioJsonRpcMessages(input) {
+  let buffer = Buffer.alloc(0);
+  for await (const chunk of input) {
+    buffer = Buffer.concat([buffer, bufferFromChunk(chunk)]);
+    while (true) {
+      const result = readNextMessage(buffer);
+      if (result.kind === "incomplete")
+        break;
+      buffer = result.remaining;
+      if (result.message)
+        yield result.message;
+    }
+  }
+  const trailing = buffer.toString("utf8").trim();
+  if (trailing.length > 0) {
+    yield parseJsonPayload(trailing, "line");
+  }
+}
+function writeStdioJsonRpcResponse(output, response, responseMode) {
+  const body = JSON.stringify(response);
+  if (responseMode === "framed") {
+    output.write(`Content-Length: ${Buffer.byteLength(body, "utf8")}\r
+\r
+${body}`);
+    return;
+  }
+  output.write(`${body}
+`);
+}
+function readNextMessage(buffer) {
+  if (buffer.length === 0)
+    return { kind: "incomplete" };
+  return startsWithContentLength(buffer) ? readFramedMessage(buffer) : readLineMessage(buffer);
+}
+function readLineMessage(buffer) {
+  const newlineIndex = buffer.indexOf(10);
+  if (newlineIndex === -1)
+    return { kind: "incomplete" };
+  const line = buffer.subarray(0, newlineIndex).toString("utf8").replace(/\r$/, "");
+  if (line.trim().length === 0) {
+    return {
+      kind: "complete",
+      remaining: buffer.subarray(newlineIndex + 1)
+    };
+  }
+  return {
+    kind: "complete",
+    message: parseJsonPayload(line, "line"),
+    remaining: buffer.subarray(newlineIndex + 1)
+  };
+}
+function readFramedMessage(buffer) {
+  const separatorIndex = buffer.indexOf(HEADER_SEPARATOR);
+  if (separatorIndex === -1)
+    return { kind: "incomplete" };
+  const headers = buffer.subarray(0, separatorIndex).toString("ascii");
+  const contentLength = parseContentLength(headers);
+  const bodyStart = separatorIndex + HEADER_SEPARATOR.length;
+  if (contentLength === undefined) {
+    return {
+      kind: "complete",
+      message: {
+        kind: "parse_error",
+        message: "Missing or invalid Content-Length header",
+        responseMode: "framed"
+      },
+      remaining: buffer.subarray(bodyStart)
+    };
+  }
+  const bodyEnd = bodyStart + contentLength;
+  if (buffer.length < bodyEnd)
+    return { kind: "incomplete" };
+  const body = buffer.subarray(bodyStart, bodyEnd).toString("utf8");
+  return {
+    kind: "complete",
+    message: parseJsonPayload(body, "framed"),
+    remaining: buffer.subarray(bodyEnd)
+  };
+}
+function startsWithContentLength(buffer) {
+  const prefix = buffer.subarray(0, "content-length:".length).toString("ascii").toLowerCase();
+  return prefix === "content-length:";
+}
+function parseContentLength(headers) {
+  for (const line of headers.split(`\r
+`)) {
+    const match = /^content-length:\s*(\d+)$/i.exec(line);
+    if (match === null)
+      continue;
+    const value = match[1];
+    if (value === undefined)
+      return;
+    return Number(value);
+  }
+  return;
+}
+function parseJsonPayload(payload, responseMode) {
+  try {
+    return { kind: "request", payload: JSON.parse(payload), responseMode };
+  } catch (error) {
+    return { kind: "parse_error", message: messageFromError(error), responseMode };
+  }
+}
+function bufferFromChunk(chunk) {
+  if (Buffer.isBuffer(chunk))
+    return chunk;
+  if (typeof chunk === "string")
+    return Buffer.from(chunk);
+  throw new TypeError(`Unsupported stdio chunk type: ${typeof chunk}`);
+}
+function messageFromError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/mcp-stdio-server.ts
+var DEFAULT_IDLE_TIMEOUT_MS = 10 * 60000;
+var noopLog = () => {};
+async function runJsonRpcStdioServer(handler, input, output, options, stdioOptions = {}) {
+  const log = stdioOptions.log ?? noopLog;
+  const idleTimeoutMs = stdioOptions.idleTimeoutMs ?? DEFAULT_IDLE_TIMEOUT_MS;
+  const idleTimer = createIdleTimer(idleTimeoutMs, log, stdioOptions.onIdleTimeout);
+  log("stdio_started", { cwd: process.cwd(), idle_timeout_ms: idleTimeoutMs });
+  idleTimer.arm();
+  try {
+    for await (const message of readStdioJsonRpcMessages(input)) {
+      if (idleTimer.closed())
+        break;
+      idleTimer.arm();
+      if (message.kind === "parse_error") {
+        log("parse_error", { message: message.message });
+        writeStdioJsonRpcResponse(output, errorResponse(null, -32700, "Parse error", message.message), message.responseMode);
+        continue;
+      }
+      const parsed = message.payload;
+      const id = isRecord(parsed) ? jsonRpcId(parsed.id) : null;
+      const method = isRecord(parsed) && typeof parsed.method === "string" ? parsed.method : null;
+      log("request", { id: id === null ? null : String(id), method });
+      const response = await handler(parsed, options);
+      if (response) {
+        writeStdioJsonRpcResponse(output, response, message.responseMode);
+        log("response", { id: String(response.id), method, is_error: response.error !== undefined });
+      }
+    }
+  } finally {
+    idleTimer.clear();
+    log("stdio_stopped");
+  }
+}
+function createIdleTimer(idleTimeoutMs, log, onIdleTimeout) {
+  let timer = null;
+  let isClosed = false;
+  return {
+    arm: () => {
+      if (timer !== null)
+        clearTimeout(timer);
+      if (idleTimeoutMs <= 0)
+        return;
+      timer = setTimeout(() => {
+        isClosed = true;
+        log("idle_timeout", { idle_timeout_ms: idleTimeoutMs });
+        onIdleTimeout?.();
+      }, idleTimeoutMs);
+      timer.unref();
+    },
+    clear: () => {
+      if (timer === null)
+        return;
+      clearTimeout(timer);
+      timer = null;
+    },
+    closed: () => isClosed
+  };
+}
+function errorResponse(id, code, message, data) {
+  return { jsonrpc: "2.0", id, error: data === undefined ? { code, message } : { code, message, data } };
+}
+function jsonRpcId(value) {
+  return typeof value === "string" || typeof value === "number" || value === null ? value : null;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 // src/runner.ts
 import { existsSync as existsSync3 } from "node:fs";
 
@@ -692,9 +908,9 @@ var AST_GREP_MCP_TOOLS = [
   }
 ];
 async function handleAstGrepMcpRequest(input, options = {}) {
-  if (!isRecord(input))
-    return errorResponse(null, -32600, "Invalid Request");
-  const id = jsonRpcId(input.id);
+  if (!isRecord2(input))
+    return errorResponse2(null, -32600, "Invalid Request");
+  const id = jsonRpcId2(input.id);
   if (input.method === "notifications/initialized")
     return;
   if (input.method === "ping")
@@ -710,35 +926,19 @@ async function handleAstGrepMcpRequest(input, options = {}) {
     return successResponse(id, { tools: enabledTools(options) });
   if (input.method === "tools/call")
     return handleToolCall(id, input.params, options);
-  return errorResponse(id, -32601, `Method not found: ${String(input.method)}`);
+  return errorResponse2(id, -32601, `Method not found: ${String(input.method)}`);
 }
-async function runMcpStdioServer(input = process.stdin, output = process.stdout, options = {}) {
-  const lines = createInterface({ input, crlfDelay: Number.POSITIVE_INFINITY });
-  for await (const line of lines) {
-    if (!line.trim())
-      continue;
-    let parsed;
-    try {
-      parsed = JSON.parse(line);
-    } catch (error) {
-      output.write(`${JSON.stringify(errorResponse(null, -32700, "Parse error", messageFromError(error)))}
-`);
-      continue;
-    }
-    const response = await handleAstGrepMcpRequest(parsed, options);
-    if (response)
-      output.write(`${JSON.stringify(response)}
-`);
-  }
+async function runMcpStdioServer(input = process.stdin, output = process.stdout, options = {}, stdioOptions = {}) {
+  await runJsonRpcStdioServer(handleAstGrepMcpRequest, input, output, options, stdioOptions);
 }
 async function handleToolCall(id, params, options) {
-  if (!isRecord(params) || typeof params.name !== "string")
-    return errorResponse(id, -32602, "tools/call requires params.name");
+  if (!isRecord2(params) || typeof params.name !== "string")
+    return errorResponse2(id, -32602, "tools/call requires params.name");
   try {
     const result = await executeAstGrepTool(params.name, params.arguments, options);
     return successResponse(id, { content: result.content, isError: result.isError ?? false });
   } catch (error) {
-    return successResponse(id, { content: [{ type: "text", text: messageFromError(error) }], isError: true });
+    return successResponse(id, { content: [{ type: "text", text: messageFromError2(error) }], isError: true });
   }
 }
 async function executeAstGrepTool(name, args, options) {
@@ -794,7 +994,7 @@ function parseReplaceArgs(args, workspaceDirectory) {
   };
 }
 function requireRecord(value) {
-  if (!isRecord(value))
+  if (!isRecord2(value))
     throw new Error("Tool arguments must be an object");
   return value;
 }
@@ -849,21 +1049,21 @@ function optionalBoolean(input, key) {
 function successResponse(id, result) {
   return { jsonrpc: "2.0", id, result };
 }
-function errorResponse(id, code, message, data) {
+function errorResponse2(id, code, message, data) {
   return { jsonrpc: "2.0", id, error: data === undefined ? { code, message } : { code, message, data } };
 }
 function requestedProtocolVersion(params) {
-  if (!isRecord(params) || typeof params.protocolVersion !== "string")
+  if (!isRecord2(params) || typeof params.protocolVersion !== "string")
     return "2024-11-05";
   return params.protocolVersion;
 }
-function jsonRpcId(value) {
+function jsonRpcId2(value) {
   return typeof value === "string" || typeof value === "number" || value === null ? value : null;
 }
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function messageFromError(error) {
+function messageFromError2(error) {
   return error instanceof Error ? error.message : String(error);
 }
 
@@ -871,10 +1071,15 @@ function messageFromError(error) {
 async function main() {
   const [command = "mcp"] = argv.slice(2);
   if (command === "mcp") {
-    await runMcpStdioServer();
+    await runMcpStdioServer(process.stdin, process.stdout, {}, {
+      log: writeMcpLifecycleLog,
+      onIdleTimeout: () => {
+        process.exit(0);
+      }
+    });
     return;
   }
-  stderr.write(`Usage: ast-grep-mcp [mcp]
+  stderr.write(`Usage: omo-ast-grep [mcp]
 `);
   process.exitCode = 2;
 }