@ken-jo/agent-connector 0.1.0

package/dist/cursor-4TMXKJOZ.js

@@ -0,0 +1,603 @@
+#!/usr/bin/env node
+import {
+  rewriteEnvRefs
+} from "./chunk-DBQMX75U.js";
+import {
+  BaseAdapter
+} from "./chunk-TIIP3RG2.js";
+import "./chunk-7L6ITC4T.js";
+import {
+  buildHomeBinHookCommand,
+  buildServeWrapperCommand,
+  isHomeBinHookCommand,
+  shouldWrapForTelemetry
+} from "./chunk-MEH7GC7R.js";
+import "./chunk-TRQKHP7D.js";
+
+// src/adapters/cursor/index.ts
+import { existsSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var HOST = "cursor";
+var MCP_ROOT_KEY = "mcpServers";
+var CURSOR_HOOKS_VERSION = 1;
+var CURSOR_EVENT = {
+  PreToolUse: "preToolUse",
+  PostToolUse: "postToolUse",
+  SessionStart: "sessionStart",
+  Stop: "stop"
+};
+var EVENT_MAP = {
+  PreToolUse: CURSOR_EVENT.PreToolUse,
+  PostToolUse: CURSOR_EVENT.PostToolUse,
+  SessionStart: CURSOR_EVENT.SessionStart,
+  Stop: CURSOR_EVENT.Stop
+};
+var CursorAdapter = class extends BaseAdapter {
+  id = HOST;
+  name = "Cursor";
+  paradigm = "json-stdio";
+  capabilities = {
+    // Cursor natively supports pre/post tool-use, session start, and stop.
+    preToolUse: true,
+    postToolUse: true,
+    preCompact: false,
+    sessionStart: true,
+    sessionEnd: false,
+    userPromptSubmit: false,
+    stop: true,
+    notification: false,
+    // Cursor's preToolUse can rewrite tool input (updated_input) but cannot
+    // rewrite already-emitted tool output.
+    canModifyArgs: true,
+    canModifyOutput: false,
+    canInjectSessionContext: true,
+    transports: ["stdio", "http"],
+    // Content surfaces: Cursor supports all three (commands, skills, subagents).
+    supportsCommands: true,
+    supportsSkills: true,
+    supportsSubagents: true
+  };
+  // ── Detection ────────────────────────────────────────────────────────────
+  detectInstalled(projectDir) {
+    const userDir = join(homedir(), ".cursor");
+    const userMcp = join(userDir, "mcp.json");
+    const userHooks = join(userDir, "hooks.json");
+    const projectDirCursor = join(projectDir, ".cursor");
+    const installed = existsSync(userDir) || existsSync(userMcp) || existsSync(userHooks) || existsSync(projectDirCursor);
+    return {
+      id: this.id,
+      name: this.name,
+      installed,
+      paradigm: this.paradigm,
+      capabilities: this.capabilities,
+      configPath: userMcp,
+      scope: "user",
+      reason: installed ? `found Cursor config under ${userDir}` : `no Cursor config at ${userDir}`,
+      confidence: installed ? "high" : "low"
+    };
+  }
+  // ── Native paths ─────────────────────────────────────────────────────────
+  getConfigDir(ctx) {
+    return ctx.scope === "project" ? join(ctx.projectDir, ".cursor") : join(homedir(), ".cursor");
+  }
+  getServerConfigPath(ctx) {
+    return join(this.getConfigDir(ctx), "mcp.json");
+  }
+  getHookConfigPath(ctx) {
+    return join(this.getConfigDir(ctx), "hooks.json");
+  }
+  // ── MCP server install / uninstall ───────────────────────────────────────
+  installServer(ctx) {
+    const { connector } = ctx;
+    const override = connector.platforms[HOST]?.server;
+    if (!connector.server || override === false) {
+      return [
+        {
+          platform: this.id,
+          action: "skip",
+          detail: connector.server ? "server registration disabled for cursor" : "connector declares no MCP server"
+        }
+      ];
+    }
+    const server = override && typeof override === "object" ? { ...connector.server, ...override } : connector.server;
+    const serverPath = this.getServerConfigPath(ctx);
+    const entry = this.renderServerEntry(ctx, server);
+    return [
+      this.upsertServerInJson(serverPath, MCP_ROOT_KEY, connector.id, entry, ctx.dryRun)
+    ];
+  }
+  uninstallServer(ctx) {
+    const serverPath = this.getServerConfigPath(ctx);
+    return [
+      this.removeServerFromJson(serverPath, MCP_ROOT_KEY, ctx.connector.id, ctx.dryRun)
+    ];
+  }
+  /** Render a normalized ServerDef into Cursor's native mcpServers entry. */
+  renderServerEntry(ctx, server) {
+    const transport = server.transport;
+    if (transport === "stdio") {
+      let command = server.command ?? "";
+      let args = [...server.args ?? []];
+      if (shouldWrapForTelemetry(server, ctx.connector.telemetry)) {
+        const wrapped = buildServeWrapperCommand(
+          ctx.homeBinPath,
+          ctx.connector.id,
+          command,
+          args,
+          ctx.scope,
+          this.id
+        );
+        command = wrapped.command;
+        args = wrapped.args;
+      }
+      const entry2 = { command: this.rewrite(command) };
+      if (args.length > 0) entry2.args = args.map((a) => this.rewrite(a));
+      const env = this.renderEnv(server.env);
+      if (env) entry2.env = env;
+      if (server.cwd) entry2.cwd = this.rewrite(server.cwd);
+      return entry2;
+    }
+    const entry = { url: this.rewrite(server.url ?? "") };
+    const headers = this.renderEnv(server.headers);
+    if (headers) entry.headers = headers;
+    return entry;
+  }
+  /**
+   * Render env/header values. Cursor supports its own `${env:VAR}` native
+   * interpolation, so translate `${env:VAR}` refs to that native token rather
+   * than baking secrets into the file. Literals pass through unchanged.
+   */
+  renderEnv(env) {
+    if (!env || Object.keys(env).length === 0) return void 0;
+    const out = {};
+    for (const [k, v] of Object.entries(env)) out[k] = this.rewrite(v);
+    return out;
+  }
+  /** Translate `${env:VAR(:-default)}` to Cursor's native `${env:VAR}` token. */
+  rewrite(value) {
+    return rewriteEnvRefs(value, cursorEnvToken);
+  }
+  // ── Hook install / uninstall ─────────────────────────────────────────────
+  installHooks(ctx) {
+    const { connector } = ctx;
+    if (connector.platforms[HOST]?.hooks === false) {
+      return [{ platform: this.id, action: "skip", detail: "hooks disabled for cursor" }];
+    }
+    if (connector.hookEvents.length === 0) {
+      return [{ platform: this.id, action: "skip", detail: "connector declares no hooks" }];
+    }
+    const hooksPath = this.getHookConfigPath(ctx);
+    const file = this.readJson(hooksPath) ?? {};
+    const hooks = file.hooks ??= {};
+    const changes = [];
+    let mutated = false;
+    for (const event of connector.hookEvents) {
+      const cursorEvent = EVENT_MAP[event];
+      if (!cursorEvent) {
+        changes.push({
+          platform: this.id,
+          action: "warn",
+          path: hooksPath,
+          detail: `${event} has no Cursor hook equivalent \u2014 skipped`
+        });
+        continue;
+      }
+      const command = buildHomeBinHookCommand(ctx.homeBinPath, HOST, event, connector.id);
+      const matcher = connector.hooks[event]?.matcher;
+      const entry = matcher ? { command, matcher } : { command };
+      const bucket = hooks[cursorEvent] ??= [];
+      const existingIdx = bucket.findIndex((e) => this.isOurCommand(e.command, ctx));
+      if (existingIdx >= 0) {
+        if (JSON.stringify(bucket[existingIdx]) === JSON.stringify(entry)) {
+          changes.push({
+            platform: this.id,
+            action: "skip",
+            path: hooksPath,
+            detail: `hooks.${cursorEvent} already registered`
+          });
+          continue;
+        }
+        bucket[existingIdx] = entry;
+        changes.push({
+          platform: this.id,
+          action: "update",
+          path: hooksPath,
+          detail: `hooks.${cursorEvent}`
+        });
+      } else {
+        bucket.push(entry);
+        changes.push({
+          platform: this.id,
+          action: "create",
+          path: hooksPath,
+          detail: `hooks.${cursorEvent}`
+        });
+      }
+      mutated = true;
+    }
+    if (mutated) {
+      file.version = CURSOR_HOOKS_VERSION;
+      this.writeJson(hooksPath, file, ctx.dryRun);
+    }
+    return changes;
+  }
+  uninstallHooks(ctx) {
+    const hooksPath = this.getHookConfigPath(ctx);
+    const file = this.readJson(hooksPath);
+    const hooks = file?.hooks;
+    if (!file || !hooks) {
+      return [
+        {
+          platform: this.id,
+          action: "skip",
+          path: hooksPath,
+          detail: "no hooks section present"
+        }
+      ];
+    }
+    const changes = [];
+    let mutated = false;
+    for (const cursorEvent of Object.keys(hooks)) {
+      const bucket = hooks[cursorEvent];
+      if (!Array.isArray(bucket)) continue;
+      const before = bucket.length;
+      const next = bucket.filter((e) => !this.isOurCommand(e.command, ctx));
+      const removed = before - next.length;
+      if (removed > 0) {
+        if (next.length > 0) hooks[cursorEvent] = next;
+        else delete hooks[cursorEvent];
+        changes.push({
+          platform: this.id,
+          action: "remove",
+          path: hooksPath,
+          detail: `hooks.${cursorEvent} (${removed})`
+        });
+        mutated = true;
+      }
+    }
+    if (mutated) this.writeJson(hooksPath, file, ctx.dryRun);
+    if (changes.length === 0) {
+      changes.push({
+        platform: this.id,
+        action: "skip",
+        path: hooksPath,
+        detail: "no matching hook entries"
+      });
+    }
+    return changes;
+  }
+  /** True when a hook command references our home binary AND this connector id
+   *  (anchored so a shared-prefix id can't collide — see isHomeBinHookCommand). */
+  isOurCommand(command, ctx) {
+    return isHomeBinHookCommand(command, ctx.homeBinPath, ctx.connector.id);
+  }
+  // ── Content surfaces: commands / skills / subagents ──────────────────────
+  // CONTENT-ONLY: pure native-file writers under <configDir>/{commands,skills,
+  // agents}. No runtime dispatch, no home-bin pointer, no telemetry wrap. Each
+  // method is idempotent (byte-identical → skip) via BaseAdapter.writeContentFile
+  // and reversible via removeContentFile. Honors platforms["cursor"] per-surface
+  // false to skip. Cursor commands are BODY-ONLY markdown (no frontmatter);
+  // skills are the uniform <name>/SKILL.md + resources; subagents are md+fm.
+  commandsDir(ctx) {
+    return join(this.getConfigDir(ctx), "commands");
+  }
+  skillsDir(ctx) {
+    return join(this.getConfigDir(ctx), "skills");
+  }
+  agentsDir(ctx) {
+    return join(this.getConfigDir(ctx), "agents");
+  }
+  /** Native command file path: <configDir>/commands/<name>.md. */
+  commandPath(ctx, name) {
+    return join(this.commandsDir(ctx), `${name}.md`);
+  }
+  /** Native skill dir: <configDir>/skills/<name>. */
+  skillDir(ctx, name) {
+    return join(this.skillsDir(ctx), name);
+  }
+  /** Native subagent file path: <configDir>/agents/<name>.md. */
+  subagentPath(ctx, name) {
+    return join(this.agentsDir(ctx), `${name}.md`);
+  }
+  // ── Commands ──────────────────────────────────────────────────────────────
+  installCommands(ctx) {
+    const { connector } = ctx;
+    if (connector.platforms[HOST]?.commands === false) {
+      return [{ platform: this.id, action: "skip", detail: "commands disabled for cursor" }];
+    }
+    if (connector.commands.length === 0) {
+      return [{ platform: this.id, action: "skip", detail: "connector declares no commands" }];
+    }
+    return connector.commands.map(
+      (cmd) => this.writeContentFile(
+        this.commandPath(ctx, cmd.name),
+        this.renderCommand(cmd),
+        ctx.dryRun
+      )
+    );
+  }
+  uninstallCommands(ctx) {
+    const { connector } = ctx;
+    if (connector.commands.length === 0) {
+      return [{ platform: this.id, action: "skip", detail: "connector declares no commands" }];
+    }
+    return connector.commands.map(
+      (cmd) => this.removeContentFile(this.commandPath(ctx, cmd.name), ctx.dryRun)
+    );
+  }
+  /**
+   * Render a Cursor command: BODY-ONLY markdown (no frontmatter). Cursor reads
+   * the file as the command prompt verbatim. We prepend the one-line description
+   * as an HTML comment header when present so authoring intent survives the
+   * round-trip without leaking into the rendered prompt. A description containing
+   * "-->" would prematurely CLOSE the HTML comment and leak the remainder into
+   * the prompt, so we neutralize that sequence before embedding it.
+   */
+  renderCommand(cmd) {
+    if (!cmd.description) return `${cmd.prompt}
+`;
+    const safe = cmd.description.replace(/--+>/g, (m) => m.replace(/>/g, "&gt;"));
+    return `<!-- ${safe} -->
+
+${cmd.prompt}
+`;
+  }
+  // ── Skills ────────────────────────────────────────────────────────────────
+  installSkills(ctx) {
+    const { connector } = ctx;
+    if (connector.platforms[HOST]?.skills === false) {
+      return [{ platform: this.id, action: "skip", detail: "skills disabled for cursor" }];
+    }
+    if (connector.skills.length === 0) {
+      return [{ platform: this.id, action: "skip", detail: "connector declares no skills" }];
+    }
+    const changes = [];
+    for (const skill of connector.skills) {
+      const dir = this.skillDir(ctx, skill.name);
+      changes.push(
+        this.writeContentFile(join(dir, "SKILL.md"), this.renderSkill(skill), ctx.dryRun)
+      );
+      for (const [rel, contents] of Object.entries(skill.resources ?? {})) {
+        const target = this.resolveWithin(dir, rel);
+        if (target === null) {
+          changes.push({
+            platform: this.id,
+            action: "warn",
+            detail: `skill resource "${rel}" escapes the skill dir; skipped`
+          });
+          continue;
+        }
+        changes.push(this.writeContentFile(target, contents, ctx.dryRun));
+      }
+    }
+    return changes;
+  }
+  uninstallSkills(ctx) {
+    const { connector } = ctx;
+    if (connector.skills.length === 0) {
+      return [{ platform: this.id, action: "skip", detail: "connector declares no skills" }];
+    }
+    const changes = [];
+    for (const skill of connector.skills) {
+      const dir = this.skillDir(ctx, skill.name);
+      changes.push(this.removeContentFile(join(dir, "SKILL.md"), ctx.dryRun));
+      for (const rel of Object.keys(skill.resources ?? {})) {
+        const target = this.resolveWithin(dir, rel);
+        if (target === null) continue;
+        changes.push(this.removeContentFile(target, ctx.dryRun));
+      }
+      changes.push(this.removeDirIfEmpty(dir, ctx.dryRun));
+    }
+    return changes;
+  }
+  /**
+   * Render a skill's SKILL.md: frontmatter (name, description + optional model,
+   * allowed-tools, disable-model-invocation) + body. Uniform across platforms;
+   * only the parent dir differs.
+   */
+  renderSkill(skill) {
+    const frontmatter = {
+      name: skill.name,
+      description: skill.description
+    };
+    if (skill.model !== void 0) frontmatter.model = skill.model;
+    const allow = skill.tools?.allow;
+    if (allow && allow.length > 0) frontmatter["allowed-tools"] = allow.join(", ");
+    if (skill.disableModelInvocation !== void 0) {
+      frontmatter["disable-model-invocation"] = skill.disableModelInvocation;
+    }
+    if (skill.extra) Object.assign(frontmatter, skill.extra);
+    return this.renderFrontmatterMd(frontmatter, skill.body);
+  }
+  // ── Subagents ───────────────────────────────────────────────────────────────
+  installSubagents(ctx) {
+    const { connector } = ctx;
+    if (connector.platforms[HOST]?.subagents === false) {
+      return [{ platform: this.id, action: "skip", detail: "subagents disabled for cursor" }];
+    }
+    if (connector.subagents.length === 0) {
+      return [{ platform: this.id, action: "skip", detail: "connector declares no subagents" }];
+    }
+    return connector.subagents.map(
+      (agent) => this.writeContentFile(
+        this.subagentPath(ctx, agent.name),
+        this.renderSubagent(agent),
+        ctx.dryRun
+      )
+    );
+  }
+  uninstallSubagents(ctx) {
+    const { connector } = ctx;
+    if (connector.subagents.length === 0) {
+      return [{ platform: this.id, action: "skip", detail: "connector declares no subagents" }];
+    }
+    return connector.subagents.map(
+      (agent) => this.removeContentFile(this.subagentPath(ctx, agent.name), ctx.dryRun)
+    );
+  }
+  /** Render a Cursor subagent to md+frontmatter (name, description, model, readonly) + prompt body. */
+  renderSubagent(agent) {
+    const frontmatter = {
+      name: agent.name,
+      description: agent.description
+    };
+    if (agent.model !== void 0) frontmatter.model = agent.model;
+    if (agent.readonly !== void 0) frontmatter.readonly = agent.readonly;
+    if (agent.extra) Object.assign(frontmatter, agent.extra);
+    return this.renderFrontmatterMd(frontmatter, agent.prompt);
+  }
+  // ── Diagnostics ──────────────────────────────────────────────────────────
+  getHealthChecks(ctx) {
+    const mcpPath = this.getServerConfigPath(ctx);
+    const hooksPath = this.getHookConfigPath(ctx);
+    const checks = [
+      {
+        name: `${this.name}: mcp.json present`,
+        check: () => existsSync(mcpPath) ? { status: "OK", detail: mcpPath } : { status: "FAIL", detail: `not found: ${mcpPath}` }
+      },
+      {
+        name: `${this.name}: hooks.json present`,
+        check: () => existsSync(hooksPath) ? { status: "OK", detail: hooksPath } : { status: "FAIL", detail: `not found: ${hooksPath}` }
+      }
+    ];
+    for (const cmd of ctx.connector.commands) {
+      const p = this.commandPath(ctx, cmd.name);
+      checks.push({
+        name: `${this.name}: command ${cmd.name} present`,
+        check: () => existsSync(p) ? { status: "OK", detail: p } : { status: "FAIL", detail: `not found: ${p}` }
+      });
+    }
+    for (const skill of ctx.connector.skills) {
+      const p = join(this.skillDir(ctx, skill.name), "SKILL.md");
+      checks.push({
+        name: `${this.name}: skill ${skill.name} present`,
+        check: () => existsSync(p) ? { status: "OK", detail: p } : { status: "FAIL", detail: `not found: ${p}` }
+      });
+    }
+    for (const agent of ctx.connector.subagents) {
+      const p = this.subagentPath(ctx, agent.name);
+      checks.push({
+        name: `${this.name}: subagent ${agent.name} present`,
+        check: () => existsSync(p) ? { status: "OK", detail: p } : { status: "FAIL", detail: `not found: ${p}` }
+      });
+    }
+    return checks;
+  }
+  // ── Runtime: parse Cursor stdin JSON → normalized event ──────────────────
+  parseEvent(event, raw) {
+    const input = raw ?? {};
+    const connectorId = typeof input.connector === "string" ? input.connector : "";
+    const sessionId = extractSessionId(input);
+    const projectDir = this.getProjectDir(input);
+    const base = {
+      hostPlatform: HOST,
+      connectorId,
+      sessionId,
+      raw,
+      ...projectDir !== void 0 ? { projectDir } : {}
+    };
+    switch (event) {
+      case "PreToolUse": {
+        const ev = {
+          ...base,
+          toolName: input.tool_name ?? "",
+          toolInput: input.tool_input ?? {}
+        };
+        return ev;
+      }
+      case "PostToolUse": {
+        const toolOutput = input.tool_output ?? input.error_message;
+        const ev = {
+          ...base,
+          toolName: input.tool_name ?? "",
+          toolInput: input.tool_input ?? {},
+          ...toolOutput !== void 0 ? { toolOutput } : {},
+          ...input.error_message ? { isError: true } : {}
+        };
+        return ev;
+      }
+      case "SessionStart": {
+        const ev = {
+          ...base,
+          source: normalizeSessionSource(input.source ?? input.trigger)
+        };
+        return ev;
+      }
+      case "Stop": {
+        const ev = {
+          ...base,
+          ...typeof input.stop_hook_active === "boolean" ? { stopHookActive: input.stop_hook_active } : {}
+        };
+        return ev;
+      }
+      default: {
+        throw new Error(`unsupported cursor hook event: ${String(event)}`);
+      }
+    }
+  }
+  getProjectDir(input) {
+    return input.cwd ?? input.workspace_roots?.[0] ?? void 0;
+  }
+  // ── Runtime: normalized response → Cursor native hook reply ──────────────
+  formatReply(event, response) {
+    const decision = response.decision ?? "allow";
+    if (decision === "deny") {
+      return this.stdout({
+        permission: "deny",
+        user_message: response.reason ?? "Blocked by hook"
+      });
+    }
+    if (decision === "ask") {
+      return this.stdout({
+        permission: "ask",
+        user_message: response.reason ?? "Confirmation required by hook"
+      });
+    }
+    if (decision === "modify") {
+      if (event === "PreToolUse" && response.updatedInput) {
+        return this.stdout({ updated_input: response.updatedInput });
+      }
+    }
+    if (decision === "context" && response.additionalContext) {
+      return event === "PreToolUse" ? this.stdout({ agent_message: response.additionalContext }) : this.stdout({ additional_context: response.additionalContext });
+    }
+    if (event === "SessionStart") {
+      return this.stdout({ additional_context: response.additionalContext ?? "" });
+    }
+    if (event === "PreToolUse") return this.stdout({ agent_message: "" });
+    if (event === "PostToolUse") return this.stdout({ additional_context: "" });
+    return { exitCode: 0 };
+  }
+  stdout(payload) {
+    return { exitCode: 0, stdout: JSON.stringify(payload) };
+  }
+};
+function cursorEnvToken(name) {
+  return `\${env:${name}}`;
+}
+function extractSessionId(input) {
+  if (typeof input.conversation_id === "string") return input.conversation_id;
+  if (typeof input.session_id === "string") return input.session_id;
+  return "";
+}
+function normalizeSessionSource(source) {
+  switch (source) {
+    case "compact":
+      return "compact";
+    case "resume":
+      return "resume";
+    case "clear":
+      return "clear";
+    default:
+      return "startup";
+  }
+}
+var adapter = new CursorAdapter();
+var cursor_default = adapter;
+export {
+  CursorAdapter,
+  adapter,
+  cursor_default as default
+};
+//# sourceMappingURL=cursor-4TMXKJOZ.js.map