cursor-opencode-provider 0.7.6 → 0.8.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cursor-opencode-provider",
-  "version": "0.7.6",
+  "version": "0.8.1",
   "description": "Use Cursor subscription models from OpenCode via Cursor's Connect-RPC agent protocol",
   "type": "module",
   "license": "MIT",
@@ -70,7 +70,8 @@
     "LICENSE",
     "DISCLAIMER.md",
     "SECURITY.md",
-    "README.md"
+    "README.md",
+    "CHANGELOG.md"
   ],
   "scripts": {
     "build": "tsc",

package/dist/context/agents.d.ts

@@ -1,12 +0,0 @@
-export type CollectedAgent = {
-    fullPath: string;
-    name: string;
-    description: string;
-    prompt: string;
-};
-/**
- * Custom agents from the active OpenCode-compatible config roots. A host bridge may
- * install a host-neutral bridge before loading this module; without one this
- * remains the direct OpenCode discovery path.
- */
-export declare function collectAgents(workspaceRoot: string): Promise<CollectedAgent[]>;

package/dist/context/agents.js

@@ -1,136 +0,0 @@
-import { readdir, readFile, realpath, stat } from "node:fs/promises";
-import path from "node:path";
-import { opencodeGlobalConfigDirs, opencodeProjectConfigDirs } from "./paths.js";
-async function exists(p) {
-    try {
-        await stat(p);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function parseAgentMarkdown(raw, fallbackName) {
-    let name = fallbackName;
-    let description = "";
-    let body = raw;
-    if (raw.startsWith("---")) {
-        const end = raw.indexOf("\n---", 3);
-        if (end >= 0) {
-            const fm = raw.slice(3, end).trim();
-            body = raw.slice(end + 4).replace(/^\n/, "");
-            for (const line of fm.split("\n")) {
-                const m = line.match(/^(\w+):\s*(.*)$/);
-                if (!m)
-                    continue;
-                let val = m[2].trim();
-                if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith("'") && val.endsWith("'"))) {
-                    val = val.slice(1, -1);
-                }
-                if (m[1] === "name")
-                    name = val;
-                if (m[1] === "description")
-                    description = val;
-            }
-        }
-    }
-    return { name, description, prompt: body.slice(0, 20_000) };
-}
-function uniquePaths(paths) {
-    const seen = new Set();
-    return paths.filter((value) => {
-        const normalized = path.resolve(value);
-        if (seen.has(normalized))
-            return false;
-        seen.add(normalized);
-        return true;
-    });
-}
-/**
- * Read one host config root's `agent/` and `agents/` trees. Host loaders use
- * both spellings and recurse through nested markdown files. Directory symlinks
- * are followed with realpath cycle detection, matching host behavior without
- * allowing a symlink loop to hang context construction.
- */
-async function scanAgentRoot(root, out) {
-    if (!(await exists(root)))
-        return;
-    const visitedDirs = new Set();
-    const scanDir = async (dir, relativePrefix) => {
-        let canonical;
-        try {
-            canonical = await realpath(dir);
-        }
-        catch {
-            return;
-        }
-        if (visitedDirs.has(canonical))
-            return;
-        visitedDirs.add(canonical);
-        let entries;
-        try {
-            entries = await readdir(dir, { withFileTypes: true });
-            entries.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
-        }
-        catch {
-            return;
-        }
-        for (const entry of entries) {
-            const full = path.join(dir, entry.name);
-            const relative = path.join(relativePrefix, entry.name);
-            let isDirectory = entry.isDirectory();
-            let isFile = entry.isFile();
-            if (entry.isSymbolicLink()) {
-                try {
-                    const target = await stat(full);
-                    isDirectory = target.isDirectory();
-                    isFile = target.isFile();
-                }
-                catch {
-                    continue;
-                }
-            }
-            if (isDirectory) {
-                await scanDir(full, relative);
-                continue;
-            }
-            if (!isFile || !entry.name.endsWith(".md"))
-                continue;
-            try {
-                const raw = await readFile(full, "utf-8");
-                const fallbackName = relative.replace(/\\/g, "/").replace(/\.md$/, "");
-                const parsed = parseAgentMarkdown(raw, fallbackName);
-                if (!out.has(parsed.name)) {
-                    out.set(parsed.name, {
-                        fullPath: path.resolve(full),
-                        name: parsed.name,
-                        description: parsed.description,
-                        prompt: parsed.prompt,
-                    });
-                }
-            }
-            catch {
-                /* skip unreadable or malformed files without failing context build */
-            }
-        }
-    };
-    // Scan singular before plural, then let root ordering establish host
-    // precedence. This is deterministic and mirrors the hosts' brace glob.
-    await scanDir(path.join(root, "agent"), "agent");
-    await scanDir(path.join(root, "agents"), "agents");
-}
-/**
- * Custom agents from the active OpenCode-compatible config roots. A host bridge may
- * install a host-neutral bridge before loading this module; without one this
- * remains the direct OpenCode discovery path.
- */
-export async function collectAgents(workspaceRoot) {
-    const out = new Map();
-    const roots = uniquePaths([
-        ...opencodeProjectConfigDirs(workspaceRoot),
-        ...opencodeGlobalConfigDirs(),
-    ]);
-    for (const root of roots)
-        await scanAgentRoot(root, out);
-    return [...out.values()];
-}

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 { 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 = error instanceof Error ? error.message : String(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();
-}