@evanovation/open-cursor 2.4.15

package/src/client/sdk-child.ts

@@ -0,0 +1,550 @@
+/**
+ * sdk-child.ts
+ *
+ * Spawns sdk-runner.mjs as a persistent singleton process.
+ * The runner reads NDJSON requests from stdin: {"id":"...","model":"...","cwd":"...","prompt":"..."}
+ * and emits wrapped NDJSON responses to stdout: {"id":"...","event":{...}} or {"id":"...","done":true,"exitCode":...}
+ *
+ * This module demultiplexes per-request by:
+ * 1. Maintaining a singleton runner process (lazy spawn on first use)
+ * 2. Generating a unique request id per create*Child call
+ * 3. Writing the request to runner stdin
+ * 4. Filtering runner stdout by id to re-emit per-request events
+ * 5. Closing the per-request stream when "done" is received
+ *
+ * Benefits:
+ * - Node process boot + SDK import cost paid once for all requests
+ * - Requests run concurrently inside the runner (OpenCode fires several at once)
+ * - Also exposes listModelsViaRunner() for model discovery (op: "listModels")
+ *
+ * Limitations:
+ * - kill() on a single child does not interrupt the in-flight SDK run
+ * - If a different apiKey arrives (rare), the runner is re-spawned with the new key
+ */
+
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { dirname, resolve } from "node:path";
+import { existsSync } from "node:fs";
+import { EventEmitter } from "node:events";
+import { PassThrough } from "node:stream";
+import { createLogger } from "../utils/logger.js";
+import { randomBytes } from "node:crypto";
+
+const log = createLogger("sdk-child");
+const textEncoder = new TextEncoder();
+
+const EVENT_KEY = '"event":';
+
+/**
+ * Extract the inner event JSON from a wrapper line like {"id":"...","event":{...}}
+ * without re-serializing the parsed object. Falls back to the full line if
+ * the format is unexpected.
+ */
+/** @internal Exported for testing only. */
+export function extractEventJson(line: string): string {
+  const idx = line.indexOf(EVENT_KEY);
+  if (idx < 0) return line;
+  const start = idx + EVENT_KEY.length;
+  const end = line.lastIndexOf("}");
+  if (end <= start) return line;
+  return line.substring(start, end);
+}
+
+// ─── Utilities ──────────────────────────────────────────────────────────────
+
+/**
+ * Resolve the Node binary path from PATH or environment override.
+ */
+function resolveNodeBinary(): string {
+  return process.env.CURSOR_ACP_NODE_BIN || "node";
+}
+
+/**
+ * Resolve the path to sdk-runner.mjs, handling both src/ (dev) and dist/ (built) contexts.
+ * Returns the absolute path or throws if not found.
+ */
+export function resolveRunnerPath(
+  currentFile: string = fileURLToPath(import.meta.url),
+  checkExists: (path: string) => boolean = existsSync,
+  env: Pick<NodeJS.ProcessEnv, "CURSOR_ACP_SDK_RUNNER_PATH"> = process.env,
+): string {
+  const override = env.CURSOR_ACP_SDK_RUNNER_PATH?.trim();
+  if (override) {
+    if (checkExists(override)) {
+      return override;
+    }
+    throw new Error(`CURSOR_ACP_SDK_RUNNER_PATH does not exist: ${override}`);
+  }
+
+  const currentDir = dirname(currentFile);
+
+  const candidates = [
+    // Source layout: src/client/sdk-child.ts -> scripts/sdk-runner.mjs.
+    // Non-bundled dist layout: dist/client/sdk-child.js -> scripts/sdk-runner.mjs.
+    resolve(currentDir, "../../scripts/sdk-runner.mjs"),
+    // Bundled package layout: dist/plugin-entry.js -> scripts/sdk-runner.mjs.
+    resolve(currentDir, "../scripts/sdk-runner.mjs"),
+  ];
+
+  for (const candidate of candidates) {
+    if (checkExists(candidate)) {
+      return candidate;
+    }
+  }
+
+  log.error("Could not resolve sdk-runner.mjs", {
+    currentFile,
+    candidates,
+  });
+
+  throw new Error(
+    `sdk-runner.mjs not found. Tried: ${candidates.join(", ")}`,
+  );
+}
+
+/**
+ * Generate a unique request id (hex string).
+ */
+function generateRequestId(): string {
+  return randomBytes(8).toString("hex");
+}
+
+// ─── Singleton Runner ──────────────────────────────────────────────────────
+
+interface PendingRequest {
+  controller: ReadableStreamDefaultController<Uint8Array>;
+  promiseResolver: (code: number) => void;
+  promiseRejector: (err: Error) => void;
+}
+
+/**
+ * Manages the persistent runner process and per-request demultiplexing.
+ */
+class SdkRunnerSingleton {
+  private runnerProcess: ReturnType<typeof spawn> | null = null;
+  private lastApiKey: string | null = null;
+  private pendingRequests = new Map<string, PendingRequest>();
+  private lineBuffer = "";
+  private starting: Promise<void> | null = null;
+
+  /**
+   * Ensure the runner is spawned (or re-spawn if apiKey changed).
+   * Concurrent callers share the same spawn (lock via this.starting) —
+   * OpenCode fires multiple requests at once (e.g. title-gen + chat).
+   */
+  async ensureRunning(apiKey: string): Promise<void> {
+    // If apiKey changed, kill the old process and respawn
+    if (this.lastApiKey && this.lastApiKey !== apiKey) {
+      log.info("API key changed, restarting runner");
+      this.kill();
+      this.starting = null;
+    }
+
+    if (this.runnerProcess) {
+      return; // already running
+    }
+    if (this.starting) {
+      return this.starting; // spawn already in progress
+    }
+
+    this.starting = this.doSpawn(apiKey);
+    try {
+      await this.starting;
+    } finally {
+      this.starting = null;
+    }
+  }
+
+  private async doSpawn(apiKey: string): Promise<void> {
+    const nodeBin = resolveNodeBinary();
+    const runnerPath = resolveRunnerPath();
+
+    log.info("spawning persistent sdk runner", {
+      runnerPath,
+      nodeBin,
+    });
+
+    this.lastApiKey = apiKey;
+
+    this.runnerProcess = spawn(nodeBin, [runnerPath], {
+      env: { ...process.env, CURSOR_API_KEY: apiKey },
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+
+    // Handle runner stdout (demultiplex by request id)
+    this.runnerProcess.stdout?.on("data", (chunk) => {
+      this.handleStdoutChunk(chunk);
+    });
+
+    // Forward stderr to our logger (diagnostics only)
+    this.runnerProcess.stderr?.on("data", (chunk) => {
+      const text = chunk.toString("utf8").trimEnd();
+      for (const line of text.split("\n")) {
+        if (line) {
+          log.debug(`[runner stderr] ${line}`);
+        }
+      }
+    });
+
+    // Handle runner exit
+    this.runnerProcess.on("close", (code) => {
+      log.error(`sdk runner exited with code ${code}`);
+      this.runnerProcess = null;
+      // Fail all pending requests
+      for (const [id, pending] of this.pendingRequests.entries()) {
+        pending.promiseRejector(new Error(`Runner exited with code ${code}`));
+        pending.controller.error(new Error(`Runner exited with code ${code}`));
+      }
+      this.pendingRequests.clear();
+    });
+
+    this.runnerProcess.on("error", (err) => {
+      log.error("sdk runner spawn error", { error: err.message });
+      this.runnerProcess = null;
+      // Fail all pending requests
+      for (const [id, pending] of this.pendingRequests.entries()) {
+        pending.promiseRejector(err);
+        pending.controller.error(err);
+      }
+      this.pendingRequests.clear();
+    });
+  }
+
+  /**
+   * Send a request to the runner.
+   */
+  sendRequest(requestId: string, model: string, cwd: string, prompt: string): void {
+    if (!this.runnerProcess || !this.runnerProcess.stdin) {
+      throw new Error("Runner process not ready");
+    }
+
+    const request = { id: requestId, model, cwd, prompt };
+    this.runnerProcess.stdin.write(JSON.stringify(request) + "\n");
+  }
+
+
+  /**
+   * Send a raw request to the runner (for operations like listModels).
+   * The request object is sent as-is; the caller is responsible for including id.
+   */
+  sendRawRequest(request: Record<string, any>): void {
+    if (!this.runnerProcess || !this.runnerProcess.stdin) {
+      throw new Error("Runner process not ready");
+    }
+    this.runnerProcess.stdin.write(JSON.stringify(request) + "\n");
+  }
+
+  /**
+   * Handle a chunk of stdout from the runner.
+   * Lines are wrapped: {"id":"...","event":{...}} or {"id":"...","done":true,"exitCode":...}
+   */
+  private handleStdoutChunk(chunk: Buffer | Uint8Array): void {
+    this.lineBuffer += chunk.toString("utf8");
+    const lines = this.lineBuffer.split("\n");
+    this.lineBuffer = lines.pop() ?? ""; // keep incomplete line
+
+    for (const line of lines) {
+      if (!line.trim()) continue;
+
+      try {
+        const wrapped = JSON.parse(line);
+        const requestId = wrapped.id;
+        if (!requestId) {
+          log.warn("Wrapped response missing id", { wrapped });
+          continue;
+        }
+
+        const pending = this.pendingRequests.get(requestId);
+        if (!pending) {
+          log.warn(`Received response for unknown request ${requestId}`, { wrapped });
+          continue;
+        }
+
+        if (wrapped.done) {
+          // Request complete
+          log.info(`Request ${requestId} complete with exitCode ${wrapped.exitCode}`);
+          pending.controller.close();
+          pending.promiseResolver(wrapped.exitCode ?? 0);
+          this.pendingRequests.delete(requestId);
+        } else if (wrapped.event) {
+          const eventJson = extractEventJson(line);
+          pending.controller.enqueue(textEncoder.encode(eventJson + "\n"));
+        }
+      } catch (err) {
+        log.error("Failed to parse wrapped response line", {
+          line,
+          error: err instanceof Error ? err.message : String(err),
+        });
+      }
+    }
+  }
+
+  /**
+   * Register a pending request and return the id.
+   */
+  registerPending(
+    controller: ReadableStreamDefaultController<Uint8Array>,
+    promiseResolver: (code: number) => void,
+    promiseRejector: (err: Error) => void,
+  ): string {
+    const id = generateRequestId();
+    this.pendingRequests.set(id, { controller, promiseResolver, promiseRejector });
+    return id;
+  }
+
+  /**
+   * Kill the runner process (hard kill).
+   */
+  kill(): void {
+    if (this.runnerProcess) {
+      try {
+        this.runnerProcess.kill("SIGKILL");
+      } catch {
+        // ignore
+      }
+      this.runnerProcess = null;
+    }
+  }
+}
+
+const singleton = new SdkRunnerSingleton();
+
+export function stopSdkRunner(): void {
+  singleton.kill();
+}
+
+// ─── BUN-compatible child ──────────────────────────────────────────────────
+
+export interface SdkBunChild {
+  stdout: ReadableStream<Uint8Array>;
+  stderr: ReadableStream<Uint8Array>;
+  exited: Promise<number>;
+  kill(): void;
+}
+
+/**
+ * Creates a Bun-spawn-compatible object using the persistent runner.
+ * Each call returns a fresh per-request pair of streams.
+ */
+export function createSdkBunChild(options: {
+  apiKey: string;
+  model: string;
+  prompt: string;
+  cwd: string;
+}): SdkBunChild {
+  log.info("creating sdk bun child", {
+    model: options.model,
+    cwd: options.cwd,
+  });
+
+  let requestId: string;
+  let resolveExited!: (code: number) => void;
+  let rejectExited!: (err: Error) => void;
+
+  const exited = new Promise<number>((resolve, reject) => {
+    resolveExited = resolve;
+    rejectExited = reject;
+  });
+
+  const stdout = new ReadableStream<Uint8Array>({
+    start: async (controller) => {
+      try {
+        // Ensure runner is alive with this apiKey
+        await singleton.ensureRunning(options.apiKey);
+
+        // Register this request
+        requestId = singleton.registerPending(controller, resolveExited, rejectExited);
+        log.info(`request ${requestId} registered (bun)`);
+
+        // Send the request to the runner
+        singleton.sendRequest(requestId, options.model, options.cwd, options.prompt);
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        log.error("Failed to start request (bun)", { error: error.message });
+        controller.error(error);
+        rejectExited(error);
+      }
+    },
+    cancel() {
+      // Best-effort: could stop forwarding events, but runner continues
+      // For now, just log it
+      log.debug(`request ${requestId} cancelled (bun)`);
+    },
+  });
+
+  // Stub stderr (runner diagnostics go to parent stderr via logger)
+  const stderr = new ReadableStream<Uint8Array>({
+    start(controller) {
+      // No stderr for individual requests; it's global to the runner process
+      controller.close();
+    },
+  });
+
+  return {
+    stdout,
+    stderr,
+    exited,
+    kill() {
+      log.debug(`kill() called on bun child ${requestId}` );
+      // Best-effort cancellation; runner process stays alive
+    },
+  };
+}
+
+// ─── Node-compatible child ─────────────────────────────────────────────────
+
+/**
+ * EventEmitter-based child that mirrors the shape of Node child_process.spawn().
+ * Emits "close" with exit code and "error" on failure.
+ */
+export class SdkNodeChild extends EventEmitter {
+  public readonly stdout: PassThrough = new PassThrough();
+  public readonly stderr: PassThrough = new PassThrough();
+
+  private requestId: string | null = null;
+
+  async spawn(options: { apiKey: string; model: string; prompt: string; cwd: string }) {
+    try {
+      log.info("spawning (via singleton) sdk node child", {
+        model: options.model,
+        cwd: options.cwd,
+      });
+
+      // Ensure runner is alive with this apiKey
+      await singleton.ensureRunning(options.apiKey);
+
+      // Create a ReadableStream to demultiplex from the singleton
+      let requestId: string;
+      let resolveExited: (code: number) => void;
+      let rejectExited: (err: Error) => void;
+
+      const exited = new Promise<number>((resolve, reject) => {
+        resolveExited = resolve;
+        rejectExited = reject;
+      });
+
+      const dummyController = {
+        enqueue: (data: Uint8Array) => {
+          this.stdout.write(data);
+        },
+        close: () => {
+          this.stdout.end();
+        },
+        error: (err: Error) => {
+          this.stdout.destroy(err);
+        },
+      } as unknown as ReadableStreamDefaultController<Uint8Array>;
+
+      // Register this request
+      requestId = singleton.registerPending(dummyController, (code) => {
+        this.stderr.end();
+        this.emit("close", code);
+        resolveExited(code);
+      }, (err) => {
+        this.stderr.end();
+        this.emit("error", err);
+        rejectExited(err);
+      });
+
+      this.requestId = requestId;
+      log.info(`request ${requestId} registered (node)`);
+
+      // Send the request to the runner
+      singleton.sendRequest(requestId, options.model, options.cwd, options.prompt);
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      log.error("Failed to spawn sdk node child", { error: error.message });
+      this.emit("error", error);
+    }
+  }
+
+  kill() {
+    if (this.requestId) {
+      log.debug(`kill() called on node child ${this.requestId}`);
+    }
+    // Best-effort: runner process stays alive; individual request cannot be interrupted
+  }
+}
+
+export function createSdkNodeChild(options: {
+  apiKey: string;
+  model: string;
+  prompt: string;
+  cwd: string;
+}): SdkNodeChild {
+  const child = new SdkNodeChild();
+  child.spawn(options).catch((err) => {
+    log.error("Spawn error", { error: err instanceof Error ? err.message : String(err) });
+  });
+  return child;
+}
+
+
+/**
+ * List available models via the SDK runner.
+ * 
+ * This function:
+ * 1. Ensures the runner is spawned with the provided apiKey
+ * 2. Sends a listModels request
+ * 3. Accumulates events and returns the models array from the models event
+ * 4. Times out after 15 seconds
+ */
+/**
+ * List available models via the SDK runner.
+ * 
+ * This function:
+ * 1. Ensures the runner is spawned with the provided apiKey
+ * 2. Sends a listModels request
+ * 3. Accumulates events and returns the models array from the models event
+ * 4. Times out after 15 seconds
+ */
+export async function listModelsViaRunner(apiKey: string): Promise<Array<{ id: string; name: string }>> {
+  try {
+    // Ensure runner is alive
+    await singleton.ensureRunning(apiKey);
+
+    // Return a promise that accumulates events
+    return new Promise(async (resolve, reject) => {
+      const timeout = setTimeout(() => reject(new Error("Timeout")), 15000);
+      const events: any[] = [];
+      let gotModels = false;
+
+      const decoder = new TextDecoder();
+      const controller = {
+        enqueue: (data: Uint8Array) => {
+          try {
+            const event = JSON.parse(decoder.decode(data).trim());
+            events.push(event);
+            if (event.type === "models") gotModels = true;
+          } catch (err) {
+            log.warn("listModels: failed to parse event", { error: String(err) });
+          }
+        },
+        close: () => {},
+        error: (e: Error) => reject(e),
+      } as any;
+
+      const id = singleton.registerPending(
+        controller,
+        (code: number) => {
+          clearTimeout(timeout as any);
+          if (!gotModels) return reject(new Error("No models"));
+          if (code !== 0) return reject(new Error(`Code ${code}`));
+          const m = events.find((e) => e.type === "models");
+          resolve(m?.models ?? []);
+        },
+        (e) => {
+          clearTimeout(timeout as any);
+          reject(e);
+        }
+      );
+
+      singleton.sendRawRequest({ id, op: "listModels" });
+    });
+  } catch (err) {
+    throw new Error(`listModelsViaRunner failed: ${String(err)}`);
+  }
+}
+
+