cursor-opencode-provider 0.7.1 → 0.7.3

package/dist/session-directory.d.ts

@@ -5,13 +5,32 @@
  * supplied once per invocation by the 1.x host. OpenCode 2.0 runs a single
  * daemon across many projects, so `process.cwd()` captured at sdk-creation
  * time is wrong for any session but the one open when the daemon started.
- * The only place the 2.0 runtime names a session's actual directory is
- * `SessionInfo.location.directory`, reachable from `session.hook("context")`'s
- * `sessionID` via `ctx.session.get()`. Record it there and let the provider
- * read it back by session id, same mechanism as `compaction-marker.ts`.
+ *
+ * The 2.0 runtime names a session directory in two places:
+ * - request header `x-opencode-directory` (per-request; preferred in the LM)
+ * - `ctx.session.get()` → flat `info.directory`, or legacy
+ *   `info.location.directory`, reachable from `session.hook("context")`
+ *
+ * This module records the session-get value by id so the language model can
+ * fall back when the header is absent, same mechanism as `compaction-marker.ts`.
  *
  * Bounded so a long-lived server cannot accumulate ids for dead sessions.
  */
 export declare function markSessionDirectory(sessionID: string, directory: string | undefined): void;
 export declare function getSessionDirectory(sessionID: string | undefined): string | undefined;
 export declare function clearSessionDirectories(): void;
+/**
+ * Active session workspace directory from OpenCode 2.0 request headers.
+ * Values may be URI-encoded.
+ */
+export declare function opencodeDirectoryHeader(headers: Record<string, string | undefined> | undefined): string | undefined;
+/**
+ * Resolve the workspace root for a model turn.
+ * Prefer the per-request header, then the session mark, then static options/cwd.
+ */
+export declare function resolveSessionWorkspaceRoot(input: {
+    sessionKey?: string;
+    headers?: Record<string, string | undefined>;
+    workspaceRoot?: string;
+    cwd?: string;
+}): string;

package/dist/session-directory.js

@@ -5,13 +5,18 @@
  * supplied once per invocation by the 1.x host. OpenCode 2.0 runs a single
  * daemon across many projects, so `process.cwd()` captured at sdk-creation
  * time is wrong for any session but the one open when the daemon started.
- * The only place the 2.0 runtime names a session's actual directory is
- * `SessionInfo.location.directory`, reachable from `session.hook("context")`'s
- * `sessionID` via `ctx.session.get()`. Record it there and let the provider
- * read it back by session id, same mechanism as `compaction-marker.ts`.
+ *
+ * The 2.0 runtime names a session directory in two places:
+ * - request header `x-opencode-directory` (per-request; preferred in the LM)
+ * - `ctx.session.get()` → flat `info.directory`, or legacy
+ *   `info.location.directory`, reachable from `session.hook("context")`
+ *
+ * This module records the session-get value by id so the language model can
+ * fall back when the header is absent, same mechanism as `compaction-marker.ts`.
  *
  * Bounded so a long-lived server cannot accumulate ids for dead sessions.
  */
+import path from "node:path";
 const MAX_TRACKED_SESSIONS = 256;
 const sessionDirectories = new Map();
 export function markSessionDirectory(sessionID, directory) {
@@ -33,3 +38,30 @@ export function getSessionDirectory(sessionID) {
 export function clearSessionDirectories() {
     sessionDirectories.clear();
 }
+/**
+ * Active session workspace directory from OpenCode 2.0 request headers.
+ * Values may be URI-encoded.
+ */
+export function opencodeDirectoryHeader(headers) {
+    if (!headers)
+        return undefined;
+    const raw = headers["x-opencode-directory"] ?? headers["X-Opencode-Directory"];
+    if (typeof raw !== "string" || raw.trim().length === 0)
+        return undefined;
+    const trimmed = raw.trim();
+    try {
+        return decodeURIComponent(trimmed);
+    }
+    catch {
+        return trimmed;
+    }
+}
+/**
+ * Resolve the workspace root for a model turn.
+ * Prefer the per-request header, then the session mark, then static options/cwd.
+ */
+export function resolveSessionWorkspaceRoot(input) {
+    return path.resolve(opencodeDirectoryHeader(input.headers) ??
+        getSessionDirectory(input.sessionKey) ??
+        (input.workspaceRoot || input.cwd || process.cwd()));
+}

package/dist/session.d.ts

@@ -131,6 +131,8 @@ export type CursorSession = {
         stepCompletes: number;
         displayToolCalls: number;
         execRequests: number;
+        createPlanInTurn?: boolean;
+        switchModeInTurn?: boolean;
     };
     /** OpenCode session whose own or descendant activity renews tool leases. */
     openCodeSessionId?: string;
@@ -186,6 +188,12 @@ export type CursorSession = {
      * stream instead of emitting tool-call parts OpenCode will reject.
      */
     allowTools: boolean;
+    /**
+     * Host-enabled tool names for *this* Run (what actually arrived). May be a
+     * subset of the epoch advertisement when plan denies edit — advertise fully
+     * for cache stability, but refuse exec outside this set.
+     */
+    permittedToolNames?: ReadonlySet<string>;
     /**
      * Best-effort held-Run activity counters used only for diagnostics. Displayed
      * AI SDK usage comes from checkpoint occupancy (tool steps) and TurnEnded
@@ -245,12 +253,24 @@ export declare class SessionManager {
     private readonly maxOpenSessions;
     constructor(options?: SessionManagerOptions);
     registerSession(session: CursorSession): void;
+    /** Live open Run for this OpenCode session id, if any. */
+    findOpenByOpenCodeSessionId(openCodeSessionId: string | undefined): CursorSession | undefined;
+    isActivelyPumping(session: CursorSession): boolean;
+    /**
+     * Clear display-only bridged pendings that do not require a Cursor exec write.
+     * Used when the host starts a fresh user turn instead of returning the bridged
+     * tool result (e.g. human `continue` while a todowrite mirror is outstanding).
+     *
+     * @returns number of bridged pendings settled
+     */
+    settleBridgedPending(session: CursorSession): number;
     private isPumping;
     /**
      * Force-close the oldest idle open session(s) once registration exceeds the
-     * cap. Never closes a session with a live pull() mid-await (see the same
-     * guard in the supersede check above) — an unclosable backlog of genuinely
-     * active sessions just means the cap can't be enforced until one finishes.
+     * cap. Never closes a session with a live pull() mid-await, or one still
+     * holding pending execs (continuation / fresh-turn cancel+drain owns those).
+     * An unclosable backlog of genuinely active sessions just means the cap
+     * can't be enforced until one finishes.
      */
     private enforceOpenSessionCap;
     recordSemanticProgress(session: CursorSession, at?: number): void;

package/dist/session.js

@@ -109,10 +109,26 @@ export class SessionManager {
                         `— leaving it to finish or expire naturally instead of interrupting it`);
                 }
                 else {
-                    trace(`sessionManager.registerSession: superseding stale session ${prior.sessionId} ` +
-                        `(openCodeSessionId=${session.openCodeSessionId}, pending=${prior.pending.size}) ` +
-                        `with new session ${session.sessionId}`);
-                    this.close(prior, "superseded-by-new-run");
+                    // Display-only bridged pendings do not need a Cursor exec write — settle
+                    // them first so a todowrite-only prior can still be superseded cleanly.
+                    const settled = this.settleBridgedPending(prior);
+                    if (settled > 0) {
+                        trace(`sessionManager.registerSession: settled ${settled} bridged pending on prior ` +
+                            `session ${prior.sessionId} before supersede`);
+                    }
+                    if (prior.pending.size > 0) {
+                        // Real execs still outstanding — preparePriorSessionForFreshTurn should
+                        // have cancelled + drained. Do not mid-exec supersede.
+                        trace(`sessionManager.registerSession: openCodeSessionId=${session.openCodeSessionId} ` +
+                            `has prior session ${prior.sessionId} with ${prior.pending.size} still-pending ` +
+                            `exec(s) — refusing supersede; leaving held Run for cancel/drain/continuation`);
+                    }
+                    else {
+                        trace(`sessionManager.registerSession: superseding stale session ${prior.sessionId} ` +
+                            `(openCodeSessionId=${session.openCodeSessionId}, pending=${prior.pending.size}) ` +
+                            `with new session ${session.sessionId}`);
+                        this.close(prior, "superseded-by-new-run");
+                    }
                 }
             }
             this.byOpenCodeSessionId.set(session.openCodeSessionId, session);
@@ -120,14 +136,54 @@ export class SessionManager {
         this.enforceOpenSessionCap(session);
         this.subscribeTerminal(session);
     }
+    /** Live open Run for this OpenCode session id, if any. */
+    findOpenByOpenCodeSessionId(openCodeSessionId) {
+        if (!openCodeSessionId)
+            return undefined;
+        const session = this.byOpenCodeSessionId.get(openCodeSessionId);
+        return session && !session.closed ? session : undefined;
+    }
+    isActivelyPumping(session) {
+        return this.isPumping(session);
+    }
+    /**
+     * Clear display-only bridged pendings that do not require a Cursor exec write.
+     * Used when the host starts a fresh user turn instead of returning the bridged
+     * tool result (e.g. human `continue` while a todowrite mirror is outstanding).
+     *
+     * @returns number of bridged pendings settled
+     */
+    settleBridgedPending(session) {
+        if (session.closed)
+            return 0;
+        let settled = 0;
+        for (const [execId, pending] of [...session.pending.entries()]) {
+            if (!pending.bridged)
+                continue;
+            if (pending.state === "claimed")
+                continue;
+            const key = this.key(session.sessionId, execId);
+            this.putTombstone(key, "delivered");
+            session.pending.delete(execId);
+            this.byExecId.delete(key);
+            settled++;
+        }
+        if (settled > 0) {
+            if (session.pending.size === 0)
+                this.recordSemanticProgress(session);
+            this.scheduleHardDeadline(session);
+        }
+        return settled;
+    }
     isPumping(session) {
         return session.pumpOwner != null || session.pumpActive;
     }
     /**
      * Force-close the oldest idle open session(s) once registration exceeds the
-     * cap. Never closes a session with a live pull() mid-await (see the same
-     * guard in the supersede check above) — an unclosable backlog of genuinely
-     * active sessions just means the cap can't be enforced until one finishes.
+     * cap. Never closes a session with a live pull() mid-await, or one still
+     * holding pending execs (continuation / fresh-turn cancel+drain owns those).
+     * An unclosable backlog of genuinely active sessions just means the cap
+     * can't be enforced until one finishes.
      */
     enforceOpenSessionCap(justRegistered) {
         while (this.sessions.size > this.maxOpenSessions) {
@@ -135,13 +191,17 @@ export class SessionManager {
             for (const candidate of this.sessions) {
                 if (candidate === justRegistered || this.isPumping(candidate))
                     continue;
+                // Held-open Runs with pending tools must not be cap-evicted — that is
+                // mid-exec supersede by another name and throws away the prefix.
+                if (candidate.pending.size > 0)
+                    continue;
                 if (!oldest || candidate.createdAt < oldest.createdAt)
                     oldest = candidate;
             }
             if (!oldest) {
                 trace(`sessionManager.registerSession: open session cap exceeded ` +
                     `(${this.sessions.size} > ${this.maxOpenSessions}) but no idle session is ` +
-                    `available to close — all remaining sessions are actively pumping`);
+                    `available to close — all remaining sessions are pumping or held-pending`);
                 return;
             }
             trace(`sessionManager.registerSession: open session cap exceeded ` +

package/dist/shared.d.ts

@@ -4,6 +4,8 @@ export declare const FALLBACK_CLIENT_VERSION = "cli-2026.07.09-a3815c0";
 export declare const CURSOR_PROVIDER_ID = "cursor";
 /** Private provider option injected by the OpenCode plugin for summary turns. */
 export declare const CURSOR_COMPACTION_OPTION = "opencodeCompaction";
+/** OpenCode host rebuilt its history without a provider compaction turn. */
+export declare const CURSOR_HISTORY_REWRITE_OPTION = "opencodeHistoryRewrite";
 /** Current OpenCode primary agent; used to invalidate incompatible checkpoints. */
 export declare const CURSOR_HOST_AGENT_OPTION = "opencodeHostAgent";
 export declare const TOKEN_EXPIRY_THRESHOLD_S = 300;

package/dist/shared.js

@@ -4,6 +4,8 @@ export const FALLBACK_CLIENT_VERSION = "cli-2026.07.09-a3815c0";
 export const CURSOR_PROVIDER_ID = "cursor";
 /** Private provider option injected by the OpenCode plugin for summary turns. */
 export const CURSOR_COMPACTION_OPTION = "opencodeCompaction";
+/** OpenCode host rebuilt its history without a provider compaction turn. */
+export const CURSOR_HISTORY_REWRITE_OPTION = "opencodeHistoryRewrite";
 /** Current OpenCode primary agent; used to invalidate incompatible checkpoints. */
 export const CURSOR_HOST_AGENT_OPTION = "opencodeHostAgent";
 export const TOKEN_EXPIRY_THRESHOLD_S = 300;

package/dist/transport/connect.js

@@ -7,6 +7,7 @@ import { trace } from "../debug.js";
 import { CursorLocalCancellationError, CursorProtocolError, CursorTransportError, cursorGrpcError, cursorHttpError, errorCode, CursorProviderError, } from "../errors.js";
 import { withAbortDeadline } from "../deadline.js";
 import http2 from "node:http2";
+import { openProxiedTlsSocket, proxyEndpoint, resolveHttpsProxyUrl } from "./https-proxy.js";
 const API_BASE = `https://${CURSOR_API_HOST}`;
 const DEFAULT_UNARY_TIMEOUT_MS = 5_000;
 const MAX_TIMER_MS = 2_147_483_647;
@@ -407,40 +408,65 @@ function validateCachedSession(session, pingTimeoutMs) {
 }
 function connectSession(origin) {
     return new Promise((resolve, reject) => {
-        const session = http2.connect(origin);
         let settled = false;
-        const cleanup = () => {
+        let session;
+        let tunnelSocket;
+        const abort = new AbortController();
+        const clearConnectTimer = () => {
             clearTimeout(timer);
+        };
+        const detachSessionListeners = () => {
+            if (!session)
+                return;
             session.removeListener("error", onError);
             session.removeListener("close", onClose);
             session.removeListener("connect", onConnect);
         };
+        const destroyTunnel = () => {
+            try {
+                tunnelSocket?.destroy();
+            }
+            catch { /* ignore */ }
+            tunnelSocket = undefined;
+        };
         const fail = (error) => {
             if (settled)
                 return;
             settled = true;
-            cleanup();
-            dropSession(origin, session);
+            clearConnectTimer();
             try {
-                session.destroy();
+                abort.abort(error);
             }
             catch { /* ignore */ }
+            detachSessionListeners();
+            if (session) {
+                dropSession(origin, session);
+                try {
+                    session.destroy();
+                }
+                catch { /* ignore */ }
+            }
+            destroyTunnel();
             reject(error);
         };
         const onError = (error) => fail(toTransportError(error, "Cursor HTTP/2 connection failed"));
         const onClose = () => fail(new CursorTransportError(`HTTP/2 connection to ${origin} closed before connecting`));
         const onConnect = () => {
-            if (settled)
+            if (settled || !session)
                 return;
             settled = true;
-            cleanup();
+            clearConnectTimer();
+            detachSessionListeners();
             installSessionInvalidation(origin, session);
             if (session.destroyed || session.closed) {
                 const error = new CursorTransportError(`HTTP/2 connection to ${origin} closed while connecting`);
                 invalidateSession(origin, session);
+                destroyTunnel();
                 reject(error);
                 return;
             }
+            // The TLS socket (if any) is owned by the HTTP/2 session from here on.
+            tunnelSocket = undefined;
             _http2SessionCreatedAt.set(session, Date.now());
             _http2Sessions.set(origin, session);
             trace(`h2 session connected: origin=${origin}`);
@@ -450,9 +476,51 @@ function connectSession(origin) {
             fail(new CursorTransportError(`HTTP/2 connect to ${origin} timed out after ${CONNECT_TIMEOUT_MS}ms`));
         }, CONNECT_TIMEOUT_MS);
         timer.unref?.();
-        session.on("error", onError);
-        session.once("close", onClose);
-        session.once("connect", onConnect);
+        void (async () => {
+            try {
+                const { hostname, port: originPort } = new URL(origin);
+                const targetPort = originPort ? Number(originPort) : 443;
+                const proxy = resolveHttpsProxyUrl(hostname, process.env, targetPort);
+                if (proxy) {
+                    const endpoint = proxyEndpoint(proxy);
+                    trace(`h2 connect via HTTPS proxy: origin=${origin} proxy=${endpoint.host}:${endpoint.port}`);
+                    const tlsSocket = await openProxiedTlsSocket({
+                        proxy,
+                        targetHost: hostname,
+                        targetPort,
+                        signal: abort.signal,
+                    });
+                    if (settled) {
+                        try {
+                            tlsSocket.destroy();
+                        }
+                        catch { /* ignore */ }
+                        return;
+                    }
+                    tunnelSocket = tlsSocket;
+                    session = http2.connect(origin, {
+                        createConnection: () => tlsSocket,
+                    });
+                }
+                else {
+                    session = http2.connect(origin);
+                }
+                if (settled) {
+                    try {
+                        session.destroy();
+                    }
+                    catch { /* ignore */ }
+                    destroyTunnel();
+                    return;
+                }
+                session.on("error", onError);
+                session.once("close", onClose);
+                session.once("connect", onConnect);
+            }
+            catch (error) {
+                fail(toTransportError(error, "Cursor HTTP/2 connection failed"));
+            }
+        })();
     });
 }
 export function getSession(baseURL, options = {}) {

package/dist/transport/https-proxy.d.ts

@@ -0,0 +1,56 @@
+/**
+ * HTTPS proxy helpers for the Cursor Run HTTP/2 transport.
+ *
+ * Unary RPCs use Bun `fetch()`, which already honors HTTPS_PROXY / NO_PROXY.
+ * `node:http2` does not, so Run sessions tunnel through an HTTP CONNECT proxy
+ * when those env vars apply. See GitHub issue #26.
+ *
+ * Important (Bun 1.3.x): do the CONNECT handshake on a native `net.Socket`,
+ * then `tls.connect({ socket })` on that same socket. Do not insert a custom
+ * Duplex between the proxy socket and TLS — destroying such a session mid-
+ * handshake can segfault Bun.
+ */
+import net from "node:net";
+import tls from "node:tls";
+export type ProxyEnv = Record<string, string | undefined>;
+/**
+ * HTTPS_PROXY / https_proxy for an HTTPS target. Like curl, HTTP_PROXY is not
+ * consulted for HTTPS. Only `http://` proxies can carry the CONNECT tunnel;
+ * `https://` (TLS to the proxy) and other schemes are ignored so the Run keeps
+ * its direct connection rather than failing on every connect.
+ */
+export declare function resolveHttpsProxyUrl(targetHost: string, env?: ProxyEnv, targetPort?: number): URL | undefined;
+/**
+ * curl/Node-style NO_PROXY matching: `*`, exact host, optional `:port`, and
+ * leading-dot / bare-domain suffix forms (`.corp.example` / `corp.example`).
+ * A port-qualified entry only bypasses that port.
+ */
+export declare function hostMatchesNoProxy(targetHost: string, noProxy: string | undefined, targetPort?: number): boolean;
+/** Dialable proxy address: IPv6 literals without URL brackets, default port 80. */
+export declare function proxyEndpoint(proxy: URL): {
+    host: string;
+    port: number;
+};
+export type OpenHttpsConnectTunnelOptions = {
+    proxy: URL;
+    targetHost: string;
+    targetPort?: number;
+    signal?: AbortSignal;
+    /** Injected for tests. */
+    connect?: typeof net.connect;
+};
+/**
+ * Open a plain TCP connection to the proxy and establish an HTTP CONNECT tunnel
+ * to `targetHost:targetPort`. Returns the tunneled socket ready for TLS.
+ */
+export declare function openHttpsConnectTunnel(options: OpenHttpsConnectTunnelOptions): Promise<net.Socket>;
+export type OpenProxiedTlsSocketOptions = {
+    proxy: URL;
+    targetHost: string;
+    targetPort?: number;
+    signal?: AbortSignal;
+    connect?: typeof net.connect;
+    tlsConnect?: typeof tls.connect;
+};
+/** CONNECT through the proxy, then complete TLS (ALPN h2) on the native socket. */
+export declare function openProxiedTlsSocket(options: OpenProxiedTlsSocketOptions): Promise<tls.TLSSocket>;