@rama_nigg/open-cursor 2.2.1 → 2.3.0

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@rama_nigg/open-cursor",
-  "version": "2.2.1",
+  "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(() => {});
+    }
+  }
+}

package/src/acp/tools.ts

@@ -0,0 +1,209 @@
+export interface ToolUpdate {
+  sessionId: string;
+  toolCallId: string;
+  title?: string;
+  kind?: 'read' | 'write' | 'edit' | 'search' | 'execute' | 'other';
+  status?: 'pending' | 'in_progress' | 'completed' | 'failed';
+  locations?: Array<{ path: string; line?: number }>;
+  content?: Array<{ type: string; [key: string]: unknown }>;
+  rawOutput?: string;
+  startTime?: number;
+  endTime?: number;
+}
+
+interface CursorEvent {
+  type: string;
+  call_id?: string;
+  tool_call_id?: string;
+  subtype?: string;
+  tool_call?: {
+    [key: string]: {
+      args?: Record<string, unknown>;
+      result?: Record<string, unknown>;
+    };
+  };
+}
+
+export class ToolMapper {
+  async mapCursorEventToAcp(event: CursorEvent, sessionId: string): Promise<ToolUpdate[]> {
+    if (event.type !== 'tool_call') {
+      return [];
+    }
+
+    const updates: ToolUpdate[] = [];
+    const toolCallId = event.call_id || event.tool_call_id || 'unknown';
+    const subtype = event.subtype || 'started';
+
+    // Completed/failed events return 1 update with results
+    if (subtype === 'completed' || subtype === 'failed') {
+      const result = this.extractResult(event.tool_call || {});
+      const locations = result.locations?.length ? result.locations : this.extractLocations(event.tool_call || {});
+
+      updates.push({
+        sessionId,
+        toolCallId,
+        title: this.buildToolTitle(event.tool_call || {}),
+        kind: this.inferToolType(event.tool_call || {}),
+        status: result.error ? 'failed' : 'completed',
+        content: result.content,
+        locations,
+        rawOutput: result.rawOutput,
+        endTime: Date.now()
+      });
+    } else {
+      // Started events return 2 updates: pending and in_progress
+      updates.push({
+        sessionId,
+        toolCallId,
+        title: this.buildToolTitle(event.tool_call || {}),
+        kind: this.inferToolType(event.tool_call || {}),
+        status: 'pending',
+        locations: this.extractLocations(event.tool_call || {}),
+        startTime: Date.now()
+      });
+
+      updates.push({
+        sessionId,
+        toolCallId,
+        status: 'in_progress'
+      });
+    }
+
+    return updates;
+  }
+
+  private inferToolType(toolCall: Record<string, unknown>): ToolUpdate['kind'] {
+    const keys = Object.keys(toolCall);
+    for (const key of keys) {
+      if (key.includes('read')) return 'read';
+      if (key.includes('write')) return 'edit';
+      if (key.includes('grep') || key.includes('glob')) return 'search';
+      if (key.includes('bash') || key.includes('shell')) return 'execute';
+    }
+    return 'other';
+  }
+
+  private buildToolTitle(toolCall: Record<string, unknown>): string {
+    const keys = Object.keys(toolCall);
+    for (const key of keys) {
+      const tool = toolCall[key] as { args?: Record<string, unknown> } | undefined;
+      const args = tool?.args || {};
+
+      if (key.includes('read') && args.path) return `Read ${args.path}`;
+      if (key.includes('write') && args.path) return `Write ${args.path}`;
+      if (key.includes('grep')) {
+        const pattern = args.pattern || 'pattern';
+        const path = args.path;
+        return path ? `Search ${path} for ${pattern}` : `Search for ${pattern}`;
+      }
+      if (key.includes('glob') && args.pattern) return `Glob ${args.pattern}`;
+      if ((key.includes('bash') || key.includes('shell')) && (args.command || args.cmd)) {
+        return `\`${args.command || args.cmd}\``;
+      }
+      if ((key.includes('bash') || key.includes('shell')) && args.commands && Array.isArray(args.commands)) {
+        return `\`${args.commands.join(' && ')}\``;
+      }
+    }
+    return 'other';
+  }
+
+  private extractLocations(toolCall: Record<string, unknown>): ToolUpdate['locations'] {
+    const keys = Object.keys(toolCall);
+    for (const key of keys) {
+      const tool = toolCall[key] as { args?: Record<string, unknown> } | undefined;
+      const args = tool?.args || {};
+
+      if (args.path) {
+        if (typeof args.path === 'string') {
+          return [{ path: args.path, line: args.line as number | undefined }];
+        }
+        if (Array.isArray(args.path)) {
+          return args.path.map((p: string | { path: string; line?: number }) =>
+            typeof p === 'string' ? { path: p } : { path: p.path, line: p.line }
+          );
+        }
+      }
+
+      if (args.paths && Array.isArray(args.paths)) {
+        return args.paths.map((p: string | { path: string; line?: number }) =>
+          typeof p === 'string' ? { path: p } : { path: p.path, line: p.line }
+        );
+      }
+    }
+    return undefined;
+  }
+
+  private extractResult(toolCall: Record<string, unknown>): {
+    error?: string;
+    content?: ToolUpdate['content'];
+    locations?: ToolUpdate['locations'];
+    rawOutput?: string;
+  } {
+    const keys = Object.keys(toolCall);
+    for (const key of keys) {
+      const tool = toolCall[key] as {
+        result?: Record<string, unknown>;
+        args?: Record<string, unknown>;
+      } | undefined;
+      const result = tool?.result || {};
+
+      if (result.error) {
+        return { error: result.error as string };
+      }
+
+      const locations: ToolUpdate['locations'] = [];
+      if (result.matches && Array.isArray(result.matches)) {
+        locations.push(...result.matches.map((m: { path: string; line?: number }) => ({
+          path: m.path,
+          line: m.line
+        })));
+      }
+      if (result.files && Array.isArray(result.files)) {
+        locations.push(...result.files.map((f: string) => ({ path: f })));
+      }
+      if (result.path) {
+        locations.push({ path: result.path as string, line: result.line as number | undefined });
+      }
+
+      const content: ToolUpdate['content'] = [];
+
+      // Handle write operations with diff generation
+      if (key.includes('write')) {
+        const oldText = result.oldText ?? null;
+        const newText = result.newText as string | undefined;
+        const path = (tool?.args?.path as string) || (result.path as string);
+        if (newText !== undefined || oldText !== undefined) {
+          content.push({
+            type: 'diff',
+            path,
+            oldText,
+            newText
+          });
+        }
+      }
+
+      if (result.content) {
+        content.push({
+          type: 'content',
+          content: { text: result.content as string }
+        });
+      }
+
+      if (result.output !== undefined || result.exitCode !== undefined) {
+        content.push({
+          type: 'content',
+          content: {
+            text: `Exit code: ${result.exitCode ?? 0}\n${result.output || '(no output)'}`
+          }
+        });
+      }
+
+      return {
+        content: content.length > 0 ? content : undefined,
+        locations: locations.length > 0 ? locations : undefined,
+        rawOutput: JSON.stringify(result)
+      };
+    }
+    return {};
+  }
+}

package/src/auth.ts

@@ -0,0 +1,269 @@
+// src/auth.ts
+
+import { spawn } from "child_process";
+import { existsSync } from "fs";
+import { homedir, platform } from "os";
+import { join } from "path";
+import { createLogger } from "./utils/logger";
+import { stripAnsi } from "./utils/errors";
+
+const log = createLogger("auth");
+
+// Polling configuration for auth file detection
+const AUTH_POLL_INTERVAL = 2000; // Check every 2 seconds
+const AUTH_POLL_TIMEOUT = 5 * 60 * 1000; // 5 minutes total timeout
+const URL_EXTRACTION_TIMEOUT = 10000; // Wait up to 10 seconds for URL
+
+export interface AuthResult {
+  type: "success" | "failed";
+  provider?: string;
+  key?: string;
+  error?: string;
+}
+
+function getHomeDir(): string {
+  const override = process.env.CURSOR_ACP_HOME_DIR;
+  if (override && override.length > 0) {
+    return override;
+  }
+  return homedir();
+}
+
+export async function pollForAuthFile(
+  timeoutMs: number = AUTH_POLL_TIMEOUT,
+  intervalMs: number = AUTH_POLL_INTERVAL
+): Promise<boolean> {
+  const startTime = Date.now();
+  const possiblePaths = getPossibleAuthPaths();
+
+  return new Promise((resolve) => {
+    const check = () => {
+      const elapsed = Date.now() - startTime;
+      
+      for (const authPath of possiblePaths) {
+        if (existsSync(authPath)) {
+          log.debug("Auth file detected", { path: authPath });
+          resolve(true);
+          return;
+        }
+      }
+
+      log.debug("Polling for auth file", {
+        checkedPaths: possiblePaths,
+        elapsed: `${elapsed}ms`,
+        timeout: `${timeoutMs}ms`,
+      });
+
+      if (elapsed >= timeoutMs) {
+        log.debug("Auth file polling timed out");
+        resolve(false);
+        return;
+      }
+
+      setTimeout(check, intervalMs);
+    };
+
+    check();
+  });
+}
+
+export async function startCursorOAuth(): Promise<{
+  url: string;
+  instructions: string;
+  callback: () => Promise<AuthResult>;
+}> {
+  return new Promise((resolve, reject) => {
+    log.info("Starting cursor-cli login process");
+
+    const proc = spawn("cursor-agent", ["login"], {
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+
+    let stdout = "";
+    let stderr = "";
+    let urlExtracted = false;
+
+    proc.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+
+    proc.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+
+    const extractUrl = () => {
+      // Step 1: Strip ANSI codes
+      let cleanOutput = stripAnsi(stdout);
+      // Step 2: Remove ALL whitespace (newlines, spaces, tabs)
+      // The URL is split across lines with continuation spaces
+      cleanOutput = cleanOutput.replace(/\s/g, "");
+      // Step 3: Now extract the continuous URL
+      const urlMatch = cleanOutput.match(/https:\/\/cursor\.com\/loginDeepControl[^\s]*/);
+      if (urlMatch) {
+        return urlMatch[0];
+      }
+      return null;
+    };
+
+    // Try to extract URL with polling instead of fixed timeout
+    const tryExtractUrl = () => {
+      const url = extractUrl();
+
+      if (url && !urlExtracted) {
+        urlExtracted = true;
+        log.debug("Captured stdout", { length: stdout.length });
+        log.debug("Extracted URL", { url: url.substring(0, 50) + "..." });
+        log.info("Got login URL, waiting for browser auth");
+
+        resolve({
+          url,
+          instructions: "Click 'Continue with Cursor' in your browser to authenticate",
+          callback: async () => {
+            // Wait for process to complete
+            return new Promise((resolve) => {
+              let resolved = false;
+
+              const resolveOnce = (result: AuthResult) => {
+                if (!resolved) {
+                  resolved = true;
+                  resolve(result);
+                }
+              };
+
+              proc.on("close", async (code) => {
+                log.debug("Login process closed", { code });
+
+                // If process exited successfully, poll for auth file
+                if (code === 0) {
+                  log.info("Process exited successfully, polling for auth file...");
+                  const isAuthenticated = await pollForAuthFile();
+
+                  if (isAuthenticated) {
+                    log.info("Authentication successful");
+                    resolveOnce({
+                      type: "success",
+                      provider: "cursor-acp",
+                      key: "cursor-auth",
+                    });
+                  } else {
+                    log.warn("Auth file not found after polling");
+                    resolveOnce({
+                      type: "failed",
+                      error: "Authentication was not completed. Please try again.",
+                    });
+                  }
+                } else {
+                  log.warn("Login process failed", { code });
+                  resolveOnce({
+                    type: "failed",
+                    error: stderr ? stripAnsi(stderr) : `Authentication failed with code ${code}`,
+                  });
+                }
+              });
+
+              // Timeout after 5 minutes
+              setTimeout(() => {
+                log.warn("Authentication timed out after 5 minutes");
+                proc.kill();
+                resolveOnce({
+                  type: "failed",
+                  error: "Authentication timed out. Please try again.",
+                });
+              }, AUTH_POLL_TIMEOUT);
+            });
+          },
+        });
+      }
+    };
+
+    // Poll for URL extraction with timeout
+    const urlPollStart = Date.now();
+    const pollForUrl = () => {
+      if (urlExtracted) return;
+
+      const elapsed = Date.now() - urlPollStart;
+      if (elapsed >= URL_EXTRACTION_TIMEOUT) {
+        proc.kill();
+        const errorMsg = stderr ? stripAnsi(stderr) : "No login URL received within timeout";
+        log.error("Failed to extract login URL", { error: errorMsg, elapsed: `${elapsed}ms` });
+        reject(new Error(`Failed to get login URL: ${errorMsg}`));
+        return;
+      }
+
+      tryExtractUrl();
+
+      if (!urlExtracted) {
+        setTimeout(pollForUrl, 100); // Check every 100ms
+      }
+    };
+
+    // Start polling for URL
+    pollForUrl();
+  });
+}
+
+export function verifyCursorAuth(): boolean {
+  const possiblePaths = getPossibleAuthPaths();
+  
+  for (const authPath of possiblePaths) {
+    if (existsSync(authPath)) {
+      log.debug("Auth file found", { path: authPath });
+      return true;
+    }
+  }
+  
+  log.debug("No auth file found", { checkedPaths: possiblePaths });
+  return false;
+}
+
+/**
+ * Returns all possible auth file paths in priority order.
+ * Checks both auth.json (legacy) and cli-config.json (current cursor-agent format).
+ * - macOS: ~/.cursor/ (primary), ~/.config/cursor/ (fallback)
+ * - Linux: ~/.config/cursor/ (XDG), XDG_CONFIG_HOME/cursor/, ~/.cursor/
+ */
+export function getPossibleAuthPaths(): string[] {
+  const home = getHomeDir();
+  const paths: string[] = [];
+  const isDarwin = platform() === "darwin";
+
+  const authFiles = ["cli-config.json", "auth.json"];
+
+  if (isDarwin) {
+    for (const file of authFiles) {
+      paths.push(join(home, ".cursor", file));
+    }
+    for (const file of authFiles) {
+      paths.push(join(home, ".config", "cursor", file));
+    }
+  } else {
+    for (const file of authFiles) {
+      paths.push(join(home, ".config", "cursor", file));
+    }
+
+    const xdgConfig = process.env.XDG_CONFIG_HOME;
+    if (xdgConfig && xdgConfig !== join(home, ".config")) {
+      for (const file of authFiles) {
+        paths.push(join(xdgConfig, "cursor", file));
+      }
+    }
+
+    for (const file of authFiles) {
+      paths.push(join(home, ".cursor", file));
+    }
+  }
+
+  return paths;
+}
+
+export function getAuthFilePath(): string {
+  const possiblePaths = getPossibleAuthPaths();
+  
+  for (const authPath of possiblePaths) {
+    if (existsSync(authPath)) {
+      return authPath;
+    }
+  }
+  
+  return possiblePaths[0];
+}