cursor-opencode-provider 0.2.3 → 0.2.5

package/dist/models.d.ts

@@ -31,6 +31,11 @@ export type ModelCache = {
     /** Absent or mismatched → treat cache as stale (forces AvailableModels refetch). */
     schemaVersion?: number;
 };
+export declare class CursorVariantSelectionError extends Error {
+    constructor(message: string);
+}
+export declare function normalizeModelParameterValues(value: unknown): ModelParameterValue[] | null;
+export declare function normalizeModelCache(value: unknown): ModelCache | null;
 /**
  * Read only the dedicated variant payload generated by the plugin. OpenCode
  * merges model, agent, and variant options into one providerOptions namespace;
@@ -41,6 +46,7 @@ export declare function extractCursorVariantParameters(providerOptions: Record<s
 export declare function resolveCursorWireModelId(providerOptions: Record<string, unknown> | undefined, fallback: string): string;
 /** True when resolved params select the long-context (1m) tier. */
 export declare function paramsImplyMaxMode(params: ModelParameterValue[]): boolean;
+export declare function parseCursorContextLimit(value: unknown): number | undefined;
 export declare function isCacheFresh(cache: ModelCache, ttlMs?: number): boolean;
 export declare function cacheFilePath(cacheDir: string): string;
 export declare function readCache(cacheDir: string): Promise<ModelCache | null>;
@@ -68,6 +74,7 @@ export declare function fetchModels(token: string, options?: {
     baseURL?: string;
     headers?: Record<string, string>;
 }): Promise<ModelInfo[]>;
+export declare function refreshModelCache(cacheDir: string, fetcher: () => Promise<ModelInfo[]>): Promise<ModelInfo[]>;
 export declare function discoverModels(token: string, cacheDir: string, options?: {
     baseURL?: string;
     headers?: Record<string, string>;

package/dist/models.js

@@ -1,13 +1,158 @@
 import { MODEL_CACHE_FILE, MODEL_CACHE_SCHEMA_VERSION, MODEL_CACHE_TTL_MS } from "./shared.js";
 import { unaryAvailableModels } from "./transport/connect.js";
 import { buildRequestedModelParams } from "./protocol/thinking.js";
-import { readFile, writeFile, mkdir } from "node:fs/promises";
-import { existsSync } from "node:fs";
+import { mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
 import path from "node:path";
 /** Dedicated OpenCode provider-option key for a selected Cursor variant. */
 export const CURSOR_VARIANT_PARAMETERS_KEY = "cursorVariantParameters";
 /** Real Cursor model id used when an OpenCode entry has a synthetic id. */
 export const CURSOR_WIRE_MODEL_ID_KEY = "cursorModelId";
+export class CursorVariantSelectionError extends Error {
+    constructor(message) {
+        super(`Cursor variant selection ${message}`);
+        this.name = "CursorVariantSelectionError";
+    }
+}
+function isPlainRecord(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function optionalString(record, names) {
+    for (const name of names) {
+        if (!Object.hasOwn(record, name))
+            continue;
+        if (record[name] === undefined)
+            return undefined;
+        return typeof record[name] === "string" ? record[name] : null;
+    }
+    return undefined;
+}
+function optionalBoolean(record, names) {
+    for (const name of names) {
+        if (!Object.hasOwn(record, name))
+            continue;
+        if (record[name] === undefined)
+            return undefined;
+        return typeof record[name] === "boolean" ? record[name] : null;
+    }
+    return undefined;
+}
+function optionalPositiveNumber(record, names) {
+    for (const name of names) {
+        if (!Object.hasOwn(record, name))
+            continue;
+        const value = record[name];
+        if (value === undefined)
+            return undefined;
+        return typeof value === "number" && Number.isFinite(value) && value > 0
+            ? value
+            : null;
+    }
+    return undefined;
+}
+export function normalizeModelParameterValues(value) {
+    if (!Array.isArray(value))
+        return null;
+    const parameters = [];
+    for (const parameter of value) {
+        if (!isPlainRecord(parameter))
+            return null;
+        if (!isNonEmptyString(parameter.id) || typeof parameter.value !== "string")
+            return null;
+        parameters.push({ id: parameter.id, value: parameter.value });
+    }
+    return parameters;
+}
+function normalizeVariant(value, fallbackName) {
+    if (!isPlainRecord(value))
+        return null;
+    const parameters = normalizeModelParameterValues(value.parameterValues ?? value.parameter_values ?? []);
+    if (!parameters)
+        return null;
+    const key = optionalString(value, ["key"]);
+    const displayName = optionalString(value, ["displayName", "display_name"]);
+    const isDefaultNonMax = optionalBoolean(value, ["isDefaultNonMax", "isDefaultNonMaxConfig", "is_default_non_max_config"]);
+    const isDefaultMax = optionalBoolean(value, ["isDefaultMax", "isDefaultMaxConfig", "is_default_max_config"]);
+    if (key === null ||
+        displayName === null ||
+        isDefaultNonMax === null ||
+        isDefaultMax === null) {
+        return null;
+    }
+    if ((key !== undefined && !isNonEmptyString(key)) ||
+        (displayName !== undefined && !isNonEmptyString(displayName))) {
+        return null;
+    }
+    return {
+        key: key ?? fallbackName,
+        displayName: displayName ?? fallbackName,
+        parameterValues: parameters,
+        isDefaultNonMax: isDefaultNonMax ?? false,
+        isDefaultMax: isDefaultMax ?? false,
+    };
+}
+function normalizeModelInfo(value) {
+    if (!isPlainRecord(value) || !isNonEmptyString(value.id))
+        return null;
+    const rawVariants = value.variants ?? [];
+    if (!Array.isArray(rawVariants))
+        return null;
+    const variants = rawVariants.map((variant) => normalizeVariant(variant, value.id));
+    if (variants.some((variant) => variant === null))
+        return null;
+    const displayName = optionalString(value, ["displayName", "display_name"]);
+    const family = optionalString(value, ["family"]);
+    const supportsThinking = optionalBoolean(value, ["supportsThinking", "supports_thinking"]);
+    const supportsAgent = optionalBoolean(value, ["supportsAgent", "supports_agent"]);
+    const supportsMaxMode = optionalBoolean(value, ["supportsMaxMode", "supports_max_mode"]);
+    const maxContext = optionalPositiveNumber(value, ["maxContext", "contextTokenLimit", "context_token_limit"]);
+    const maxContextForMaxMode = optionalPositiveNumber(value, ["maxContextForMaxMode", "contextTokenLimitForMaxMode", "context_token_limit_for_max_mode"]);
+    if (displayName === null ||
+        family === null ||
+        supportsThinking === null ||
+        supportsAgent === null ||
+        supportsMaxMode === null ||
+        maxContext === null ||
+        maxContextForMaxMode === null) {
+        return null;
+    }
+    return {
+        id: value.id,
+        ...(displayName === undefined ? {} : { displayName }),
+        ...(family === undefined ? {} : { family }),
+        ...(supportsThinking === undefined ? {} : { supportsThinking }),
+        ...(supportsAgent === undefined ? {} : { supportsAgent }),
+        ...(maxContext === undefined ? {} : { maxContext }),
+        ...(maxContextForMaxMode === undefined ? {} : { maxContextForMaxMode }),
+        ...(supportsMaxMode === undefined ? {} : { supportsMaxMode }),
+        variants: variants,
+    };
+}
+export function normalizeModelCache(value) {
+    if (!isPlainRecord(value) || !Array.isArray(value.models))
+        return null;
+    if (typeof value.fetchedAt !== "number" || !Number.isFinite(value.fetchedAt))
+        return null;
+    if (value.schemaVersion !== undefined &&
+        (!Number.isSafeInteger(value.schemaVersion) || value.schemaVersion < 0)) {
+        return null;
+    }
+    const models = value.models.map(normalizeModelInfo);
+    if (models.some((model) => model === null))
+        return null;
+    return {
+        models: models,
+        fetchedAt: value.fetchedAt,
+        ...(value.schemaVersion === undefined
+            ? {}
+            : { schemaVersion: value.schemaVersion }),
+    };
+}
 /**
  * Read only the dedicated variant payload generated by the plugin. OpenCode
  * merges model, agent, and variant options into one providerOptions namespace;
@@ -15,17 +160,12 @@ export const CURSOR_WIRE_MODEL_ID_KEY = "cursorModelId";
  * onto the wire.
  */
 export function extractCursorVariantParameters(providerOptions) {
-    const raw = providerOptions?.[CURSOR_VARIANT_PARAMETERS_KEY];
-    if (!Array.isArray(raw) || raw.length === 0)
+    if (!providerOptions || !Object.hasOwn(providerOptions, CURSOR_VARIANT_PARAMETERS_KEY)) {
         return undefined;
-    const params = [];
-    for (const item of raw) {
-        if (!item || typeof item !== "object" || Array.isArray(item))
-            return undefined;
-        const { id, value } = item;
-        if (typeof id !== "string" || typeof value !== "string")
-            return undefined;
-        params.push({ id, value });
+    }
+    const params = normalizeModelParameterValues(providerOptions[CURSOR_VARIANT_PARAMETERS_KEY]);
+    if (!params) {
+        throw new CursorVariantSelectionError("is malformed: cursorVariantParameters must be a parameter array");
     }
     return params;
 }
@@ -35,7 +175,8 @@ export function resolveCursorWireModelId(providerOptions, fallback) {
 }
 /** True when resolved params select the long-context (1m) tier. */
 export function paramsImplyMaxMode(params) {
-    return params.some((p) => p.id === "context" && p.value === "1m");
+    return params.some((parameter) => parameter.id === "context" &&
+        parseCursorContextLimit(parameter.value) === 1_000_000);
 }
 // Cursor encodes a model's context window as a variant parameter `id: "context"`
 // whose value is a tier string — the same 200k / 272k / 300k / 1m the IDE's
@@ -44,21 +185,30 @@ export function paramsImplyMaxMode(params) {
 // `context_token_limit` (#15) / `context_token_limit_for_max_mode` (#16) are
 // also defined on AvailableModel but the server often leaves them empty — the
 // variant param is the primary source (request flags may still populate them).
-const CONTEXT_TIER_TO_TOKENS = {
-    "200k": 200_000,
-    "272k": 272_000,
-    "300k": 300_000,
-    "1m": 1_000_000,
-};
+export function parseCursorContextLimit(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const text = value.trim();
+    const match = /^(\d+(?:\.\d+)?)\s*([km])$/i.exec(text);
+    if (match) {
+        const multiplier = match[2].toLowerCase() === "k" ? 1_000 : 1_000_000;
+        const limit = Number(match[1]) * multiplier;
+        return Number.isSafeInteger(limit) && limit > 0 ? limit : undefined;
+    }
+    const numeric = Number(text);
+    return Number.isSafeInteger(numeric) && numeric > 0 ? numeric : undefined;
+}
 function variantContextTokens(v) {
     const raw = v?.parameterValues.find((p) => p.id === "context")?.value;
-    if (!raw)
-        return undefined;
-    const mapped = CONTEXT_TIER_TO_TOKENS[raw];
-    if (mapped !== undefined)
-        return mapped;
-    const n = Number(raw);
-    return Number.isFinite(n) && n > 0 ? n : undefined;
+    return parseCursorContextLimit(raw);
+}
+function isLongContextVariant(v) {
+    return variantContextTokens(v) === 1_000_000;
+}
+function positiveNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0
+        ? value
+        : undefined;
 }
 // ── Cache helpers ──
 export function isCacheFresh(cache, ttlMs = MODEL_CACHE_TTL_MS) {
@@ -72,43 +222,66 @@ export function cacheFilePath(cacheDir) {
 export async function readCache(cacheDir) {
     const filePath = cacheFilePath(cacheDir);
     try {
-        if (!existsSync(filePath))
-            return null;
         const data = await readFile(filePath, "utf-8");
-        return JSON.parse(data);
+        return normalizeModelCache(JSON.parse(data));
     }
     catch {
         return null;
     }
 }
 export async function writeCache(cacheDir, cache) {
+    const normalized = normalizeModelCache(cache);
+    if (!normalized)
+        throw new Error("Refusing to write an invalid Cursor model cache");
     const filePath = cacheFilePath(cacheDir);
-    await mkdir(path.dirname(filePath), { recursive: true });
-    await writeFile(filePath, JSON.stringify(cache, null, 2), "utf-8");
+    const directory = path.dirname(filePath);
+    const tempPath = path.join(directory, `.${MODEL_CACHE_FILE}.${process.pid}.${crypto.randomUUID()}.tmp`);
+    await mkdir(directory, { recursive: true });
+    try {
+        await writeFile(tempPath, JSON.stringify(normalized, null, 2), "utf-8");
+        await rename(tempPath, filePath);
+    }
+    finally {
+        await unlink(tempPath).catch(() => { });
+    }
 }
 // ── Map live API response to ModelInfo[] ──
+function apiBoolean(record, names) {
+    const value = optionalBoolean(record, names);
+    if (value === null)
+        throw new Error(`AvailableModels returned a non-boolean ${names[0]}`);
+    return value ?? false;
+}
 export function mapAvailableModelsResponse(raw) {
     const entries = raw.models ?? [];
     const models = [];
     for (const entry of entries) {
+        if (!isPlainRecord(entry))
+            continue;
         const e = entry;
         const name = e.name;
-        if (!name)
+        if (!isNonEmptyString(name))
             continue;
         const variants = [];
-        const rawVariants = (e.variants ?? []);
+        const rawVariants = e.variants ?? [];
+        if (!Array.isArray(rawVariants)) {
+            throw new Error(`AvailableModels returned invalid variants for ${name}`);
+        }
         for (const v of rawVariants) {
+            if (!isPlainRecord(v)) {
+                throw new Error(`AvailableModels returned an invalid variant for ${name}`);
+            }
             const rawParams = (v.parameterValues ?? v.parameter_values ?? []);
-            const parameterValues = rawParams.map((p) => ({
-                id: p.id,
-                value: String(p.value ?? ""),
-            }));
+            const parameterValues = normalizeModelParameterValues(rawParams);
+            if (!parameterValues) {
+                throw new Error(`AvailableModels returned invalid parameter values for ${name}`);
+            }
             variants.push({
                 key: name,
                 parameterValues,
                 displayName: (v.displayName ?? v.display_name ?? name),
-                isDefaultNonMax: !!(v.isDefaultNonMaxConfig ?? v.is_default_non_max_config ?? false),
-                isDefaultMax: !!(v.isDefaultMaxConfig ?? v.is_default_max_config ?? false),
+                isDefaultNonMax: apiBoolean(v, ["isDefaultNonMaxConfig", "is_default_non_max_config"]),
+                isDefaultMax: apiBoolean(v, ["isDefaultMaxConfig", "is_default_max_config"]),
             });
         }
         // Derive the context window from the variant `context` param (primary
@@ -117,17 +290,18 @@ export function mapAvailableModelsResponse(raw) {
         // Prefer a non-1m context when isDefaultNonMax is missing so a leading
         // max-mode variant cannot inflate the base window.
         const variantBaseContext = variantContextTokens(variants.find((v) => v.isDefaultNonMax)) ??
-            variantContextTokens(variants.find((v) => v.parameterValues.some((p) => p.id === "context" && p.value !== "1m"))) ??
+            variantContextTokens(variants.find((v) => variantContextTokens(v) !== 1_000_000)) ??
             variantContextTokens(variants.find((v) => v.parameterValues.some((p) => p.id === "context")));
         const variantMaxContext = variantContextTokens(variants.find((v) => v.isDefaultMax));
         models.push({
             id: name,
             displayName: (e.clientDisplayName ?? e.client_display_name ?? name),
-            supportsThinking: !!(e.supportsThinking ?? e.supports_thinking ?? false),
-            supportsAgent: !!(e.supportsAgent ?? e.supports_agent ?? false),
-            maxContext: (variantBaseContext ?? e.contextTokenLimit ?? e.context_token_limit ?? undefined),
-            maxContextForMaxMode: (variantMaxContext ?? e.contextTokenLimitForMaxMode ?? e.context_token_limit_for_max_mode ?? undefined),
-            supportsMaxMode: !!(e.supportsMaxMode ?? e.supports_max_mode ?? false),
+            supportsThinking: apiBoolean(e, ["supportsThinking", "supports_thinking"]),
+            supportsAgent: apiBoolean(e, ["supportsAgent", "supports_agent"]),
+            maxContext: variantBaseContext ?? positiveNumber(e.contextTokenLimit ?? e.context_token_limit),
+            maxContextForMaxMode: variantMaxContext ??
+                positiveNumber(e.contextTokenLimitForMaxMode ?? e.context_token_limit_for_max_mode),
+            supportsMaxMode: apiBoolean(e, ["supportsMaxMode", "supports_max_mode"]),
             variants,
         });
     }
@@ -148,34 +322,34 @@ export function mapAvailableModelsResponse(raw) {
  * so the picked values are already isolated and can be matched verbatim.
  */
 export function resolveVariantParameters(model, opts = {}) {
-    const picked = opts.picked?.length ? opts.picked.map((p) => ({ ...p })) : undefined;
+    const picked = opts.picked?.map((p) => ({ ...p }));
     if (!model || model.variants.length === 0) {
-        if (picked?.length)
-            return picked;
+        if (picked !== undefined) {
+            throw new CursorVariantSelectionError(`is stale: model ${JSON.stringify(model?.id ?? "unknown")} has no cached variants`);
+        }
         return opts.reasoningEffort ? [{ id: "effort", value: opts.reasoningEffort }] : [];
     }
     const effortOf = (v) => v.parameterValues.find((p) => p.id === "effort" || p.id === "reasoning")?.value;
     const isFast = (v) => v.parameterValues.find((p) => p.id === "fast")?.value === "true";
-    const contextOf = (v) => v.parameterValues.find((p) => p.id === "context")?.value;
-    const isMaxVariant = (v) => v.isDefaultMax || contextOf(v) === "1m";
+    const isMaxVariant = (v) => v.isDefaultMax || isLongContextVariant(v);
     const wantMax = opts.maxMode ?? false;
     // Non-fast pool for hint-based resolution only. Exact `picked` matching
     // searches all variants so Fast selections are not silently dropped.
     const pool = model.variants.filter((v) => !isFast(v));
     const scoped = pool.length > 0 ? pool : model.variants;
     // 1. Variant explicitly picked by opencode (verbatim — preserves context, fast, …).
-    if (picked?.length) {
-        const signature = new Set(picked.map((p) => `${p.id}=${p.value}`));
-        const exact = model.variants.find((v) => v.parameterValues.every((p) => signature.has(`${p.id}=${p.value}`)) &&
-            signature.size === v.parameterValues.length);
+    if (picked !== undefined) {
+        const pickedById = new Map(picked.map((parameter) => [parameter.id, parameter.value]));
+        const exact = model.variants.find((v) => v.parameterValues.length === picked.length &&
+            pickedById.size === picked.length &&
+            v.parameterValues.every((parameter) => pickedById.get(parameter.id) === parameter.value));
         if (exact) {
             return buildRequestedModelParams(exact.parameterValues, {
                 reasoningEffort: opts.reasoningEffort,
                 maxMode: wantMax,
             });
         }
-        // Unmatched: forward the stripped pick so the TUI choice is not discarded.
-        return picked;
+        throw new CursorVariantSelectionError(`is stale for model ${JSON.stringify(model.id)}: its exact parameter tuple is unavailable`);
     }
     // When maxMode is requested, prefer max-tier variants for effort matching
     // so "high + max" lands on 1m high rather than the first 300k high.
@@ -193,7 +367,7 @@ export function resolveVariantParameters(model, opts = {}) {
     }
     // 3. Max-mode hint → prefer the default max variant (1m context).
     if (wantMax) {
-        const max = scoped.find((v) => v.isDefaultMax) ?? scoped.find((v) => contextOf(v) === "1m");
+        const max = scoped.find((v) => v.isDefaultMax) ?? scoped.find(isLongContextVariant);
         if (max)
             return buildRequestedModelParams(max.parameterValues, { maxMode: true });
     }
@@ -209,17 +383,37 @@ export async function fetchModels(token, options = {}) {
     const raw = await unaryAvailableModels(token, options);
     return mapAvailableModelsResponse(raw);
 }
+const refreshesByDirectory = new Map();
+export async function refreshModelCache(cacheDir, fetcher) {
+    const key = path.resolve(cacheDir);
+    const existing = refreshesByDirectory.get(key);
+    if (existing)
+        return existing;
+    const refresh = (async () => {
+        const models = await fetcher();
+        await writeCache(cacheDir, {
+            models,
+            fetchedAt: Date.now(),
+            schemaVersion: MODEL_CACHE_SCHEMA_VERSION,
+        });
+        return models;
+    })();
+    refreshesByDirectory.set(key, refresh);
+    try {
+        return await refresh;
+    }
+    finally {
+        if (refreshesByDirectory.get(key) === refresh)
+            refreshesByDirectory.delete(key);
+    }
+}
 export async function discoverModels(token, cacheDir, options = {}) {
     const cached = await readCache(cacheDir);
+    const refresh = () => refreshModelCache(cacheDir, () => fetchModels(token, options));
     // Cache is fresh → return it; refresh in background
     if (cached && isCacheFresh(cached)) {
         // Background refresh (fire and forget)
-        fetchModels(token, options)
-            .then((models) => writeCache(cacheDir, {
-            models,
-            fetchedAt: Date.now(),
-            schemaVersion: MODEL_CACHE_SCHEMA_VERSION,
-        }))
+        void refresh()
             .catch(() => {
             /* background refresh failure is non-fatal */
         });
@@ -228,26 +422,12 @@ export async function discoverModels(token, cacheDir, options = {}) {
     // Cache exists but expired → try fetch, serve stale on failure
     if (cached) {
         try {
-            const models = await fetchModels(token, options);
-            const newCache = {
-                models,
-                fetchedAt: Date.now(),
-                schemaVersion: MODEL_CACHE_SCHEMA_VERSION,
-            };
-            await writeCache(cacheDir, newCache);
-            return models;
+            return await refresh();
         }
         catch {
             return cached.models;
         }
     }
     // No cache → must fetch
-    const models = await fetchModels(token, options);
-    const newCache = {
-        models,
-        fetchedAt: Date.now(),
-        schemaVersion: MODEL_CACHE_SCHEMA_VERSION,
-    };
-    await writeCache(cacheDir, newCache);
-    return models;
+    return refresh();
 }

package/dist/plugin.js

@@ -1,9 +1,11 @@
 import { CURSOR_COMPACTION_OPTION, CURSOR_PROVIDER_ID, CURSOR_WEBSITE_HOST, CURSOR_API_HOST } from "./shared.js";
-import { pollForTokens, exchangeApiKey, refreshAccessToken, isExpiringSoon, generatePkceParams, generatePkceChallenge, buildLoginUrl, decodeJwtPayload } from "./auth.js";
-import { CURSOR_VARIANT_PARAMETERS_KEY, CURSOR_WIRE_MODEL_ID_KEY, readCache, discoverModels, isCacheFresh } from "./models.js";
+import { pollForTokens, exchangeApiKey, refreshAccessToken, isExpiringSoon, generatePkceParams, generatePkceChallenge, buildLoginUrl, decodeJwtExpiryMs } from "./auth.js";
+import { CURSOR_VARIANT_PARAMETERS_KEY, CURSOR_WIRE_MODEL_ID_KEY, readCache, discoverModels, isCacheFresh, parseCursorContextLimit } from "./models.js";
 import { opencodeGlobalCacheDir } from "./context/paths.js";
 import { readStoredAuth } from "./context/auth-store.js";
 import { resolveAgentUrl } from "./agent-url.js";
+import { captureCursorShellResult, cursorShellOriginalCommand, prepareCursorShellArgs, } from "./shell-timeout.js";
+import { sessionActivity } from "./activity.js";
 const MODULE_URL = new URL("./index.js", import.meta.url).href;
 /**
  * Strip characters and markup that break rendering in the OpenCode TUI/GUI from
@@ -85,7 +87,7 @@ function modelInfoVariants(mi, variants) {
     return entries;
 }
 function isLongContextVariant(v) {
-    return v.parameterValues.some((p) => p.id === "context" && p.value === "1m");
+    return v.parameterValues.some((p) => p.id === "context" && parseCursorContextLimit(p.value) === 1_000_000);
 }
 function variantsForTier(mi, tier) {
     return mi.variants.filter((v) => isLongContextVariant(v) === (tier === "long"));
@@ -273,7 +275,7 @@ export async function CursorPlugin(input) {
                     type: "oauth",
                     access: newTokens.accessToken,
                     refresh: newTokens.refreshToken,
-                    expires: decodeExpFromJwt(newTokens.accessToken),
+                    expires: decodeJwtExpiryMs(newTokens.accessToken) ?? Date.now(),
                     ...(extras.accountId !== undefined ? { accountId: extras.accountId } : {}),
                     ...(extras.enterpriseUrl !== undefined ? { enterpriseUrl: extras.enterpriseUrl } : {}),
                 });
@@ -311,6 +313,37 @@ export async function CursorPlugin(input) {
         return cached?.models.length ? modelsToConfig(cached.models) : {};
     }
     return {
+        async event({ event }) {
+            switch (event.type) {
+                case "session.created":
+                    sessionActivity.linkSession(event.properties.info.id, event.properties.info.parentID);
+                    sessionActivity.recordActivity(event.properties.info.id);
+                    break;
+                case "session.updated":
+                    sessionActivity.linkSession(event.properties.info.id, event.properties.info.parentID);
+                    break;
+                case "session.deleted":
+                    sessionActivity.removeSession(event.properties.info.id);
+                    break;
+                case "message.updated":
+                    sessionActivity.recordActivity(event.properties.info.sessionID);
+                    break;
+                case "message.part.updated":
+                    sessionActivity.recordActivity(event.properties.part.sessionID);
+                    break;
+            }
+        },
+        async "tool.execute.before"(hookInput, output) {
+            if (hookInput.tool !== "bash")
+                return;
+            prepareCursorShellArgs(hookInput.callID, output.args);
+        },
+        async "tool.execute.after"(hookInput, output) {
+            if (hookInput.tool !== "bash")
+                return;
+            output.title = cursorShellOriginalCommand(hookInput.callID) ?? output.title;
+            output.output = captureCursorShellResult(hookInput.callID, output.output, output.metadata);
+        },
         async "chat.params"(hookInput, output) {
             if (hookInput.model.providerID !== CURSOR_PROVIDER_ID)
                 return;
@@ -364,7 +397,7 @@ export async function CursorPlugin(input) {
                                     provider: CURSOR_PROVIDER_ID,
                                     access: result.accessToken,
                                     refresh: result.refreshToken,
-                                    expires: decodeExpFromJwt(result.accessToken),
+                                    expires: decodeJwtExpiryMs(result.accessToken) ?? Date.now(),
                                 };
                             },
                         };
@@ -436,9 +469,3 @@ export async function CursorPlugin(input) {
         },
     };
 }
-function decodeExpFromJwt(jwt) {
-    const payload = decodeJwtPayload(jwt);
-    if (payload && typeof payload.exp === "number")
-        return payload.exp * 1000;
-    return Date.now() + 3600_000;
-}

package/dist/protocol/exec-variants.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Canonical Cursor agent.v1 exec request/result pairs.
+ *
+ * Source of truth: Cursor CLI generated `agent/v1/exec_pb.js` plus the
+ * registrations in `agent-exec/dist/index.js`. Most request/result variants
+ * share a field number; Pi requests deliberately use result field +1.
+ *
+ * `handling` describes this provider, not the Cursor CLI:
+ * - opencode-tool: emitted through an advertised OpenCode tool
+ * - provider-control: answered directly on the held-open Run stream
+ * - unsupported: known Cursor-native capability with no safe AI SDK bridge
+ */
+export type CursorExecHandling = "opencode-tool" | "provider-control" | "unsupported";
+export type CursorExecVariant = {
+    requestField: number;
+    requestName: string;
+    resultField: number;
+    resultName: string;
+    handling: CursorExecHandling;
+};
+export declare const CURSOR_EXEC_VARIANTS: readonly CursorExecVariant[];
+export declare function cursorExecVariantByRequestField(field: number): CursorExecVariant | undefined;
+export declare function cursorExecVariantByRequestName(name: string): CursorExecVariant | undefined;
+export declare function describeCursorExecVariant(field: number | undefined): string;