@meetopenbot/cursor 0.0.2 → 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,6 +1,6 @@
-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 { formatCursorError, formatToolResult } from './format.js';
 import { getOrCreateCursorAgent, StaleAgentSessionError } from './session.js';
 import { streamCursorPrompt } from './stream.js';
 export default definePlugin({
@@ -112,14 +112,103 @@ export default definePlugin({
                     state: handlerCtx.state,
                     storage: context.storage,
                 });
-                try {
-                    for await (const chunk of streamCursorPrompt(agentHandle.agent, prompt, config, agentHandle.wasResumed)) {
+                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: chunk,
+                            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) {
@@ -130,13 +219,7 @@ export default definePlugin({
                             storage: context.storage,
                             forceNew: true,
                         });
-                        for await (const chunk of streamCursorPrompt(agentHandle.agent, prompt, config, agentHandle.wasResumed)) {
-                            yield agentOutput({
-                                agentId: context.agentId,
-                                content: chunk,
-                                threadId,
-                            });
-                        }
+                        yield* runTurn(agentHandle.wasResumed);
                     }
                     else {
                         throw streamErr;

package/dist/stream.js

@@ -1,7 +1,7 @@
 import { buildModelSelection } from './config.js';
-import { createStreamState, formatCursorEvent } from './format.js';
+import { createStreamState, formatCursorEvent, } from './format.js';
 import { StaleAgentSessionError } from './session.js';
-/** Bridge Cursor SDK run events into an async generator of output chunks. */
+/** 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 = [];
@@ -28,17 +28,20 @@ export async function* streamCursorPrompt(agent, prompt, config, wasResumed) {
             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
@@ -48,7 +51,7 @@ export async function* streamCursorPrompt(agent, prompt, config, wasResumed) {
                 })
                     .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.2",
+  "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"
   }
-}
+}