cursor-opencode-provider 0.8.0 → 0.8.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cursor-opencode-provider",
-  "version": "0.8.0",
+  "version": "0.8.3",
   "description": "Use Cursor subscription models from OpenCode via Cursor's Connect-RPC agent protocol",
   "type": "module",
   "license": "MIT",
@@ -70,13 +70,15 @@
     "LICENSE",
     "DISCLAIMER.md",
     "SECURITY.md",
-    "README.md"
+    "README.md",
+    "CHANGELOG.md"
   ],
   "scripts": {
     "build": "tsc",
     "typecheck": "tsc --noEmit && tsc --noEmit -p tsconfig.test.json",
     "test": "bun test",
-    "test:node-http2": "bun run build && node test/node-http2-cleanup.mjs",
+    "test:coverage": "bun test --coverage --coverage-reporter=lcov && bun scripts/strip-copied-coverage.ts",
+    "test:node-http2": "bun run build && node test/node-http2-cleanup.mjs && node test/node-http2-drain.mjs && node test/node-http2-session-memory.mjs",
     "test:watch": "bun test --watch",
     "generate:pricing": "bun run scripts/generate-cursor-pricing.ts",
     "generate:pricing:check": "bun run scripts/generate-cursor-pricing.ts -- --check",

package/dist/plan-execution-kickoff.d.ts

@@ -1,57 +0,0 @@
-/**
- * Queue OpenCode's post-plan-exit kickoff after CreatePlan approval.
- *
- * Native `plan_exit` asks the user, then injects a synthetic user message with
- * `agent: "build"` so a new turn starts implementing. Our CreatePlan → question
- * path already asks; this module is the missing second half. A host plugin
- * installs the prompt handler; the language model records a request after Yes,
- * and the outer stream wrapper flushes it only after the current `doStream`
- * result stream has settled. This prevents a second generation from starting
- * while the continuation Run is still live.
- */
-export type PlanExecutionKickoffInput = {
-    sessionID: string;
-    /** Filesystem path (or relative display path) of the approved plan. */
-    planPath: string;
-    /** Concrete Cursor Run that owns the approval. Guards recovery/supersession. */
-    cursorSessionID?: string;
-};
-export type PlanExecutionKickoffFn = (input: PlanExecutionKickoffInput) => void | Promise<void>;
-/** Upstream `PlanExitTool` wording — keep verbatim so behaviour matches OpenCode. */
-export declare function createPlanExecutionKickoffText(planPath: string): string;
-/**
- * Prefer a worktree-relative label when the plan sits under `workspaceRoot`,
- * matching OpenCode's `path.relative(instance.worktree, Session.plan(...))`.
- * Otherwise keep the absolute path (global data `plans/` is outside the tree).
- */
-export declare function formatPlanKickoffPath(planPath: string, workspaceRoot?: string): string;
-/** Decode a `file://` plan URI to a filesystem path; pass other strings through. */
-export declare function planPathFromUri(planUri: string): string;
-export type PlanExecutionKickoffState = PlanExecutionKickoffInput & {
-    status: "pending" | "failed";
-    attempts: number;
-    lastError?: string;
-};
-/** Install (or clear) the host kickoff. */
-export declare function setPlanExecutionKickoff(fn: PlanExecutionKickoffFn | undefined): void;
-export declare function hasPlanExecutionKickoff(): boolean;
-/** Record the approved plan; execution is flushed after the stream settles. */
-export declare function queuePlanExecutionKickoff(input: PlanExecutionKickoffInput): boolean;
-/** Drop any approval state owned by a deleted host session. */
-export declare function cancelPlanExecutionKickoff(sessionID: string | undefined): void;
-/**
- * Run one pending kickoff only after the owning Cursor Run reached a terminal,
- * idle state. Returns true only after successful host handoff.
- */
-export declare function flushPlanExecutionKickoff(sessionID: string | undefined, options?: {
-    cursorSessionID?: string;
-    terminal?: boolean;
-    pumpActive?: boolean;
-    pendingExecs?: number;
-}): Promise<boolean>;
-/** Consume a user-visible warning on the next provider turn. */
-export declare function takePlanExecutionKickoffWarning(sessionID: string | undefined): string | undefined;
-/** Retry state remains explicit; no timer or automatic loop fires it. */
-export declare function planExecutionKickoffState(sessionID: string | undefined): PlanExecutionKickoffState | undefined;
-/** Test helper: clear the registered kickoff and pending approvals. */
-export declare function resetPlanExecutionKickoffForTests(): void;

package/dist/plan-execution-kickoff.js

@@ -1,186 +0,0 @@
-/**
- * Queue OpenCode's post-plan-exit kickoff after CreatePlan approval.
- *
- * Native `plan_exit` asks the user, then injects a synthetic user message with
- * `agent: "build"` so a new turn starts implementing. Our CreatePlan → question
- * path already asks; this module is the missing second half. A host plugin
- * installs the prompt handler; the language model records a request after Yes,
- * and the outer stream wrapper flushes it only after the current `doStream`
- * result stream has settled. This prevents a second generation from starting
- * while the continuation Run is still live.
- */
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { errorMessage, trace } from "./debug.js";
-/** Upstream `PlanExitTool` wording — keep verbatim so behaviour matches OpenCode. */
-export function createPlanExecutionKickoffText(planPath) {
-    const where = planPath.trim() || "the plan";
-    return `The plan at ${where} has been approved, you can now edit files. Execute the plan`;
-}
-/**
- * Prefer a worktree-relative label when the plan sits under `workspaceRoot`,
- * matching OpenCode's `path.relative(instance.worktree, Session.plan(...))`.
- * Otherwise keep the absolute path (global data `plans/` is outside the tree).
- */
-export function formatPlanKickoffPath(planPath, workspaceRoot) {
-    const absolute = planPath.trim();
-    if (!absolute)
-        return absolute;
-    const root = workspaceRoot?.trim();
-    if (!root)
-        return absolute;
-    const relative = path.relative(root, absolute);
-    if (!relative || relative.startsWith("..") || path.isAbsolute(relative)) {
-        return absolute;
-    }
-    return relative;
-}
-/** Decode a `file://` plan URI to a filesystem path; pass other strings through. */
-export function planPathFromUri(planUri) {
-    const raw = planUri.trim();
-    if (!raw)
-        return "";
-    if (raw.startsWith("file:")) {
-        try {
-            return fileURLToPath(raw);
-        }
-        catch {
-            return raw;
-        }
-    }
-    return raw;
-}
-let kickoff;
-const pending = new Map();
-const warnings = new Map();
-const MAX_PENDING_PLAN_KICKOFFS = 256;
-/** Install (or clear) the host kickoff. */
-export function setPlanExecutionKickoff(fn) {
-    kickoff = fn;
-    if (!fn) {
-        pending.clear();
-        warnings.clear();
-    }
-}
-export function hasPlanExecutionKickoff() {
-    return kickoff !== undefined;
-}
-/** Record the approved plan; execution is flushed after the stream settles. */
-export function queuePlanExecutionKickoff(input) {
-    const sessionID = input.sessionID.trim();
-    const planPath = input.planPath.trim();
-    if (!sessionID || !planPath || !kickoff) {
-        trace(`plan-execution-kickoff: not queued sessionID=${JSON.stringify(sessionID)} ` +
-            `planPath=${JSON.stringify(planPath)} handler=${Boolean(kickoff)}`);
-        return false;
-    }
-    pending.set(sessionID, {
-        sessionID,
-        planPath,
-        ...(input.cursorSessionID ? { cursorSessionID: input.cursorSessionID } : {}),
-        status: "pending",
-        attempts: 0,
-    });
-    warnings.delete(sessionID);
-    while (pending.size > MAX_PENDING_PLAN_KICKOFFS) {
-        const oldest = pending.keys().next().value;
-        if (!oldest)
-            break;
-        pending.delete(oldest);
-        warnings.delete(oldest);
-    }
-    trace(`plan-execution-kickoff: pending sessionID=${sessionID} ` +
-        `cursorSessionID=${input.cursorSessionID ?? ""} planPath=${planPath}`);
-    return true;
-}
-/** Drop any approval state owned by a deleted host session. */
-export function cancelPlanExecutionKickoff(sessionID) {
-    const key = sessionID?.trim();
-    if (!key)
-        return;
-    pending.delete(key);
-    warnings.delete(key);
-}
-/**
- * Run one pending kickoff only after the owning Cursor Run reached a terminal,
- * idle state. Returns true only after successful host handoff.
- */
-export async function flushPlanExecutionKickoff(sessionID, options = {}) {
-    const key = sessionID?.trim();
-    if (!key)
-        return false;
-    const state = pending.get(key);
-    if (!state)
-        return false;
-    if (options.terminal !== true || options.pumpActive || (options.pendingExecs ?? 0) > 0) {
-        trace(`plan-execution-kickoff: deferred sessionID=${key} terminal=${Boolean(options.terminal)} ` +
-            `pumpActive=${Boolean(options.pumpActive)} pending=${options.pendingExecs ?? 0}`);
-        return false;
-    }
-    if (state.cursorSessionID
-        && options.cursorSessionID
-        && state.cursorSessionID !== options.cursorSessionID) {
-        // The owning Run was superseded before the handoff could happen. Applying
-        // it from a later Run would execute a stale approval in the wrong turn.
-        pending.delete(key);
-        warnings.delete(key);
-        trace(`plan-execution-kickoff: discarded stale Run sessionID=${key} ` +
-            `owner=${state.cursorSessionID} terminal=${options.cursorSessionID}`);
-        return false;
-    }
-    const run = kickoff;
-    if (!run) {
-        const message = "The plan was approved, but this host cannot start its execution turn.";
-        state.status = "failed";
-        state.lastError = message;
-        warnings.set(key, message);
-        return false;
-    }
-    state.attempts += 1;
-    try {
-        await run({
-            sessionID: state.sessionID,
-            planPath: state.planPath,
-            ...(state.cursorSessionID ? { cursorSessionID: state.cursorSessionID } : {}),
-        });
-        pending.delete(key);
-        warnings.delete(key);
-        trace(`plan-execution-kickoff: queued sessionID=${key} planPath=${state.planPath}`);
-        return true;
-    }
-    catch (error) {
-        const detail = errorMessage(error);
-        const message = `The approved plan could not start execution: ${detail}. ` +
-            "The plan remains active and can be retried.";
-        state.status = "failed";
-        state.lastError = detail;
-        // A later explicit provider turn may retry after its own terminal boundary;
-        // do not keep pinning the retry to the now-finished Cursor Run.
-        delete state.cursorSessionID;
-        warnings.set(key, message);
-        trace(`plan-execution-kickoff: FAILED sessionID=${key} attempts=${state.attempts} err=${detail}`);
-        return false;
-    }
-}
-/** Consume a user-visible warning on the next provider turn. */
-export function takePlanExecutionKickoffWarning(sessionID) {
-    const key = sessionID?.trim();
-    if (!key)
-        return undefined;
-    const message = warnings.get(key);
-    if (message)
-        warnings.delete(key);
-    return message;
-}
-/** Retry state remains explicit; no timer or automatic loop fires it. */
-export function planExecutionKickoffState(sessionID) {
-    const key = sessionID?.trim();
-    const state = key ? pending.get(key) : undefined;
-    return state ? { ...state } : undefined;
-}
-/** Test helper: clear the registered kickoff and pending approvals. */
-export function resetPlanExecutionKickoffForTests() {
-    kickoff = undefined;
-    pending.clear();
-    warnings.clear();
-}

package/dist/protocol/thinking.d.ts

@@ -1,15 +0,0 @@
-export type EffortConfig = {
-    reasoningEffort?: string;
-    maxMode?: boolean;
-};
-/**
- * Build RequestedModel parameter list from a model's variant parameters
- * and optional overrides from providerOptions.
- */
-export declare function buildRequestedModelParams(variantParameters: Array<{
-    id: string;
-    value: string;
-}>, options?: EffortConfig): Array<{
-    id: string;
-    value: string;
-}>;

package/dist/protocol/thinking.js

@@ -1,17 +0,0 @@
-// Reasoning effort / max mode → RequestedModel parameters
-/**
- * Build RequestedModel parameter list from a model's variant parameters
- * and optional overrides from providerOptions.
- */
-export function buildRequestedModelParams(variantParameters, options) {
-    // Start with variant's parameters as base
-    const params = variantParameters.map((p) => ({ ...p }));
-    // Override effort if specified
-    if (options?.reasoningEffort) {
-        const effortIdx = params.findIndex((p) => p.id === "effort" || p.id === "reasoning");
-        if (effortIdx >= 0) {
-            params[effortIdx] = { ...params[effortIdx], value: options.reasoningEffort };
-        }
-    }
-    return params;
-}