EPMCDME-14834 Cursor IDE OTLP integration

src/agents/__tests__/registry.test.ts

@@ -19,6 +19,7 @@ describe('AgentRegistry', () => {
           'codemie-code',
           'claude',
           'claude-acp',
+          'cursor-ide',
           'gemini',
           'opencode',
           'codex',

src/agents/core/types.ts

@@ -664,6 +664,35 @@ export interface AgentHookConfig {
    * }
    */
   eventNameMapping?: Record<string, InternalHookEventName>;
+
+
+  /**
+   * When true, the `codemie hook` CLI path never exits non-zero for this
+   * agent: JSON-parse failures and `validateHookEvent` failures degrade to a
+   * non-blocking failure (thrown internally, caught, and turned into a
+   * successful exit) instead of `process.exit(2)`. Set by agents whose host
+   * treats a non-zero exit as a hard block on the user's action.
+   */
+  neverBlockingExit?: boolean;
+
+  /**
+   * Optional per-agent stdout response contract, invoked with the
+   * agent-native event name (`event.hook_event_name`, unmutated by
+   * `eventNameMapping`) after the hook has been routed. Lets a host that
+   * inspects stdout for a synchronous response (e.g. Cursor's
+   * `{"permission":"allow"}`/`{"continue":true}`) get one without adding an
+   * agent-name literal to `hook.ts` — set only by agents whose host reads a
+   * response from stdout.
+   */
+  writeStdoutResponse?: (nativeEventName: string) => void;
+
+
+  /**
+   * When true, the hook action forwards every event as-is to the local proxy
+   * daemon (see forwardOtlpEvent) and returns immediately, before the shared
+   * transform/validate/route pipeline and its legacy analytics handlers run.
+   */
+  otlpIngestion?: boolean;
 }
 
 /**

src/agents/plugins/cursor-ide/cursor-ide.constants.ts

@@ -0,0 +1,15 @@
+/**
+ * Shared Cursor IDE identifiers.
+ *
+ * Kept apart from `cursor-ide.plugin.ts` so other modules (the connector, the
+ * hook transformer) can import identifiers without pulling in the full plugin.
+ */
+
+/** Internal agent key. Canonical everywhere: the `--cursor-ide` flag, `--agent cursor-ide`, `metadata.name`. */
+export const CURSOR_IDE_AGENT_NAME = 'cursor-ide';
+
+/** User-facing label shown in analytics output. */
+export const CURSOR_IDE_DISPLAY_NAME = 'Cursor IDE';
+
+/** Runtime client type recorded on ingested analytics events. */
+export const CURSOR_IDE_CLIENT_TYPE = 'codemie-cursor-ide';

src/agents/plugins/cursor-ide/cursor-ide.otlp-forwarder.ts

@@ -0,0 +1,64 @@
+import { readState, isProcessAlive } from '../../../cli/commands/proxy/daemon-manager.js';
+import { logger } from '../../../utils/logger.js';
+
+interface OtlpEventPayload {
+  agentName: string;
+  timestamp: string;
+  raw: string;
+}
+
+/**
+ * Fire-and-forget forward of a raw cursor-ide hook event to the local proxy daemon.
+ *
+ * - Calls readState() to get daemon URL and gateway key
+ * - If no daemon or process is dead, logs at debug and returns (no error)
+ * - POSTs { agentName, timestamp, raw: rawInput } to daemon's /v1/otlp/hook-events route
+ * - Uses 1500ms timeout and swallows all errors (network, non-2xx status)
+ * - Never throws, never blocks cursor's exit, never affects hook's exit code
+ */
+export async function forwardOtlpEvent(rawInput: string, agentName: string): Promise<void> {
+  try {
+    const state = await readState();
+    if (!state) {
+      logger.debug('forwardOtlpEvent: no daemon state found');
+      return;
+    }
+
+    if (!isProcessAlive(state.pid)) {
+      logger.debug(`forwardOtlpEvent: daemon pid ${state.pid} not alive`);
+      return;
+    }
+
+    const payload: OtlpEventPayload = {
+      agentName,
+      timestamp: new Date().toISOString(),
+      raw: rawInput,
+    };
+
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 1500);
+
+    try {
+      const response = await fetch(`${state.url}/v1/otlp/hook-events`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${state.gatewayKey}`,
+        },
+        body: JSON.stringify(payload),
+        signal: controller.signal,
+      });
+
+      if (!response.ok) {
+        logger.debug(`forwardOtlpEvent: received status ${response.status}`);
+      }
+    } finally {
+      clearTimeout(timeout);
+    }
+  } catch (err) {
+    // Swallow all errors: network failure, timeout, JSON errors, etc.
+    // Never let a POST failure affect cursor's exit or the hook's behavior
+    const msg = err instanceof Error ? err.message : String(err);
+    logger.debug(`forwardOtlpEvent: ${msg}`);
+  }
+}

src/agents/plugins/cursor-ide/cursor-ide.plugin.ts

@@ -0,0 +1,69 @@
+import type { AgentMetadata } from '../../core/types.js';
+import { BaseAgentAdapter } from '../../core/BaseAgentAdapter.js';
+import { writeCursorResponse } from './cursor-ide.response.js';
+import {
+  CURSOR_IDE_AGENT_NAME,
+  CURSOR_IDE_CLIENT_TYPE,
+  CURSOR_IDE_DISPLAY_NAME,
+} from './cursor-ide.constants.js';
+
+export {
+  CURSOR_IDE_AGENT_NAME,
+  CURSOR_IDE_CLIENT_TYPE,
+  CURSOR_IDE_DISPLAY_NAME,
+} from './cursor-ide.constants.js';
+
+export const CursorIdePluginMetadata: AgentMetadata = {
+  name: CURSOR_IDE_AGENT_NAME,
+  displayName: CURSOR_IDE_DISPLAY_NAME,
+  description: 'Cursor IDE - analytics-only hook ingestion, never installed or launched by CodeMie',
+
+  // Analytics-only: CodeMie never installs, updates, or launches Cursor.
+  npmPackage: null,
+  cliCommand: null,
+
+  envMapping: {
+    baseUrl: [],
+    apiKey: [],
+    model: [],
+  },
+  supportedProviders: [],
+
+  // The sole gate excluding this agent from `codemie install/list/uninstall/update`
+  // (src/agents/registry.ts:getManageableAgents, types.ts:analyticsOnly).
+  analyticsOnly: true,
+
+  ssoConfig: {
+    enabled: false,
+    clientType: CURSOR_IDE_CLIENT_TYPE,
+  },
+
+  hookConfig: {
+    // Exit code 2 is equivalent to `permission: "deny"` in Cursor and blocks
+    // the user's action - analytics ingestion must never be capable of that.
+    neverBlockingExit: true,
+    // Cursor reads a JSON response off stdout for a subset of its events
+    // (see cursor-ide.response.ts) - this is the sole gate that calls it,
+    // set only for this agent.
+    writeStdoutResponse: writeCursorResponse,
+    // Fire-and-forget forward raw events to the local proxy daemon's
+    // /v1/otlp/hook-events route, bypassing the shared transform/validate/route
+    // pipeline and its legacy analytics handlers.
+    otlpIngestion: true,
+  },
+};
+
+export class CursorIdePlugin extends BaseAgentAdapter {
+  constructor(metadata: AgentMetadata = CursorIdePluginMetadata) {
+    super(metadata);
+  }
+
+  override async isInstalled(): Promise<boolean> {
+    // Analytics-only: Cursor's installation state is irrelevant to CodeMie.
+    return true;
+  }
+
+  override async getVersion(): Promise<string | null> {
+    return null;
+  }
+}

src/agents/plugins/cursor-ide/cursor-ide.response.ts

@@ -0,0 +1,48 @@
+/**
+ * Cursor IDE stdout response contract.
+ *
+ * Cursor reads a JSON object off the hook process's stdout to decide how to
+ * proceed for a subset of its events - `{"permission":"allow"}` for
+ * tool-permission events, `{"continue":true}` for `beforeSubmitPrompt`.
+ * Every other event reads nothing from stdout, so this writer emits nothing
+ * for them: an unexpected stdout payload is exactly as unsafe here as a
+ * missing one.
+ *
+ * This module never decides *whether* to run - it is wired in declaratively
+ * via `AgentHookConfig.writeStdoutResponse` (see cursor-ide.plugin.ts), so
+ * `hook.ts` never needs an `if (agentName === 'cursor-ide')` branch to call
+ * it only for this agent.
+ *
+ * See: https://cursor.com/docs/hooks
+ */
+
+const ALLOW_RESPONSE = JSON.stringify({ permission: 'allow' });
+const CONTINUE_RESPONSE = JSON.stringify({ continue: true });
+
+/**
+ * Cursor-native event names (not the internal names they map onto) that
+ * carry a response contract.
+ */
+const CURSOR_STDOUT_RESPONSES: Readonly<Record<string, string>> = {
+  preToolUse: ALLOW_RESPONSE,
+  beforeShellExecution: ALLOW_RESPONSE,
+  beforeMCPExecution: ALLOW_RESPONSE,
+  beforeReadFile: ALLOW_RESPONSE,
+  beforeTabFileRead: ALLOW_RESPONSE,
+  subagentStart: ALLOW_RESPONSE,
+  beforeSubmitPrompt: CONTINUE_RESPONSE,
+};
+
+/**
+ * Writes Cursor's expected stdout response for `nativeEventName`, if any.
+ * A no-op for every event outside the response matrix above.
+ *
+ * @param nativeEventName - The Cursor-native event name (`hook_event_name`
+ *   on the raw/transformed payload - never the internal name it maps onto).
+ */
+export function writeCursorResponse(nativeEventName: string): void {
+  const response = CURSOR_STDOUT_RESPONSES[nativeEventName];
+  if (response) {
+    process.stdout.write(`${response}\n`);
+  }
+}

src/agents/registry.ts

@@ -9,6 +9,7 @@ import { KimiPlugin } from './plugins/kimi/kimi.plugin.js';
 import { KimiAcpPlugin } from './plugins/kimi/kimi-acp.plugin.js';
 import { OpenWikiPlugin } from './plugins/openwiki/openwiki.plugin.js';
 import { CopilotCliPlugin } from './plugins/copilot-cli/index.js';
+import { CursorIdePlugin } from './plugins/cursor-ide/cursor-ide.plugin.js';
 import { AgentAdapter, AgentAnalyticsAdapter } from './core/types.js';
 
 // Re-export for backwards compatibility
@@ -43,6 +44,7 @@ export class AgentRegistry {
     AgentRegistry.registerPlugin(new KimiAcpPlugin());
     AgentRegistry.registerPlugin(new OpenWikiPlugin());
     AgentRegistry.registerPlugin(new CopilotCliPlugin());
+    AgentRegistry.registerPlugin(new CursorIdePlugin());
 
     AgentRegistry.initialized = true;
   }