@meetopenbot/cursor 0.0.1 → 0.0.3

package/dist/format.js

@@ -93,7 +93,19 @@ const formatCloudStatus = (status, message, config) => {
             return message ? truncate(message) : undefined;
     }
 };
-/** Map Cursor SDK stream events to user-visible output chunks. */
+export const formatToolResult = (result) => {
+    if (result == null)
+        return '';
+    if (typeof result === 'string')
+        return result;
+    try {
+        return JSON.stringify(result, null, 2);
+    }
+    catch {
+        return String(result);
+    }
+};
+/** Map Cursor SDK stream events to structured output chunks. */
 export const formatCursorEvent = (event, state, config) => {
     switch (event.type) {
         case 'assistant': {
@@ -107,27 +119,44 @@ export const formatCursorEvent = (event, state, config) => {
         }
         case 'tool_call': {
             if (event.status === 'running') {
-                return formatToolStart(event.name, event.args);
-            }
-            if (event.status === 'error') {
-                const details = JSON.stringify(event);
-                return `Tool **${event.name}** failed. Details: \`${details}\``;
+                return {
+                    type: 'tool_start',
+                    toolCallId: event.call_id,
+                    toolName: event.name,
+                    args: event.args,
+                    statusLine: formatToolStart(event.name, event.args),
+                };
             }
-            return undefined;
+            const isError = event.status === 'error';
+            return {
+                type: 'tool_end',
+                toolCallId: event.call_id,
+                toolName: event.name,
+                args: event.args,
+                result: event.result,
+                isError,
+                statusLine: isError
+                    ? `Tool **${event.name}** failed.`
+                    : formatToolStart(event.name, event.args).replace(/…$/, ''),
+            };
         }
         case 'status': {
             if (event.status === 'ERROR') {
                 const details = JSON.stringify(event);
                 const isCloud = config?.runtime === 'cloud';
                 const prefix = isCloud ? 'Cloud run failed' : 'Local run failed';
-                return `**Cursor error:** ${prefix}. Event details: \`${details}\``;
+                return {
+                    type: 'text',
+                    content: `**Cursor error:** ${prefix}. Event details: \`${details}\``,
+                };
             }
-            return formatCloudStatus(event.status, event.message, config);
+            const statusLine = formatCloudStatus(event.status, event.message, config);
+            return statusLine ? { type: 'status', statusLine } : undefined;
         }
         case 'task': {
             if (!event.text?.trim())
                 return undefined;
-            return truncate(event.text);
+            return { type: 'status', statusLine: truncate(event.text) };
         }
         default:
             return undefined;

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import type { Plugin } from '@meetopenbot/plugin-sdk';
+declare const plugin: Plugin;
+export { plugin };
+export default plugin;

package/dist/index.js

@@ -1,7 +1,7 @@
-import { agentOutput, definePlugin, shouldHandleInvoke, } from '@meetopenbot/plugin-sdk';
+import { agentOutput, buildDiffWidget, definePlugin, diffFileFromMutationTool, resolveRunDiffFiles, shouldHandleInvoke, snapshotWorkspace, toolTraceWidget, uiWidget, } from '@meetopenbot/plugin-sdk';
 import { CURSOR_API_KEY_ENV_VAR, resolveConfig, } from './config.js';
-import { formatCursorError } from './format.js';
-import { getOrCreateCursorAgent } from './session.js';
+import { formatCursorError, formatToolResult } from './format.js';
+import { getOrCreateCursorAgent, StaleAgentSessionError } from './session.js';
 import { streamCursorPrompt } from './stream.js';
 export default definePlugin({
     id: 'cursor',
@@ -107,17 +107,123 @@ export default definePlugin({
                 return;
             }
             try {
-                const { agent } = await getOrCreateCursorAgent({
+                let agentHandle = await getOrCreateCursorAgent({
                     config,
                     state: handlerCtx.state,
                     storage: context.storage,
                 });
-                for await (const chunk of streamCursorPrompt(agent, prompt, config)) {
-                    yield agentOutput({
-                        agentId: context.agentId,
-                        content: chunk,
-                        threadId,
+                const snapshot = snapshotWorkspace(config.cwd);
+                const runTurn = async function* (wasResumed) {
+                    const toolInfoMap = new Map();
+                    const changedFiles = new Map();
+                    let fullTextContent = '';
+                    for await (const chunk of streamCursorPrompt(agentHandle.agent, prompt, config, wasResumed)) {
+                        switch (chunk.type) {
+                            case 'tool_start':
+                                toolInfoMap.set(chunk.toolCallId, {
+                                    statusLine: chunk.statusLine,
+                                    args: chunk.args,
+                                });
+                                yield uiWidget({
+                                    agentId: context.agentId,
+                                    threadId,
+                                    widget: toolTraceWidget({
+                                        widgetId: chunk.toolCallId,
+                                        groupId: 'cursor:tools',
+                                        title: chunk.statusLine,
+                                        body: `**Input**\n\`\`\`json\n${JSON.stringify(chunk.args ?? {}, null, 2)}\n\`\`\``,
+                                    }),
+                                });
+                                break;
+                            case 'tool_end': {
+                                const info = toolInfoMap.get(chunk.toolCallId);
+                                const args = chunk.args ?? info?.args;
+                                const inputMd = args
+                                    ? `**Input**\n\`\`\`json\n${JSON.stringify(args, null, 2)}\n\`\`\`\n\n`
+                                    : '';
+                                const outputMd = chunk.result != null
+                                    ? `**Output**\n${formatToolResult(chunk.result)}`
+                                    : '';
+                                yield uiWidget({
+                                    agentId: context.agentId,
+                                    threadId,
+                                    widget: toolTraceWidget({
+                                        widgetId: chunk.toolCallId,
+                                        groupId: 'cursor:tools',
+                                        title: chunk.statusLine || info?.statusLine || `Tool ${chunk.toolName} finished`,
+                                        body: inputMd + outputMd,
+                                        state: chunk.isError ? 'error' : 'submitted',
+                                    }),
+                                });
+                                if (!chunk.isError) {
+                                    const file = diffFileFromMutationTool({
+                                        toolName: chunk.toolName,
+                                        input: args,
+                                        result: chunk.result,
+                                    });
+                                    if (file)
+                                        changedFiles.set(file.path, file);
+                                }
+                                break;
+                            }
+                            case 'status':
+                                yield uiWidget({
+                                    agentId: context.agentId,
+                                    threadId,
+                                    widget: toolTraceWidget({
+                                        widgetId: `status-${Date.now()}`,
+                                        groupId: 'cursor:tools',
+                                        title: 'Status',
+                                        body: chunk.statusLine,
+                                    }),
+                                });
+                                break;
+                            case 'text':
+                                if (fullTextContent)
+                                    fullTextContent += '\n\n';
+                                fullTextContent += chunk.content;
+                                break;
+                        }
+                    }
+                    if (fullTextContent.trim()) {
+                        yield agentOutput({
+                            agentId: context.agentId,
+                            content: fullTextContent.trim(),
+                            threadId,
+                        });
+                    }
+                    const diff = buildDiffWidget({
+                        widgetId: `cursor-diff:${threadId ?? 'run'}:${Date.now()}`,
+                        files: resolveRunDiffFiles({
+                            snapshot,
+                            fallback: changedFiles.values(),
+                        }),
                     });
+                    if (diff) {
+                        yield uiWidget({
+                            agentId: context.agentId,
+                            threadId,
+                            widget: diff,
+                        });
+                    }
+                };
+                try {
+                    yield* runTurn(agentHandle.wasResumed);
+                }
+                catch (streamErr) {
+                    if (streamErr instanceof StaleAgentSessionError) {
+                        console.warn(`[cursor-plugin] Detected stale resumed agent. Re-creating a fresh agent session...`);
+                        agentHandle = await getOrCreateCursorAgent({
+                            config,
+                            state: handlerCtx.state,
+                            storage: context.storage,
+                            forceNew: true,
+                        });
+                        yield* runTurn(agentHandle.wasResumed);
+                    }
+                    else {
+                        throw streamErr;
+                    }
                 }
             }
             catch (error) {

package/dist/session.js

@@ -2,6 +2,12 @@ import { Agent, } from '@cursor/sdk';
 import { buildModelSelection, } from './config.js';
 import { formatCursorError } from './format.js';
 import { persistCursorState, readPersistedState } from './state.js';
+export class StaleAgentSessionError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'StaleAgentSessionError';
+    }
+}
 const sessionCache = new Map();
 const buildSessionKey = (state) => state.threadId ? `${state.channelId}:${state.threadId}` : state.channelId;
 const buildAgentOptions = (config) => {
@@ -44,16 +50,33 @@ const resumeOptions = (config) => ({
 const createAgent = async (config) => Agent.create(buildAgentOptions(config));
 const resumeAgent = async (cursorAgentId, config) => Agent.resume(cursorAgentId, resumeOptions(config));
 export const getOrCreateCursorAgent = async (args) => {
-    const { config, state, storage } = args;
+    const { config, state, storage, forceNew } = args;
     const sessionKey = buildSessionKey(state);
-    const cached = sessionCache.get(sessionKey);
-    if (cached)
-        return cached;
-    const persisted = readPersistedState(state);
+    if (forceNew) {
+        const cached = sessionCache.get(sessionKey);
+        if (cached) {
+            try {
+                await cached.agent[Symbol.asyncDispose]();
+            }
+            catch (e) {
+                console.warn(`[cursor-plugin] Failed to dispose cached agent:`, e);
+            }
+            sessionCache.delete(sessionKey);
+        }
+        await persistCursorState(state, storage, { cursorAgentId: undefined });
+    }
+    else {
+        const cached = sessionCache.get(sessionKey);
+        if (cached)
+            return cached;
+    }
+    const persisted = forceNew ? {} : readPersistedState(state);
     let agent;
+    let wasResumed = false;
     if (persisted.cursorAgentId) {
         try {
             agent = await resumeAgent(persisted.cursorAgentId, config);
+            wasResumed = true;
         }
         catch (error) {
             console.warn(`[cursor-plugin] Failed to resume ${persisted.cursorAgentId}: ${formatCursorError(error)}`);
@@ -61,11 +84,12 @@ export const getOrCreateCursorAgent = async (args) => {
     }
     if (!agent) {
         agent = await createAgent(config);
+        wasResumed = false;
         if (agent.agentId !== persisted.cursorAgentId) {
             await persistCursorState(state, storage, { cursorAgentId: agent.agentId });
         }
     }
-    const handle = { agent, sessionKey };
+    const handle = { agent, sessionKey, wasResumed };
     sessionCache.set(sessionKey, handle);
     return handle;
 };

package/dist/state.js

@@ -2,7 +2,7 @@ const asRecord = (value) => value && typeof value === 'object' && !Array.isArray
     ? value
     : {};
 export const readPersistedState = (state) => {
-    const source = state.threadDetails?.state ?? state.channelDetails?.state;
+    const source = state.threadId ? state.threadDetails?.state : state.channelDetails?.state;
     const record = asRecord(source);
     return typeof record.cursorAgentId === 'string'
         ? { cursorAgentId: record.cursorAgentId }

package/dist/stream.js

@@ -1,7 +1,8 @@
 import { buildModelSelection } from './config.js';
-import { createStreamState, formatCursorEvent } from './format.js';
-/** Bridge Cursor SDK run events into an async generator of output chunks. */
-export async function* streamCursorPrompt(agent, prompt, config) {
+import { createStreamState, formatCursorEvent, } from './format.js';
+import { StaleAgentSessionError } from './session.js';
+/** Bridge Cursor SDK run events into an async generator of structured chunks. */
+export async function* streamCursorPrompt(agent, prompt, config, wasResumed) {
     const state = createStreamState();
     const pending = [];
     let wake;
@@ -27,14 +28,20 @@ export async function* streamCursorPrompt(agent, prompt, config) {
             const result = await run.wait();
             const finalText = (result.result ?? state.assistantText).trim();
             if (finalText) {
-                pending.push(finalText);
+                pending.push({ type: 'text', content: finalText });
             }
             if (result.status === 'error') {
+                if (wasResumed && (result.durationMs ?? 0) < 2000) {
+                    throw new StaleAgentSessionError('Resumed Cursor agent session is stale or expired.');
+                }
                 const details = JSON.stringify(result);
-                pending.push(`**Cursor error:** Run finished with error status. Details: \`${details}\``);
+                pending.push({
+                    type: 'text',
+                    content: `**Cursor error:** Run finished with error status. Details: \`${details}\``,
+                });
             }
             else if (result.status === 'cancelled') {
-                pending.push('**Cursor:** Run cancelled.');
+                pending.push({ type: 'text', content: '**Cursor:** Run cancelled.' });
             }
             if (result.git?.branches?.length) {
                 const branches = result.git.branches
@@ -44,7 +51,7 @@ export async function* streamCursorPrompt(agent, prompt, config) {
                 })
                     .filter(Boolean);
                 if (branches.length) {
-                    pending.push(`Git: ${branches.join('; ')}`);
+                    pending.push({ type: 'text', content: `Git: ${branches.join('; ')}` });
                 }
             }
         }

package/package.json

@@ -1,29 +1,35 @@
 {
   "name": "@meetopenbot/cursor",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "OpenBot agent plugin powered by the Cursor SDK.",
   "type": "module",
-  "main": "dist/index.js",
+  "main": "./dist/index.js",
   "publishConfig": {
     "access": "public"
   },
   "exports": {
-    ".": "./dist/index.js"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
   },
   "files": [
     "dist"
   ],
-  "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "typecheck": "tsc -p tsconfig.json --noEmit"
-  },
   "license": "MIT",
   "dependencies": {
     "@cursor/sdk": "^1.0.18",
-    "@meetopenbot/plugin-sdk": "^0.1.2"
+    "@meetopenbot/plugin-sdk": "^0.2.0"
   },
   "devDependencies": {
     "@types/node": "^25.9.2",
     "typescript": "^6.0.3"
+  },
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "build": "tsc -p tsconfig.json && node ../../scripts/write-plugin-declaration.mjs",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "dev": "tsc -p tsconfig.json --watch --preserveWatchOutput"
   }
-}
+}