@rama_nigg/open-cursor 2.2.0 → 2.3.0

package/dist/cli/opencode-cursor.js

@@ -412,11 +412,22 @@ function resolvePluginSource() {
   }
   throw new Error("Unable to locate plugin-entry.js next to CLI distribution files");
 }
+function isErrnoException(error) {
+  return typeof error === "object" && error !== null && "code" in error;
+}
 function readConfig(configPath) {
   if (!existsSync(configPath)) {
     return { plugin: [], provider: {} };
   }
-  const raw = readFileSync(configPath, "utf8");
+  let raw;
+  try {
+    raw = readFileSync(configPath, "utf8");
+  } catch (error) {
+    if (isErrnoException(error) && error.code === "ENOENT") {
+      return { plugin: [], provider: {} };
+    }
+    throw error;
+  }
   try {
     return JSON.parse(raw);
   } catch (error) {
@@ -536,14 +547,22 @@ function getStatusResult(configPath, pluginPath) {
   let pluginType = "missing";
   let pluginTarget;
   if (existsSync(pluginPath)) {
-    const stat = lstatSync(pluginPath);
-    pluginType = stat.isSymbolicLink() ? "symlink" : "file";
-    if (pluginType === "symlink") {
-      try {
-        pluginTarget = readFileSync(pluginPath, "utf8");
-      } catch {
-        pluginTarget = undefined;
+    try {
+      const stat = lstatSync(pluginPath);
+      pluginType = stat.isSymbolicLink() ? "symlink" : "file";
+      if (pluginType === "symlink") {
+        try {
+          pluginTarget = readFileSync(pluginPath, "utf8");
+        } catch {
+          pluginTarget = undefined;
+        }
+      }
+    } catch (error) {
+      if (!isErrnoException(error) || error.code !== "ENOENT") {
+        throw error;
       }
+      pluginType = "missing";
+      pluginTarget = undefined;
     }
   }
   let providerEnabled = false;

package/dist/index.js

@@ -17754,6 +17754,8 @@ var exports_plugin = {};
 __export(exports_plugin, {
   shouldProcessModel: () => shouldProcessModel,
   resolveChatParamTools: () => resolveChatParamTools,
+  normalizeWorkspaceForCompare: () => normalizeWorkspaceForCompare,
+  isReusableProxyHealthPayload: () => isReusableProxyHealthPayload,
   ensurePluginDirectory: () => ensurePluginDirectory,
   default: () => plugin_default,
   CursorPlugin: () => CursorPlugin
@@ -17855,6 +17857,18 @@ function resolveWorkspaceDirectory(worktree, directory) {
   }
   return dirCandidate || cwd || configPrefix;
 }
+function normalizeWorkspaceForCompare(pathValue) {
+  return resolve(pathValue);
+}
+function isReusableProxyHealthPayload(payload, workspaceDirectory) {
+  if (!payload || payload.ok !== true) {
+    return false;
+  }
+  if (typeof payload.workspaceDirectory !== "string" || payload.workspaceDirectory.length === 0) {
+    return false;
+  }
+  return normalizeWorkspaceForCompare(payload.workspaceDirectory) === normalizeWorkspaceForCompare(workspaceDirectory);
+}
 function parseToolLoopMode(value) {
   const normalized = (value ?? "opencode").trim().toLowerCase();
   if (normalized === "opencode" || normalized === "proxy-exec" || normalized === "off") {
@@ -18055,16 +18069,20 @@ async function findFirstAllowedToolCallInOutput(output, options) {
 async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
   const key = getGlobalKey();
   const g = globalThis;
-  const existingBaseURL = g[key]?.baseURL;
+  const normalizedWorkspace = normalizeWorkspaceForCompare(workspaceDirectory);
+  const state = g[key] ?? { baseURL: "", baseURLByWorkspace: {} };
+  state.baseURLByWorkspace = state.baseURLByWorkspace ?? {};
+  g[key] = state;
+  const existingBaseURL = state.baseURLByWorkspace[normalizedWorkspace] ?? state.baseURL;
   if (typeof existingBaseURL === "string" && existingBaseURL.length > 0) {
     return existingBaseURL;
   }
-  g[key] = { baseURL: "" };
+  state.baseURL = "";
   const handler = async (req) => {
     try {
       const url2 = new URL(req.url);
       if (url2.pathname === "/health") {
-        return new Response(JSON.stringify({ ok: true }), {
+        return new Response(JSON.stringify({ ok: true, workspaceDirectory }), {
           status: 200,
           headers: { "Content-Type": "application/json" }
         });
@@ -18182,7 +18200,7 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
         ]);
         const stdout = (stdoutText || "").trim();
         const stderr = (stderrText || "").trim();
-        const exitCode = child.exitCode;
+        const exitCode = await child.exited;
         log14.debug("cursor-agent completed (bun non-stream)", {
           exitCode,
           stdoutChars: stdout.length,
@@ -18431,14 +18449,15 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
             if (streamTerminated) {
               return;
             }
-            if (child.exitCode !== 0) {
+            const exitCode = await child.exited;
+            if (exitCode !== 0) {
               const stderrText = await new Response(child.stderr).text();
-              const errSource = (stderrText || "").trim() || `cursor-agent exited with code ${String(child.exitCode ?? "unknown")} and no output`;
+              const errSource = (stderrText || "").trim() || `cursor-agent exited with code ${String(exitCode ?? "unknown")} and no output`;
               const parsed = parseAgentError(errSource);
               const msg = formatErrorForUser(parsed);
               log14.error("cursor-cli streaming failed", {
                 type: parsed.type,
-                code: child.exitCode
+                code: exitCode
               });
               const errChunk = createChatCompletionChunk(id, created, model, msg, true);
               controller.enqueue(encoder.encode(`data: ${JSON.stringify(errChunk)}
@@ -18448,7 +18467,7 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
               return;
             }
             log14.debug("cursor-agent completed (bun stream)", {
-              exitCode: child.exitCode
+              exitCode
             });
             const doneChunk = createChatCompletionChunk(id, created, model, "", true);
             controller.enqueue(encoder.encode(`data: ${JSON.stringify(doneChunk)}
@@ -18482,8 +18501,12 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
     try {
       const res = await fetch(`http://${CURSOR_PROXY_HOST}:${CURSOR_PROXY_DEFAULT_PORT}/health`).catch(() => null);
       if (res && res.ok) {
-        g[key].baseURL = CURSOR_PROXY_DEFAULT_BASE_URL;
-        return CURSOR_PROXY_DEFAULT_BASE_URL;
+        const payload = await res.json().catch(() => null);
+        if (isReusableProxyHealthPayload(payload, workspaceDirectory)) {
+          state.baseURL = CURSOR_PROXY_DEFAULT_BASE_URL;
+          state.baseURLByWorkspace[normalizedWorkspace] = CURSOR_PROXY_DEFAULT_BASE_URL;
+          return CURSOR_PROXY_DEFAULT_BASE_URL;
+        }
       }
     } catch {}
   }
@@ -18494,7 +18517,7 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
       const url2 = new URL(req.url || "/", `http://${req.headers.host}`);
       if (url2.pathname === "/health") {
         res.writeHead(200, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ ok: true }));
+        res.end(JSON.stringify({ ok: true, workspaceDirectory }));
         return;
       }
       if (url2.pathname === "/v1/models" || url2.pathname === "/models") {
@@ -18916,7 +18939,8 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
       server2.once("error", reject);
     });
     const baseURL = `http://${CURSOR_PROXY_HOST}:${CURSOR_PROXY_DEFAULT_PORT}/v1`;
-    g[key].baseURL = baseURL;
+    state.baseURL = baseURL;
+    state.baseURLByWorkspace[normalizedWorkspace] = baseURL;
     return baseURL;
   } catch (error45) {
     if (error45?.code !== "EADDRINUSE") {
@@ -18926,8 +18950,12 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
       try {
         const res = await fetch(`http://${CURSOR_PROXY_HOST}:${CURSOR_PROXY_DEFAULT_PORT}/health`).catch(() => null);
         if (res && res.ok) {
-          g[key].baseURL = CURSOR_PROXY_DEFAULT_BASE_URL;
-          return CURSOR_PROXY_DEFAULT_BASE_URL;
+          const payload = await res.json().catch(() => null);
+          if (isReusableProxyHealthPayload(payload, workspaceDirectory)) {
+            state.baseURL = CURSOR_PROXY_DEFAULT_BASE_URL;
+            state.baseURLByWorkspace[normalizedWorkspace] = CURSOR_PROXY_DEFAULT_BASE_URL;
+            return CURSOR_PROXY_DEFAULT_BASE_URL;
+          }
         }
       } catch {}
     }
@@ -18938,7 +18966,8 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
     });
     const addr = server2.address();
     const baseURL = `http://${CURSOR_PROXY_HOST}:${addr.port}/v1`;
-    g[key].baseURL = baseURL;
+    state.baseURL = baseURL;
+    state.baseURLByWorkspace[normalizedWorkspace] = baseURL;
     return baseURL;
   }
 }

package/dist/plugin-entry.js

@@ -17754,6 +17754,8 @@ var exports_plugin = {};
 __export(exports_plugin, {
   shouldProcessModel: () => shouldProcessModel,
   resolveChatParamTools: () => resolveChatParamTools,
+  normalizeWorkspaceForCompare: () => normalizeWorkspaceForCompare,
+  isReusableProxyHealthPayload: () => isReusableProxyHealthPayload,
   ensurePluginDirectory: () => ensurePluginDirectory,
   default: () => plugin_default,
   CursorPlugin: () => CursorPlugin
@@ -17855,6 +17857,18 @@ function resolveWorkspaceDirectory(worktree, directory) {
   }
   return dirCandidate || cwd || configPrefix;
 }
+function normalizeWorkspaceForCompare(pathValue) {
+  return resolve2(pathValue);
+}
+function isReusableProxyHealthPayload(payload, workspaceDirectory) {
+  if (!payload || payload.ok !== true) {
+    return false;
+  }
+  if (typeof payload.workspaceDirectory !== "string" || payload.workspaceDirectory.length === 0) {
+    return false;
+  }
+  return normalizeWorkspaceForCompare(payload.workspaceDirectory) === normalizeWorkspaceForCompare(workspaceDirectory);
+}
 function parseToolLoopMode(value) {
   const normalized = (value ?? "opencode").trim().toLowerCase();
   if (normalized === "opencode" || normalized === "proxy-exec" || normalized === "off") {
@@ -18055,16 +18069,20 @@ async function findFirstAllowedToolCallInOutput(output, options) {
 async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
   const key = getGlobalKey();
   const g = globalThis;
-  const existingBaseURL = g[key]?.baseURL;
+  const normalizedWorkspace = normalizeWorkspaceForCompare(workspaceDirectory);
+  const state = g[key] ?? { baseURL: "", baseURLByWorkspace: {} };
+  state.baseURLByWorkspace = state.baseURLByWorkspace ?? {};
+  g[key] = state;
+  const existingBaseURL = state.baseURLByWorkspace[normalizedWorkspace] ?? state.baseURL;
   if (typeof existingBaseURL === "string" && existingBaseURL.length > 0) {
     return existingBaseURL;
   }
-  g[key] = { baseURL: "" };
+  state.baseURL = "";
   const handler = async (req) => {
     try {
       const url2 = new URL(req.url);
       if (url2.pathname === "/health") {
-        return new Response(JSON.stringify({ ok: true }), {
+        return new Response(JSON.stringify({ ok: true, workspaceDirectory }), {
           status: 200,
           headers: { "Content-Type": "application/json" }
         });
@@ -18182,7 +18200,7 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
         ]);
         const stdout = (stdoutText || "").trim();
         const stderr = (stderrText || "").trim();
-        const exitCode = child.exitCode;
+        const exitCode = await child.exited;
         log14.debug("cursor-agent completed (bun non-stream)", {
           exitCode,
           stdoutChars: stdout.length,
@@ -18431,14 +18449,15 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
             if (streamTerminated) {
               return;
             }
-            if (child.exitCode !== 0) {
+            const exitCode = await child.exited;
+            if (exitCode !== 0) {
               const stderrText = await new Response(child.stderr).text();
-              const errSource = (stderrText || "").trim() || `cursor-agent exited with code ${String(child.exitCode ?? "unknown")} and no output`;
+              const errSource = (stderrText || "").trim() || `cursor-agent exited with code ${String(exitCode ?? "unknown")} and no output`;
               const parsed = parseAgentError(errSource);
               const msg = formatErrorForUser(parsed);
               log14.error("cursor-cli streaming failed", {
                 type: parsed.type,
-                code: child.exitCode
+                code: exitCode
               });
               const errChunk = createChatCompletionChunk(id, created, model, msg, true);
               controller.enqueue(encoder.encode(`data: ${JSON.stringify(errChunk)}
@@ -18448,7 +18467,7 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
               return;
             }
             log14.debug("cursor-agent completed (bun stream)", {
-              exitCode: child.exitCode
+              exitCode
             });
             const doneChunk = createChatCompletionChunk(id, created, model, "", true);
             controller.enqueue(encoder.encode(`data: ${JSON.stringify(doneChunk)}
@@ -18482,8 +18501,12 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
     try {
       const res = await fetch(`http://${CURSOR_PROXY_HOST}:${CURSOR_PROXY_DEFAULT_PORT}/health`).catch(() => null);
       if (res && res.ok) {
-        g[key].baseURL = CURSOR_PROXY_DEFAULT_BASE_URL;
-        return CURSOR_PROXY_DEFAULT_BASE_URL;
+        const payload = await res.json().catch(() => null);
+        if (isReusableProxyHealthPayload(payload, workspaceDirectory)) {
+          state.baseURL = CURSOR_PROXY_DEFAULT_BASE_URL;
+          state.baseURLByWorkspace[normalizedWorkspace] = CURSOR_PROXY_DEFAULT_BASE_URL;
+          return CURSOR_PROXY_DEFAULT_BASE_URL;
+        }
       }
     } catch {}
   }
@@ -18494,7 +18517,7 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
       const url2 = new URL(req.url || "/", `http://${req.headers.host}`);
       if (url2.pathname === "/health") {
         res.writeHead(200, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ ok: true }));
+        res.end(JSON.stringify({ ok: true, workspaceDirectory }));
         return;
       }
       if (url2.pathname === "/v1/models" || url2.pathname === "/models") {
@@ -18916,7 +18939,8 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
       server2.once("error", reject);
     });
     const baseURL = `http://${CURSOR_PROXY_HOST}:${CURSOR_PROXY_DEFAULT_PORT}/v1`;
-    g[key].baseURL = baseURL;
+    state.baseURL = baseURL;
+    state.baseURLByWorkspace[normalizedWorkspace] = baseURL;
     return baseURL;
   } catch (error45) {
     if (error45?.code !== "EADDRINUSE") {
@@ -18926,8 +18950,12 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
       try {
         const res = await fetch(`http://${CURSOR_PROXY_HOST}:${CURSOR_PROXY_DEFAULT_PORT}/health`).catch(() => null);
         if (res && res.ok) {
-          g[key].baseURL = CURSOR_PROXY_DEFAULT_BASE_URL;
-          return CURSOR_PROXY_DEFAULT_BASE_URL;
+          const payload = await res.json().catch(() => null);
+          if (isReusableProxyHealthPayload(payload, workspaceDirectory)) {
+            state.baseURL = CURSOR_PROXY_DEFAULT_BASE_URL;
+            state.baseURLByWorkspace[normalizedWorkspace] = CURSOR_PROXY_DEFAULT_BASE_URL;
+            return CURSOR_PROXY_DEFAULT_BASE_URL;
+          }
         }
       } catch {}
     }
@@ -18938,7 +18966,8 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
     });
     const addr = server2.address();
     const baseURL = `http://${CURSOR_PROXY_HOST}:${addr.port}/v1`;
-    g[key].baseURL = baseURL;
+    state.baseURL = baseURL;
+    state.baseURLByWorkspace[normalizedWorkspace] = baseURL;
     return baseURL;
   }
 }

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@rama_nigg/open-cursor",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "description": "No prompt limits. No broken streams. Full thinking + tool support. Your Cursor subscription, properly integrated.",
   "type": "module",
   "main": "dist/index.js",
+  "module": "src/plugin-entry.ts",
   "scripts": {
     "build": "bun build ./src/index.ts ./src/plugin-entry.ts ./src/cli/discover.ts ./src/cli/opencode-cursor.ts --outdir ./dist --target node",
     "dev": "bun build ./src/index.ts ./src/plugin-entry.ts ./src/cli/discover.ts ./src/cli/opencode-cursor.ts --outdir ./dist --target node --watch",
@@ -20,10 +21,15 @@
     "cursor-discover": "dist/cli/discover.js"
   },
   "exports": {
-    ".": "./dist/index.js"
+    ".": {
+      "bun": "./src/plugin-entry.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
   },
   "files": [
-    "dist"
+    "dist",
+    "src"
   ],
   "dependencies": {
     "ai": "^6.0.55",

package/src/acp/metrics.ts

@@ -0,0 +1,83 @@
+export interface SessionMetrics {
+  sessionId: string;
+  model: string;
+  promptTokens: number;
+  toolCalls: number;
+  duration: number;
+  timestamp: number;
+}
+
+export interface AggregateMetrics {
+  totalPrompts: number;
+  totalToolCalls: number;
+  totalDuration: number;
+  avgDuration: number;
+}
+
+export class MetricsTracker {
+  private sessions: Map<string, SessionMetrics> = new Map();
+
+  recordPrompt(sessionId: string, model: string, tokens: number): void {
+    const existing = this.sessions.get(sessionId);
+    if (existing) {
+      existing.promptTokens = tokens;
+      existing.model = model;
+    } else {
+      this.sessions.set(sessionId, {
+        sessionId,
+        model,
+        promptTokens: tokens,
+        toolCalls: 0,
+        duration: 0,
+        timestamp: Date.now()
+      });
+    }
+  }
+
+  recordToolCall(sessionId: string, toolName: string, duration: number): void {
+    const existing = this.sessions.get(sessionId);
+    if (existing) {
+      existing.toolCalls++;
+      existing.duration += duration;
+    }
+    // If no session exists, silently ignore (matches test expectations)
+  }
+
+  getSessionMetrics(sessionId: string): SessionMetrics | undefined {
+    return this.sessions.get(sessionId);
+  }
+
+  getAggregateMetrics(hours: number): AggregateMetrics {
+    const cutoff = Date.now() - (hours * 60 * 60 * 1000);
+    let totalPrompts = 0;
+    let totalToolCalls = 0;
+    let totalDuration = 0;
+
+    for (const metrics of this.sessions.values()) {
+      if (metrics.timestamp >= cutoff) {
+        totalPrompts++;
+        totalToolCalls += metrics.toolCalls;
+        totalDuration += metrics.duration;
+      }
+    }
+
+    return {
+      totalPrompts,
+      totalToolCalls,
+      totalDuration,
+      avgDuration: totalPrompts > 0 ? Math.round(totalDuration / totalPrompts) : 0
+    };
+  }
+
+  clearMetrics(sessionId?: string): void {
+    if (sessionId) {
+      this.sessions.delete(sessionId);
+    } else {
+      this.sessions.clear();
+    }
+  }
+
+  clearAll(): void {
+    this.sessions.clear();
+  }
+}

package/src/acp/sessions.ts

@@ -0,0 +1,107 @@
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { dirname, join } from "path";
+
+export interface Session {
+  id: string;
+  cwd: string;
+  modeId?: string;
+  cancelled?: boolean;
+  resumeId?: string;
+  createdAt: number;
+  updatedAt: number;
+}
+
+export interface SessionCreateOptions {
+  cwd?: string;
+  modeId?: string;
+}
+
+export class SessionManager {
+  private sessions: Map<string, Session> = new Map();
+  private storagePath: string;
+
+  constructor(storagePath?: string) {
+    this.storagePath = storagePath || join(process.cwd(), ".opencode", "sessions.json");
+  }
+
+  async initialize(): Promise<void> {
+    // Load sessions from disk if storage file exists
+    try {
+      const data = await readFile(this.storagePath, "utf-8");
+      const sessions = JSON.parse(data) as Record<string, Session>;
+      this.sessions = new Map(Object.entries(sessions));
+    } catch {
+      // File doesn't exist or is invalid, start fresh
+      this.sessions.clear();
+    }
+  }
+
+  private async persist(): Promise<void> {
+    // Save sessions to disk
+    const dir = dirname(this.storagePath);
+    await mkdir(dir, { recursive: true });
+    const data = JSON.stringify(Object.fromEntries(this.sessions), null, 2);
+    await writeFile(this.storagePath, data, "utf-8");
+  }
+
+  async createSession(options: SessionCreateOptions): Promise<Session> {
+    const id = `session-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+    const session: Session = {
+      id,
+      cwd: options.cwd || process.cwd(),
+      modeId: options.modeId,
+      cancelled: false,
+      createdAt: Date.now(),
+      updatedAt: Date.now()
+    };
+
+    this.sessions.set(id, session);
+    await this.persist();
+    return session;
+  }
+
+  async getSession(id: string): Promise<Session | null> {
+    return this.sessions.get(id) || null;
+  }
+
+  async updateSession(id: string, updates: Partial<Session>): Promise<void> {
+    const session = this.sessions.get(id);
+    if (session) {
+      Object.assign(session, updates, { updatedAt: Date.now() });
+      await this.persist();
+    }
+  }
+
+  async deleteSession(id: string): Promise<void> {
+    this.sessions.delete(id);
+    await this.persist();
+  }
+
+  isCancelled(id: string): boolean {
+    const session = this.sessions.get(id);
+    return session?.cancelled || false;
+  }
+
+  markCancelled(id: string): void {
+    const session = this.sessions.get(id);
+    if (session) {
+      session.cancelled = true;
+      session.updatedAt = Date.now();
+      this.persist().catch(() => {});
+    }
+  }
+
+  canResume(id: string): boolean {
+    const session = this.sessions.get(id);
+    return !!session?.resumeId;
+  }
+
+  setResumeId(id: string, resumeId: string): void {
+    const session = this.sessions.get(id);
+    if (session) {
+      session.resumeId = resumeId;
+      session.updatedAt = Date.now();
+      this.persist().catch(() => {});
+    }
+  }
+}