cursor-opencode-provider 0.2.3 → 0.2.5

package/dist/shell-timeout.js

@@ -0,0 +1,186 @@
+/** Cursor agent.v1 TimeoutBehavior enum values. */
+export const CURSOR_TIMEOUT_CANCEL = 1;
+export const CURSOR_TIMEOUT_BACKGROUND = 2;
+const MAX_TRACKED_SHELL_CALLS = 512;
+const OPENCODE_TIMEOUT_GRACE_MS = 15_000;
+const POLL_INTERVAL_MS = 100;
+const BACKGROUND_MARKER = "__CURSOR_SHELL_BACKGROUND__";
+const EXIT_MARKER = "__CURSOR_SHELL_EXIT__";
+const TIMEOUT_MARKER = "__CURSOR_SHELL_TIMEOUT__";
+const policies = new Map();
+const outcomes = new Map();
+function remember(map, key, value) {
+    map.delete(key);
+    map.set(key, value);
+    while (map.size > MAX_TRACKED_SHELL_CALLS) {
+        const oldest = map.keys().next().value;
+        if (!oldest)
+            break;
+        map.delete(oldest);
+    }
+}
+function finiteNonNegative(value) {
+    const n = typeof value === "number" ? value : Number(value);
+    if (!Number.isFinite(n) || n < 0)
+        return undefined;
+    return Math.floor(n);
+}
+export function shellPolicyFromMetadata(metadata) {
+    if (!metadata || metadata.shell_stream !== true)
+        return undefined;
+    const timeoutMs = finiteNonNegative(metadata.timeout_ms) ?? 30_000;
+    const timeoutBehavior = finiteNonNegative(metadata.timeout_behavior) ?? 0;
+    const hardTimeoutMs = finiteNonNegative(metadata.hard_timeout_ms);
+    return {
+        command: typeof metadata.command === "string" ? metadata.command : "",
+        workingDirectory: typeof metadata.working_directory === "string" ? metadata.working_directory : "",
+        timeoutMs,
+        timeoutBehavior,
+        ...(hardTimeoutMs !== undefined && hardTimeoutMs > 0 ? { hardTimeoutMs } : {}),
+    };
+}
+/** Register a Cursor shell request before OpenCode executes its emitted tool call. */
+export function registerCursorShellCall(toolCallId, metadata) {
+    const policy = shellPolicyFromMetadata(metadata);
+    if (!policy || !toolCallId.startsWith("cursor_"))
+        return;
+    remember(policies, toolCallId, policy);
+}
+function shellQuote(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+/**
+ * F11 / soft-background helper.
+ *
+ * Run a Cursor soft-background command for its foreground window, then leave
+ * it detached (`nohup`) if still alive. The sentinel is removed by the after
+ * hook before OpenCode stores/renders the result.
+ *
+ * This approximates Cursor's TIMEOUT_BACKGROUND semantics through OpenCode's
+ * foreground-only bash tool. Residual: after OpenCode returns, the child (and
+ * optional hard-timeout watchdog) may still be running; this provider does not
+ * reap leftover processes — cleanup is left to the user / OS.
+ */
+export function buildSoftBackgroundCommand(policy) {
+    const polls = Math.ceil(policy.timeoutMs / POLL_INTERVAL_MS);
+    const hardPolls = policy.hardTimeoutMs !== undefined
+        ? Math.max(1, Math.ceil(policy.hardTimeoutMs / POLL_INTERVAL_MS))
+        : undefined;
+    const lines = [
+        'cursor_shell_log="$(mktemp "${TMPDIR:-/tmp}/cursor-opencode-shell.XXXXXX")" || exit 1',
+        `nohup sh -c ${shellQuote(policy.command)} >"$cursor_shell_log" 2>&1 </dev/null &`,
+        "cursor_shell_pid=$!",
+    ];
+    if (hardPolls !== undefined) {
+        lines.push('cursor_shell_status="$(mktemp "${TMPDIR:-/tmp}/cursor-opencode-shell-status.XXXXXX")" || exit 1', `nohup sh -c 'cursor_hard_poll=0; while [ "$cursor_hard_poll" -lt "$1" ] && kill -0 "$2" 2>/dev/null; do sleep ${POLL_INTERVAL_MS / 1000}; cursor_hard_poll=$((cursor_hard_poll + 1)); done; if kill -0 "$2" 2>/dev/null; then printf timeout >"$3"; kill -TERM "$2" 2>/dev/null; sleep 3; kill -KILL "$2" 2>/dev/null; fi' cursor-shell-watchdog ${hardPolls} "$cursor_shell_pid" "$cursor_shell_status" >/dev/null 2>&1 </dev/null &`, "cursor_shell_watchdog_pid=$!");
+    }
+    else {
+        lines.push('cursor_shell_status=""', 'cursor_shell_watchdog_pid=""');
+    }
+    lines.push("cursor_shell_poll=0", `while [ "$cursor_shell_poll" -lt ${polls} ] && kill -0 "$cursor_shell_pid" 2>/dev/null; do`, `  sleep ${POLL_INTERVAL_MS / 1000}`, "  cursor_shell_poll=$((cursor_shell_poll + 1))", "done", 'if kill -0 "$cursor_shell_pid" 2>/dev/null; then', '  cat "$cursor_shell_log"', `  printf '\n${BACKGROUND_MARKER}%s:%s\n' "$cursor_shell_pid" "$cursor_shell_log"`, "  exit 0", "fi", 'wait "$cursor_shell_pid"', "cursor_shell_code=$?", 'cat "$cursor_shell_log"', 'if [ -n "$cursor_shell_status" ] && [ "$(cat "$cursor_shell_status" 2>/dev/null)" = timeout ]; then', `  printf '\n${TIMEOUT_MARKER}%s\n' ${policy.hardTimeoutMs ?? policy.timeoutMs}`, "else", '  if [ -n "$cursor_shell_watchdog_pid" ]; then kill "$cursor_shell_watchdog_pid" 2>/dev/null || true; fi', `  printf '\n${EXIT_MARKER}%s\n' "$cursor_shell_code"`, "fi", 'rm -f -- "$cursor_shell_log"', 'if [ -n "$cursor_shell_status" ]; then rm -f -- "$cursor_shell_status"; fi');
+    return lines.join("\n");
+}
+/** Mutate OpenCode Bash args before execution when Cursor requested soft backgrounding. */
+export function prepareCursorShellArgs(toolCallId, args) {
+    const policy = policies.get(toolCallId);
+    if (!policy || policy.timeoutBehavior !== CURSOR_TIMEOUT_BACKGROUND)
+        return;
+    args.command = buildSoftBackgroundCommand(policy);
+    // The wrapper returns just after Cursor's foreground window. OpenCode's own
+    // timeout is only an outer safety net and must not win the race.
+    args.timeout = Math.max(OPENCODE_TIMEOUT_GRACE_MS, policy.timeoutMs + OPENCODE_TIMEOUT_GRACE_MS);
+}
+/** Restore the model-facing command in OpenCode's completed tool title. */
+export function cursorShellOriginalCommand(toolCallId) {
+    return policies.get(toolCallId)?.command || undefined;
+}
+function withoutMarker(output, index) {
+    let clean = output.slice(0, index).replace(/[\t ]+$/gm, "").replace(/\n{2,}$/, "\n");
+    if (clean.trim() === "" || clean.trim() === "(no output)")
+        clean = "";
+    return clean;
+}
+function parseOpenCodeTimeout(output) {
+    const re = /<shell_metadata>\r?\nshell tool terminated command after exceeding timeout (\d+) ms\.[\s\S]*?<\/shell_metadata>\s*$/;
+    const match = re.exec(output);
+    if (!match || match.index === undefined)
+        return undefined;
+    return { output: withoutMarker(output, match.index), timeoutMs: Number(match[1]) };
+}
+function parseWrapperOutcome(output, policy) {
+    const background = new RegExp(`${BACKGROUND_MARKER}(\\d+):([^\\r\\n]+)\\s*$`).exec(output);
+    if (background?.index !== undefined) {
+        const pid = Number(background[1]);
+        if (Number.isSafeInteger(pid) && pid > 0 && pid <= 0xffff_ffff) {
+            return {
+                output: withoutMarker(output, background.index),
+                outcome: {
+                    kind: "backgrounded",
+                    shellId: pid,
+                    pid,
+                    command: policy?.command ?? "",
+                    workingDirectory: policy?.workingDirectory ?? "",
+                    msToWait: policy?.timeoutMs ?? 0,
+                    reason: 1,
+                },
+            };
+        }
+    }
+    const timeout = new RegExp(`${TIMEOUT_MARKER}(\\d+)\\s*$`).exec(output);
+    if (timeout?.index !== undefined) {
+        return {
+            output: withoutMarker(output, timeout.index),
+            outcome: { kind: "timeout", timeoutMs: Number(timeout[1]) },
+        };
+    }
+    const exit = new RegExp(`${EXIT_MARKER}(-?\\d+)\\s*$`).exec(output);
+    if (exit?.index !== undefined) {
+        return {
+            output: withoutMarker(output, exit.index),
+            outcome: { kind: "exit", code: Number(exit[1]) },
+        };
+    }
+    return undefined;
+}
+/**
+ * Capture Bash completion in the classic plugin's after hook. Returns the
+ * sanitized output that OpenCode should store and render.
+ */
+export function captureCursorShellResult(toolCallId, output, metadata) {
+    if (!toolCallId.startsWith("cursor_"))
+        return output;
+    const policy = policies.get(toolCallId);
+    // Private wrapper sentinels are meaningful only for calls we transformed.
+    // A normal foreground command is allowed to print the same text verbatim.
+    const wrapper = policy?.timeoutBehavior === CURSOR_TIMEOUT_BACKGROUND
+        ? parseWrapperOutcome(output, policy)
+        : undefined;
+    if (wrapper) {
+        remember(outcomes, toolCallId, wrapper.outcome);
+        return wrapper.output;
+    }
+    const timeout = parseOpenCodeTimeout(output);
+    if (timeout) {
+        remember(outcomes, toolCallId, { kind: "timeout", timeoutMs: timeout.timeoutMs });
+        return timeout.output;
+    }
+    const exitCode = finiteNonNegative(metadata?.exit);
+    if (exitCode !== undefined)
+        remember(outcomes, toolCallId, { kind: "exit", code: exitCode });
+    return output;
+}
+/** Consume the structured result, with an inline fallback when no plugin hook ran. */
+export function consumeCursorShellResult(toolCallId, output) {
+    let clean = output;
+    if (!outcomes.has(toolCallId))
+        clean = captureCursorShellResult(toolCallId, output);
+    const outcome = outcomes.get(toolCallId);
+    outcomes.delete(toolCallId);
+    policies.delete(toolCallId);
+    return { output: clean, outcome };
+}
+/** Test/process cleanup. */
+export function resetCursorShellCalls() {
+    policies.clear();
+    outcomes.clear();
+}

package/dist/transport/connect.d.ts

@@ -1,3 +1,5 @@
+import { CursorTransportError, CursorProviderError } from "../errors.js";
+import http2 from "node:http2";
 export declare function buildBaseHeaders(token: string, clientVersion: string, extra?: Record<string, string>): Record<string, string>;
 export declare function unaryAvailableModels(token: string, options?: {
     apiBaseURL?: string;
@@ -30,19 +32,53 @@ export declare function fetchAgentUrl(token: string, options?: {
     telemetryEnabled?: boolean;
 }): Promise<string>;
 export type BidiStream = {
-    write(msg: Uint8Array): void;
+    write(msg: Uint8Array): boolean | void;
+    waitForDrain?(timeoutMs: number): Promise<void>;
     end(): void;
     frames(): AsyncIterable<{
         flags: number;
         payload: Uint8Array;
     }>;
     destroy(): void;
+    isClosed(): boolean;
+    onTerminal(listener: (event: BidiTerminalEvent) => void): () => void;
 };
+export type BidiTerminalEvent = {
+    kind: "remote-clean-close";
+} | {
+    kind: "remote-error";
+    error: CursorProviderError;
+} | {
+    kind: "local-close";
+};
+export declare class CursorRunInterruptedError extends CursorTransportError {
+    constructor(message?: string, options?: ErrorOptions);
+}
+export declare function cursorRunTerminationError(input: {
+    responseStatus: number;
+    responseHeaders?: Record<string, unknown>;
+    responseTrailers?: Record<string, unknown>;
+    streamError?: Error | null;
+}): CursorProviderError;
+export declare const HTTP2_SESSION_MAX_AGE_MS: number;
+export declare function shouldReuseHttp2Session(state: {
+    destroyed: boolean;
+    closed: boolean;
+}, createdAt: number, now?: number): boolean;
 /** Resolve the HTTP/2 connect origin for a Run stream (exported for tests). */
 export declare function resolveAgentOrigin(baseURL: string): string;
+/** Test cleanup for local HTTP/2 fixtures; production sessions stay process-cached. */
+export declare function closeCachedHttp2SessionsForTests(): void;
+/** Node-runtime regression hook; production callers use getSession(). */
+export declare function installSessionInvalidationForTests(origin: string, session: http2.ClientHttp2Session): void;
+export declare function getSession(baseURL: string, options?: {
+    pingTimeoutMs?: number;
+}): Promise<http2.ClientHttp2Session>;
 export declare function bidiRunStream(token: string, options: {
     signal?: AbortSignal;
     baseURL: string;
     headers?: Record<string, string>;
+    readIdleMs?: number;
+    pingTimeoutMs?: number;
 }): Promise<BidiStream>;
 export declare function makeRequestId(): string;