@stablekernel/opencode-cursor 0.8.0 → 0.9.0-next.0

package/dist/plugin/index.js

@@ -18,7 +18,8 @@ import {
 } from "../chunk-YIEC27VB.js";
 
 // src/plugin/index.ts
-import { rmSync as rmSync3 } from "fs";
+import { rmSync as rmSync4 } from "fs";
+import { homedir as homedir5 } from "os";
 import semver2 from "semver";
 
 // src/model-limits.ts
@@ -813,7 +814,7 @@ function clearVersionCache() {
   }
 }
 function getLocalVersion() {
-  if (true) return "0.8.0";
+  if (true) return "0.9.0-next.0";
   try {
     const require2 = createRequire(import.meta.url);
     const pkg = require2("../package.json");
@@ -869,11 +870,11 @@ async function getLatestVersion() {
 
 // src/provider/skill-mirror.ts
 import {
-  mkdirSync as mkdirSync3,
-  writeFileSync as writeFileSync3,
+  mkdirSync as mkdirSync4,
+  writeFileSync as writeFileSync4,
   readFileSync as readFileSync4,
   existsSync as existsSync2,
-  rmSync as rmSync2,
+  rmSync as rmSync3,
   readdirSync as readdirSync2,
   statSync as statSync2,
   copyFileSync,
@@ -887,10 +888,20 @@ import {
   readFileSync as readFileSync3,
   statSync,
   existsSync,
-  realpathSync
+  realpathSync,
+  mkdtempSync,
+  mkdirSync as mkdirSync3,
+  rmSync as rmSync2,
+  writeFileSync as writeFileSync3
 } from "fs";
-import { join as join3, relative, dirname, resolve as resolvePath, isAbsolute } from "path";
-import { homedir as homedir3 } from "os";
+import {
+  join as join3,
+  relative,
+  dirname,
+  resolve as resolvePath,
+  isAbsolute
+} from "path";
+import { homedir as homedir3, tmpdir as tmpdir3 } from "os";
 import { execSync } from "child_process";
 function parseFrontmatter(content) {
   if (!content.startsWith("---")) return {};
@@ -915,6 +926,112 @@ function parseFrontmatter(content) {
 }
 var SKILL_DIR_NAMES = ["skill", "skills"];
 var EXTERNAL_DIR_NAMES = [".claude", ".agents"];
+var FILE_PLUGIN_DIR_NAMES = ["plugin", "plugins"];
+var PLUGIN_SKILL_DIR_NAMES = ["skills", "skill"];
+function opencodePackagesRoot(home = homedir3()) {
+  if (process.platform === "win32") {
+    return join3(
+      process.env.LocalAppData ?? join3(home, "AppData", "Local"),
+      "opencode",
+      "cache",
+      "packages"
+    );
+  }
+  return join3(
+    process.env.XDG_CACHE_HOME ?? join3(home, ".cache"),
+    "opencode",
+    "packages"
+  );
+}
+function pluginCacheSkillDirs(entry) {
+  const dirs = [];
+  const visited = /* @__PURE__ */ new Set();
+  function scanNodeModules(nodeModules) {
+    let entries;
+    try {
+      entries = readdirSync(nodeModules, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const ent of entries) {
+      if (ent.name === ".bin") continue;
+      const fullPath = join3(nodeModules, ent.name);
+      if (entryKind(ent, fullPath) !== "dir") continue;
+      if (ent.name.startsWith("@")) {
+        scanNodeModules(fullPath);
+        continue;
+      }
+      for (const skillName of SKILL_DIR_NAMES) {
+        const candidate = join3(fullPath, skillName);
+        if (existsSync(candidate)) dirs.push(candidate);
+      }
+    }
+  }
+  function findNodeModules(dir, depth) {
+    if (depth > 5) return;
+    let realDir;
+    try {
+      realDir = realpathSync(dir);
+    } catch {
+      return;
+    }
+    if (visited.has(realDir)) return;
+    visited.add(realDir);
+    const nm = join3(dir, "node_modules");
+    if (existsSync(nm)) {
+      scanNodeModules(nm);
+      return;
+    }
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const ent of entries) {
+      const fullPath = join3(dir, ent.name);
+      if (entryKind(ent, fullPath) === "dir") {
+        findNodeModules(fullPath, depth + 1);
+      }
+    }
+  }
+  findNodeModules(entry, 0);
+  return dirs;
+}
+function pluginCacheEntries(root) {
+  let entries;
+  try {
+    entries = readdirSync(root, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const skip = /* @__PURE__ */ new Set([
+    "node_modules",
+    "package.json",
+    "package-lock.json",
+    "bun.lock",
+    "bun.lockb"
+  ]);
+  const out = [];
+  for (const ent of entries) {
+    if (skip.has(ent.name)) continue;
+    const full = join3(root, ent.name);
+    if (entryKind(ent, full) !== "dir") continue;
+    out.push(full);
+  }
+  return out;
+}
+function discoverPluginSkillDirs(cacheRoot, home) {
+  const root = cacheRoot ?? opencodePackagesRoot(home);
+  if (!existsSync(root)) return [];
+  const dirs = [];
+  for (const entry of pluginCacheEntries(root)) {
+    for (const skillDir of pluginCacheSkillDirs(entry)) {
+      dirs.push(skillDir);
+    }
+  }
+  return dirs;
+}
 function worktreeRoot(cwd) {
   try {
     const root = execSync("git rev-parse --show-toplevel", {
@@ -1025,7 +1142,39 @@ function expandSkillPath(raw, cwd, home) {
   if (isAbsolute(trimmed)) return trimmed;
   return resolvePath(cwd, trimmed);
 }
-function discoverSkills(cwd, extraPaths) {
+function discoverFilePluginSkillDirs(roots) {
+  const dirs = [];
+  for (const root of roots) {
+    for (const sub of FILE_PLUGIN_DIR_NAMES) {
+      const pluginDir = join3(root, sub);
+      if (!existsSync(pluginDir)) continue;
+      for (const skillName of PLUGIN_SKILL_DIR_NAMES) {
+        const skillDir = join3(pluginDir, skillName);
+        if (existsSync(skillDir)) dirs.push(skillDir);
+      }
+    }
+  }
+  return dirs;
+}
+function resolvePluginSkillSources(cwd) {
+  const home = homedir3();
+  const cacheRoot = opencodePackagesRoot(home);
+  let filePluginRoots = [];
+  try {
+    const candidates = [];
+    const start = cwd ?? process.cwd();
+    const stop = worktreeRoot(start);
+    for (const ancestor of walkUp(start, stop)) {
+      candidates.push(join3(ancestor, ".opencode"));
+    }
+    const xdgConfig = process.env["XDG_CONFIG_HOME"] || join3(home, ".config");
+    candidates.push(join3(xdgConfig, "opencode"), home);
+    filePluginRoots = discoverFilePluginSkillDirs(candidates).map((dir) => dirname(dirname(dir))).filter((v, i, arr) => arr.indexOf(v) === i);
+  } catch {
+  }
+  return { cacheRoot, filePluginRoots };
+}
+function discoverSkills(cwd, extraPaths, options) {
   const home = homedir3();
   const xdgConfig = process.env["XDG_CONFIG_HOME"] || join3(home, ".config");
   const stop = worktreeRoot(cwd);
@@ -1060,6 +1209,29 @@ function discoverSkills(cwd, extraPaths) {
       scanRoots.push(expanded);
     }
   }
+  for (const dir of discoverPluginSkillDirs(options?.cacheRoot, home)) {
+    scanRoots.push(dir);
+  }
+  const filePluginRoots = options?.filePluginRoots;
+  if (filePluginRoots) {
+    for (const dir of discoverFilePluginSkillDirs(filePluginRoots)) {
+      scanRoots.push(dir);
+    }
+  } else {
+    for (const ancestor of walkUp(cwd, stop)) {
+      for (const dir of discoverFilePluginSkillDirs([
+        join3(ancestor, ".opencode")
+      ])) {
+        scanRoots.push(dir);
+      }
+    }
+    for (const dir of discoverFilePluginSkillDirs([
+      join3(xdgConfig, "opencode"),
+      home
+    ])) {
+      scanRoots.push(dir);
+    }
+  }
   const byId = /* @__PURE__ */ new Map();
   for (const dir of scanRoots) {
     const found = scanSkillDir(dir);
@@ -1150,15 +1322,82 @@ function filterSkills(skills, config, options) {
   }
   return { skills: permitted, withheld };
 }
-function resolveSkills(cwd, config, options) {
+var liveScratchRoot;
+var liveScratchCleanupRegistered = false;
+function liveScratchDir() {
+  if (!liveScratchRoot) {
+    liveScratchRoot = mkdtempSync(join3(tmpdir3(), "opencode-cursor-skills-"));
+    if (!liveScratchCleanupRegistered) {
+      liveScratchCleanupRegistered = true;
+      const rootAtExit = liveScratchRoot;
+      process.once("exit", () => {
+        rmSync2(rootAtExit, { recursive: true, force: true });
+      });
+    }
+  }
+  return liveScratchRoot;
+}
+function liveSkillsToDiscovered(live) {
+  const out = [];
+  for (const skill of live) {
+    if (!skill.location || !skill.name) continue;
+    const sourceDir = skill.location.endsWith("SKILL.md") ? dirname(skill.location) : skill.location;
+    if (existsSync(join3(sourceDir, "SKILL.md"))) {
+      const loaded2 = loadSkill(skill.name, sourceDir);
+      if (loaded2) out.push(loaded2);
+      continue;
+    }
+    if (!skill.content) continue;
+    const scratchDir = join3(liveScratchDir(), skill.name);
+    const scratchMd = join3(scratchDir, "SKILL.md");
+    let needsWrite = true;
+    if (existsSync(scratchMd)) {
+      try {
+        const existing = readFileSync3(scratchMd, "utf8");
+        if (existing === renderLiveSkillMd(skill)) needsWrite = false;
+      } catch {
+      }
+    }
+    if (needsWrite) {
+      try {
+        mkdirSync3(scratchDir, { recursive: true });
+        writeFileSync3(scratchMd, renderLiveSkillMd(skill), "utf8");
+      } catch {
+        continue;
+      }
+    }
+    const loaded = loadSkill(skill.name, scratchDir);
+    if (loaded) out.push(loaded);
+  }
+  return out;
+}
+function renderLiveSkillMd(skill) {
+  const escaped = (skill.description ?? "").replace(/"/g, '\\"');
+  const body = skill.content ?? "";
+  const separator = body.startsWith("\n") ? "" : "\n";
+  return `---
+name: ${skill.name}
+description: "${escaped}"
+---
+${separator}${body}`;
+}
+function resolveSkills(cwd, config, options, discoveryOptions) {
   const skillsConfig = config;
   const extraPaths = skillsConfig?.skills?.paths;
   let discovered;
   try {
-    discovered = discoverSkills(cwd, extraPaths);
+    discovered = discoverSkills(cwd, extraPaths, discoveryOptions);
   } catch {
     discovered = [];
   }
+  if (discoveryOptions?.liveSkills?.length) {
+    const seen = new Set(discovered.map((s2) => s2.id));
+    for (const skill of liveSkillsToDiscovered(discoveryOptions.liveSkills)) {
+      if (seen.has(skill.id)) continue;
+      seen.add(skill.id);
+      discovered.push(skill);
+    }
+  }
   return filterSkills(discovered, config, options);
 }
 function skillSetHash(skills) {
@@ -1253,7 +1492,7 @@ function copyTree(srcDir, destDir, skillId, maxBytes, warn) {
             );
             continue;
           }
-          mkdirSync3(dirname2(destPath), { recursive: true });
+          mkdirSync4(dirname2(destPath), { recursive: true });
           copyFileSync(srcPath, destPath);
           bytes += size;
         } catch {
@@ -1267,8 +1506,8 @@ function copyTree(srcDir, destDir, skillId, maxBytes, warn) {
 function writeIfChanged(path, content) {
   const existing = existsSync2(path) ? readFileSync4(path, "utf8") : void 0;
   if (existing === content) return false;
-  mkdirSync3(dirname2(path), { recursive: true });
-  writeFileSync3(path, content, "utf8");
+  mkdirSync4(dirname2(path), { recursive: true });
+  writeFileSync4(path, content, "utf8");
   return true;
 }
 function ensureGitIgnored(dir, skillIds) {
@@ -1281,7 +1520,7 @@ function ensureGitIgnored(dir, skillIds) {
   if (missing.length === 0) return;
   const prefix = existing && !existing.endsWith("\n") ? `${existing}
 ` : existing;
-  writeFileSync3(path, `${prefix}${missing.join("\n")}
+  writeFileSync4(path, `${prefix}${missing.join("\n")}
 `, "utf8");
 }
 function writeSkillMirror(cwd, skills, warn) {
@@ -1389,7 +1628,7 @@ function pruneStale(cwd, currentIds, warn) {
     try {
       const content = readFileSync4(skillMdPath, "utf8");
       if (isGenerated(content)) {
-        rmSync2(join4(dir, entry.name), { recursive: true, force: true });
+        rmSync3(join4(dir, entry.name), { recursive: true, force: true });
         removed = true;
       }
     } catch {
@@ -1408,7 +1647,7 @@ function removeSkillMirror(cwd) {
       if (!existsSync2(skillMdPath)) continue;
       try {
         if (isGenerated(readFileSync4(skillMdPath, "utf8"))) {
-          rmSync2(join4(dir, entry.name), { recursive: true, force: true });
+          rmSync3(join4(dir, entry.name), { recursive: true, force: true });
         }
       } catch {
       }
@@ -1428,7 +1667,7 @@ function removeSkillMirror(cwd) {
       const ignorePath = join4(dir, IGNORE_FILE);
       if (existsSync2(ignorePath)) {
         try {
-          rmSync2(ignorePath);
+          rmSync3(ignorePath);
         } catch {
         }
       }
@@ -1450,10 +1689,449 @@ function buildSkillsCatalogue(skills) {
   ].join("\n");
 }
 
+// src/plugin/plugin-tool-registry.ts
+import { existsSync as existsSync3, readdirSync as readdirSync3, statSync as statSync3 } from "fs";
+import { join as join5 } from "path";
+import { createRequire as createRequire2 } from "module";
+import { pathToFileURL } from "url";
+import { homedir as homedir4 } from "os";
+import { tool as tool2 } from "@opencode-ai/plugin";
+var SELF_SPECS = /* @__PURE__ */ new Set([
+  "@stablekernel/opencode-cursor",
+  "@stablekernel/opencode-cursor@latest"
+]);
+function parsePluginSpec(spec) {
+  const trimmed = spec.trim();
+  if (!trimmed) return void 0;
+  if (trimmed.startsWith("/") || trimmed.startsWith("./") || trimmed.startsWith("../") || trimmed.startsWith("~/") || /\.[cm]?[jt]sx?$/.test(trimmed)) {
+    const expanded = trimmed.startsWith("~/") ? join5(homedir4(), trimmed.slice(2)) : trimmed;
+    return { kind: "path", path: expanded };
+  }
+  const at = trimmed.lastIndexOf("@");
+  if (at > 0) {
+    const name = trimmed.slice(0, at);
+    const version = trimmed.slice(at + 1);
+    if (version.startsWith("git+")) {
+      return { kind: "git", name, raw: trimmed };
+    }
+    if (version.includes("://")) {
+      return { kind: "unsupported", raw: trimmed };
+    }
+    return { kind: "npm", name, version };
+  }
+  return { kind: "npm", name: trimmed };
+}
+function resolveCacheEntry(cacheRoot, parsed) {
+  if (parsed.kind === "unsupported") return void 0;
+  if (parsed.kind === "git") {
+    const parts = parsed.raw.split("/");
+    let current = cacheRoot;
+    for (const part of parts) {
+      const candidate = join5(current, part);
+      if (!existsSync3(candidate)) return void 0;
+      current = candidate;
+    }
+    return current;
+  }
+  const { name, version } = parsed;
+  const candidates = [
+    version ? join5(cacheRoot, `${name}@${version}`) : void 0,
+    join5(cacheRoot, `${name}@latest`),
+    join5(cacheRoot, name)
+  ].filter((c) => Boolean(c));
+  for (const candidate of candidates) {
+    if (existsSync3(candidate)) return candidate;
+  }
+  return void 0;
+}
+function resolvePackageMain(cacheEntry, pkgDir, name) {
+  const tryRequire = (baseDir) => {
+    try {
+      const req = createRequire2(join5(baseDir, "noop.js"));
+      return req.resolve(name);
+    } catch {
+      return void 0;
+    }
+  };
+  return tryRequire(pkgDir) ?? tryRequire(cacheEntry);
+}
+function packageRoot(cacheEntry, name) {
+  const direct = join5(cacheEntry, "node_modules", name);
+  if (existsSync3(direct)) return direct;
+  const nm = join5(cacheEntry, "node_modules");
+  if (!existsSync3(nm)) return void 0;
+  let entries;
+  try {
+    entries = readdirSync3(nm, { withFileTypes: true });
+  } catch {
+    return void 0;
+  }
+  for (const ent of entries) {
+    if (ent.name === ".bin") continue;
+    const full = join5(nm, ent.name);
+    let isDir = ent.isDirectory();
+    if (!isDir && ent.isSymbolicLink()) {
+      try {
+        isDir = statSync3(full).isDirectory();
+      } catch {
+        isDir = false;
+      }
+    }
+    if (isDir) return full;
+  }
+  return void 0;
+}
+function argsToJsonSchema(args) {
+  if (args == null || typeof args !== "object")
+    return { type: "object", properties: {}, required: [] };
+  const entries = Object.entries(args);
+  const allZod = entries.length > 0 && entries.every(([, v]) => isZodType(v));
+  if (allZod) {
+    try {
+      const zodLike = tool2.schema;
+      if (typeof zodLike.toJSONSchema === "function") {
+        const schema = zodLike.toJSONSchema(zodLike.object(args), {
+          io: "input"
+        });
+        return normalizeZodSchema(schema);
+      }
+    } catch {
+    }
+  }
+  const properties = {};
+  for (const [key, value] of entries) {
+    if (typeof value === "boolean" || typeof value === "object" && value !== null && !Array.isArray(value)) {
+      properties[key] = value;
+    }
+  }
+  return { type: "object", properties, required: Object.keys(properties) };
+}
+function isZodType(value) {
+  return typeof value === "object" && value !== null && "_zod" in value;
+}
+function normalizeZodSchema(schema) {
+  const out = { ...schema };
+  delete out["$schema"];
+  return out;
+}
+function extractToolMap(hooks) {
+  if (!hooks || typeof hooks !== "object") return void 0;
+  const tool3 = hooks.tool;
+  if (!tool3 || typeof tool3 !== "object") return void 0;
+  const out = {};
+  for (const [id, def] of Object.entries(tool3)) {
+    if (isPluginTool(def)) out[id] = def;
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function isPluginTool(value) {
+  return typeof value === "object" && value !== null && "args" in value && "description" in value && "execute" in value;
+}
+async function loadToolMap(modulePath, input) {
+  const mod = await import(pathToFileURL(modulePath).href);
+  const candidates = [mod["server"], mod["default"]];
+  for (const value of Object.values(mod)) {
+    if (typeof value === "function" && !candidates.includes(value)) {
+      candidates.push(value);
+    }
+  }
+  for (const candidate of candidates) {
+    if (typeof candidate !== "function") continue;
+    let hooks;
+    try {
+      hooks = await candidate(input);
+    } catch {
+      continue;
+    }
+    const tools = extractToolMap(hooks);
+    if (tools) return tools;
+  }
+  return void 0;
+}
+async function mirrorPluginTools(config, input, options) {
+  const failed = {};
+  const tools = [];
+  const seen = /* @__PURE__ */ new Set();
+  const specs = (config?.plugin ?? []).map(
+    (entry) => typeof entry === "string" ? entry : Array.isArray(entry) ? entry[0] : void 0
+  ).filter((s2) => typeof s2 === "string" && s2.length > 0);
+  const cacheRoot = options?.cacheRoot ?? opencodePackagesRoot(homedir4());
+  for (const spec of specs) {
+    if (SELF_SPECS.has(spec)) continue;
+    const parsed = parsePluginSpec(spec);
+    if (!parsed) {
+      failed[spec] = "unsupported spec format";
+      continue;
+    }
+    if (parsed.kind === "unsupported") {
+      failed[spec] = "unsupported spec format (URL tarball specs are not mirrored)";
+      continue;
+    }
+    let modulePath;
+    if (parsed.kind === "path") {
+      modulePath = parsed.path.startsWith("/") ? parsed.path : void 0;
+      if (!modulePath || !existsSync3(modulePath)) {
+        failed[spec] = "plugin file not found";
+        continue;
+      }
+    } else {
+      const entry = resolveCacheEntry(cacheRoot, parsed);
+      if (!entry) {
+        failed[spec] = "not found in opencode package cache";
+        continue;
+      }
+      const pkg = packageRoot(entry, parsed.name);
+      if (!pkg) {
+        failed[spec] = "package root not found in cache entry";
+        continue;
+      }
+      const resolved = resolvePackageMain(entry, pkg, parsed.name);
+      if (!resolved) {
+        failed[spec] = "package entry point not found";
+        continue;
+      }
+      modulePath = resolved;
+    }
+    if (!modulePath) {
+      failed[spec] = "plugin module path not resolved";
+      continue;
+    }
+    let toolMap;
+    try {
+      toolMap = await loadToolMap(modulePath, input);
+    } catch (error) {
+      failed[spec] = error instanceof Error ? error.message : String(error);
+      continue;
+    }
+    if (!toolMap) {
+      failed[spec] = "no tool map exported";
+      continue;
+    }
+    for (const [id, def] of Object.entries(toolMap)) {
+      if (seen.has(id)) continue;
+      if (options?.exclude?.some((p) => matchPattern(p, id))) continue;
+      if (options?.include && options.include.length > 0 && !options.include.some((p) => matchPattern(p, id))) {
+        continue;
+      }
+      seen.add(id);
+      tools.push({
+        id,
+        description: def.description,
+        parameters: argsToJsonSchema(def.args),
+        execute: def.execute,
+        sourcePlugin: spec
+      });
+    }
+  }
+  return { tools, failed };
+}
+function matchPattern(pattern, value) {
+  if (pattern === "*") return true;
+  if (!pattern.includes("*")) return pattern === value;
+  const regex = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+  return new RegExp(`^${regex}$`).test(value);
+}
+
+// src/plugin/plugin-tools-bridge.ts
+import { createServer } from "http";
+import { randomBytes } from "crypto";
+import { existsSync as existsSync4 } from "fs";
+import { fileURLToPath } from "url";
+import { execSync as execSync2 } from "child_process";
+function buildToolContext(args, askGate) {
+  const controller = new AbortController();
+  return {
+    sessionID: args.sessionID,
+    messageID: "cursor-plugin-tools",
+    agent: args.agent,
+    directory: args.directory,
+    worktree: args.directory,
+    abort: controller.signal,
+    metadata: () => {
+    },
+    ask: async (input) => {
+      if (!askGate) {
+        throw new Error(
+          "permission gate unavailable \u2014 refusing to run plugin tool without approval"
+        );
+      }
+      await askGate(input);
+    }
+  };
+}
+function resolvePluginToolsScript() {
+  const candidates = [
+    "./plugin-tools-mcp.js",
+    // importer is a chunk at dist root
+    "../sidecar/plugin-tools-mcp.js",
+    // importer is dist/plugin/index.js
+    "../sidecar/plugin-tools-mcp.mjs"
+    // importer is src/plugin/*.ts (dev/tests)
+  ];
+  for (const candidate of candidates) {
+    const path = fileURLToPath(new URL(candidate, import.meta.url));
+    if (existsSync4(path)) return path;
+  }
+  return void 0;
+}
+function execBasename(execPath) {
+  const base = execPath.split(/[/\\]/).pop() ?? "";
+  return base.replace(/\.exe$/i, "").toLowerCase();
+}
+function resolvePluginToolsNodeCommand(execPath = process.execPath, lookupNode) {
+  const name = execBasename(execPath);
+  if (name === "node" || name === "bun") return execPath;
+  if (lookupNode) return lookupNode() || void 0;
+  try {
+    const out = execSync2(
+      process.platform === "win32" ? "where node" : "command -v node",
+      {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"]
+      }
+    ).trim();
+    return out.split("\n")[0] || void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function startPluginToolsBridge(options) {
+  const scriptPath = resolvePluginToolsScript();
+  if (!scriptPath) {
+    pluginLog("warn", "plugin-tools MCP script not found; bridge disabled");
+    return { close: async () => {
+    } };
+  }
+  const nodePath = resolvePluginToolsNodeCommand();
+  if (!nodePath) {
+    pluginLog("warn", "plugin-tools MCP needs node on PATH; bridge disabled");
+    return { close: async () => {
+    } };
+  }
+  const token = randomBytes(24).toString("hex");
+  const toolById = new Map(options.tools.map((t) => [t.id, t]));
+  const server = createServer((req, res) => {
+    const send = (status, body) => {
+      res.writeHead(status, { "content-type": "application/json" });
+      res.end(JSON.stringify(body));
+    };
+    const auth = req.headers["authorization"];
+    if (auth !== `Bearer ${token}`) {
+      send(401, { error: "unauthorized" });
+      return;
+    }
+    if (req.method === "GET" && req.url === "/tools") {
+      send(200, {
+        tools: options.tools.map((t) => ({
+          id: t.id,
+          description: t.description,
+          parameters: t.parameters
+        }))
+      });
+      return;
+    }
+    if (req.method === "POST" && req.url === "/call") {
+      const MAX_BODY = 10 * 1024 * 1024;
+      let raw = "";
+      let size = 0;
+      req.on("data", (chunk) => {
+        size += chunk.length;
+        if (size > MAX_BODY) {
+          req.destroy();
+          return;
+        }
+        raw += chunk;
+      });
+      req.on("end", async () => {
+        if (size > MAX_BODY) return;
+        let body;
+        try {
+          body = JSON.parse(raw);
+        } catch {
+          send(400, { ok: false, error: "invalid JSON body" });
+          return;
+        }
+        const tool3 = body.id ? toolById.get(body.id) : void 0;
+        if (!tool3) {
+          send(404, { ok: false, error: `unknown tool: ${body.id}` });
+          return;
+        }
+        try {
+          const ctx = buildToolContext(
+            {
+              sessionID: options.sessionID ?? "cursor-plugin-tools",
+              agent: options.agent ?? "cursor",
+              directory: options.directory
+            },
+            options.askGate
+          );
+          const result = await tool3.execute(body.args ?? {}, ctx);
+          if (typeof result === "string") {
+            send(200, { ok: true, output: result });
+          } else {
+            send(200, {
+              ok: true,
+              title: result.title,
+              output: result.output,
+              metadata: result.metadata
+            });
+          }
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          send(200, { ok: false, error: message });
+        }
+      });
+      return;
+    }
+    send(404, { error: "not found" });
+  });
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => resolve());
+  });
+  const address = server.address();
+  const port = typeof address === "object" && address ? address.port : void 0;
+  if (!port) {
+    await new Promise((resolve) => server.close(() => resolve()));
+    pluginLog(
+      "warn",
+      "plugin-tools control server failed to bind; bridge disabled"
+    );
+    return { close: async () => {
+    } };
+  }
+  return {
+    mcpServer: {
+      type: "stdio",
+      command: nodePath,
+      args: [scriptPath],
+      env: {
+        OPENCODE_PLUGIN_TOOLS_PORT: String(port),
+        OPENCODE_PLUGIN_TOOLS_TOKEN: token
+      }
+    },
+    close: () => new Promise((resolve) => {
+      server.close(() => resolve());
+      server.closeAllConnections?.();
+    })
+  };
+}
+
 // src/plugin/index.ts
 function apiKeyFromAuth(auth) {
   return auth?.type === "api" ? auth.key : void 0;
 }
+async function fetchLiveSkills(client, query) {
+  const app = client.app;
+  if (typeof app?.skills === "function") {
+    return app.skills(query);
+  }
+  const inner = client._client;
+  return inner?.get?.({
+    url: "/skill",
+    ...query?.query ? { query: query.query } : {}
+  });
+}
 var CursorPlugin = async (input) => {
   const _latestVersionPromise = (async () => {
     try {
@@ -1499,6 +2177,16 @@ var CursorPlugin = async (input) => {
     setLogBridge({ client, directory });
   }
   let resolvedCwd = directory ?? process.cwd();
+  let pluginSkillSources;
+  try {
+    pluginSkillSources = resolvePluginSkillSources();
+  } catch (error) {
+    pluginLog("warn", "plugin skill source discovery failed", {
+      error: error instanceof Error ? error.message : String(error),
+      impact: "plugin-bundled skills unavailable to the Cursor agent"
+    });
+    pluginSkillSources = void 0;
+  }
   let forwardMcp = true;
   let userMcp = {};
   let autoCompaction = false;
@@ -1507,6 +2195,134 @@ var CursorPlugin = async (input) => {
   let lastSkillHash = "";
   let currentSkillsCatalogue = "";
   const warnedOAuth = /* @__PURE__ */ new Set();
+  let forwardPluginTools = true;
+  let pluginToolOptions;
+  let mirroredTools = [];
+  let pluginToolsBridge;
+  let lastPermissionKey = "";
+  let pluginToolsMcpServer;
+  let pluginToolsWarned = false;
+  async function syncPluginTools(config) {
+    if (!forwardPluginTools) return void 0;
+    try {
+      const result = await mirrorPluginTools(config, input, pluginToolOptions);
+      if (Object.keys(result.failed).length > 0 && !pluginToolsWarned) {
+        pluginToolsWarned = true;
+        pluginLog("warn", "plugin tool mirror skipped some plugins", result.failed);
+      }
+      if (result.tools.length === 0) {
+        if (!Array.isArray(config?.plugin) && pluginToolsMcpServer) {
+          return pluginToolsMcpServer;
+        }
+        await pluginToolsBridge?.close();
+        pluginToolsBridge = void 0;
+        mirroredTools = [];
+        return void 0;
+      }
+      const ids = result.tools.map((t) => t.id).sort().join("|");
+      const permKey = JSON.stringify(config?.permission ?? null);
+      const currentIds = mirroredTools.map((t) => t.id).sort().join("|");
+      if (ids !== currentIds || permKey !== lastPermissionKey || !pluginToolsBridge) {
+        await pluginToolsBridge?.close();
+        pluginToolsBridge = await startPluginToolsBridge({
+          tools: result.tools,
+          directory: input?.directory ?? process.cwd(),
+          askGate: makeAskGate(config?.permission)
+        });
+        mirroredTools = result.tools;
+        lastPermissionKey = permKey;
+      }
+      pluginToolsMcpServer = pluginToolsBridge?.mcpServer;
+      return pluginToolsMcpServer;
+    } catch (error) {
+      pluginLog("warn", "plugin tool mirror failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return void 0;
+    }
+  }
+  function makeAskGate(permissionConfig) {
+    return async (req) => {
+      const patterns = Array.isArray(req.patterns) && req.patterns.length > 0 ? req.patterns : ["*"];
+      let needsAsk = false;
+      for (const pattern of patterns) {
+        const action = evaluatePermissionAction(
+          permissionConfig,
+          req.permission,
+          pattern
+        );
+        if (action === "deny") {
+          throw new Error(
+            `permission denied for "${req.permission}" (pattern "${pattern}")`
+          );
+        }
+        if (action !== "allow") needsAsk = true;
+      }
+      if (!needsAsk) return;
+      throw new Error(
+        `permission for "${req.permission}" is set to "ask", which can't be prompted from the Cursor agent \u2014 set it to "allow" to use this tool`
+      );
+    };
+  }
+  function evaluatePermissionAction(permissionConfig, permission, pattern) {
+    const wildcardMatch2 = (pattern2, value) => {
+      if (pattern2 === "*") return true;
+      if (!pattern2.includes("*")) return pattern2 === value;
+      const regex = pattern2.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+      return new RegExp(`^${regex}$`).test(value);
+    };
+    const normalize = (value) => value === "allow" || value === "deny" || value === "ask" ? value : void 0;
+    const home = process.env["HOME"] || homedir5();
+    const expandPattern = (pattern2) => {
+      if (pattern2 === "~") return home;
+      if (pattern2.startsWith("~/")) return home + pattern2.slice(1);
+      if (pattern2.startsWith("$HOME/")) return home + pattern2.slice(5);
+      if (pattern2.startsWith("$HOME")) return home + pattern2.slice(5);
+      return pattern2;
+    };
+    const rules = [];
+    const pushRule = (perm, pattern2, action) => {
+      const normalized = normalize(action);
+      if (typeof perm !== "string" || normalized === void 0) return;
+      rules.push({
+        permission: perm,
+        pattern: typeof pattern2 === "string" ? expandPattern(pattern2) : "*",
+        action: normalized
+      });
+    };
+    if (Array.isArray(permissionConfig)) {
+      for (const rule of permissionConfig) {
+        if (rule && typeof rule === "object") {
+          const r = rule;
+          pushRule(r.permission, r.pattern, r.action);
+        }
+      }
+    } else if (permissionConfig && typeof permissionConfig === "object") {
+      for (const [perm, value] of Object.entries(
+        permissionConfig
+      )) {
+        const direct = normalize(value);
+        if (direct) {
+          pushRule(perm, "*", value);
+          continue;
+        }
+        if (value && typeof value === "object" && !Array.isArray(value)) {
+          for (const [pattern2, action] of Object.entries(
+            value
+          )) {
+            pushRule(perm, pattern2, action);
+          }
+        }
+      }
+    }
+    for (let i = rules.length - 1; i >= 0; i--) {
+      const rule = rules[i];
+      if (wildcardMatch2(rule.permission, permission) && wildcardMatch2(rule.pattern, pattern)) {
+        return rule.action;
+      }
+    }
+    return "ask";
+  }
   return {
     auth: {
       provider: PROVIDER_ID,
@@ -1537,7 +2353,13 @@ var CursorPlugin = async (input) => {
       autoCompaction = existingOptions["autoCompaction"] === true;
       forwardMcp = existingOptions["forwardMcp"] !== false;
       userMcp = existingOptions["mcpServers"] ?? {};
-      const mcpServers = forwardMcp ? { ...userMcp, ...translateMcpServers(config.mcp) } : userMcp;
+      const baseMcpServers = forwardMcp ? { ...userMcp, ...translateMcpServers(config.mcp) } : userMcp;
+      forwardPluginTools = existingOptions["forwardPluginTools"] !== false;
+      pluginToolOptions = existingOptions["pluginTools"];
+      const pluginToolsServer = await syncPluginTools(
+        config
+      );
+      const mcpServers = pluginToolsServer ? { ...baseMcpServers, "opencode-plugin-tools": pluginToolsServer } : baseMcpServers;
       const modelParamDefaults = {};
       for (const item of models) {
         const params = defaultModelParams(item);
@@ -1553,7 +2375,8 @@ var CursorPlugin = async (input) => {
           const resolved = resolveSkills(
             resolvedCwd,
             config,
-            skillFilterOptions
+            skillFilterOptions,
+            pluginSkillSources
           );
           writeSkillMirror(
             resolvedCwd,
@@ -1629,13 +2452,19 @@ var CursorPlugin = async (input) => {
             client.config.get(),
             client.mcp.status(query)
           ]);
-          const liveMcp = cfgRes?.data?.mcp;
+          const liveConfig = cfgRes?.data;
+          const liveMcp = liveConfig?.mcp;
           const status = statusRes?.data;
           if (status) {
-            output.options["mcpServers"] = {
+            const liveToolsServer = await syncPluginTools(liveConfig);
+            const liveServers = {
               ...userMcp,
               ...translateMcpServers(liveMcp, status)
             };
+            if (liveToolsServer) {
+              liveServers["opencode-plugin-tools"] = liveToolsServer;
+            }
+            output.options["mcpServers"] = liveServers;
             const unshareable = findUnshareableOAuthServers(liveMcp, status).filter(
               (name) => !warnedOAuth.has(name)
             );
@@ -1654,6 +2483,23 @@ var CursorPlugin = async (input) => {
           }
         } catch {
         }
+      } else if (client && forwardPluginTools && mirroredTools.length > 0) {
+        try {
+          const query = directory ? { query: { directory } } : void 0;
+          const cfgRes = await client.config.get(query);
+          const liveConfig = cfgRes?.data;
+          const liveToolsServer = await syncPluginTools(liveConfig);
+          const liveServers = {
+            ...userMcp
+          };
+          if (liveToolsServer) {
+            liveServers["opencode-plugin-tools"] = liveToolsServer;
+          }
+          if (Object.keys(liveServers).length > 0) {
+            output.options["mcpServers"] = liveServers;
+          }
+        } catch {
+        }
       }
       if (forwardSkills) {
         if (client) {
@@ -1661,10 +2507,18 @@ var CursorPlugin = async (input) => {
             const query = directory ? { query: { directory } } : void 0;
             const cfgRes = await client.config.get(query);
             const liveConfig = cfgRes?.data;
+            let liveSkills;
+            try {
+              let skillsRes;
+              skillsRes = await fetchLiveSkills(client, query);
+              liveSkills = skillsRes?.data;
+            } catch {
+            }
             const resolved = resolveSkills(
               resolvedCwd,
               liveConfig,
-              skillFilterOptions
+              skillFilterOptions,
+              { ...pluginSkillSources, liveSkills }
             );
             const hash = skillSetHash(resolved.skills);
             if (hash !== lastSkillHash) {
@@ -1748,7 +2602,7 @@ var CursorPlugin = async (input) => {
           const cachePath = PLUGIN_CACHE_PATH;
           const removeCommand = process.platform === "win32" ? `rmdir /s /q "${cachePath}"` : `rm -rf ${cachePath}`;
           try {
-            rmSync3(cachePath, { recursive: true, force: true });
+            rmSync4(cachePath, { recursive: true, force: true });
             clearVersionCache();
             return {
               title: "cursor plugin (updated)",
@@ -1797,6 +2651,8 @@ then restart opencode.`,
     dispose: async () => {
       removeSystemRule(resolvedCwd);
       removeSkillMirror(resolvedCwd);
+      await pluginToolsBridge?.close();
+      pluginToolsBridge = void 0;
       clearSubagentBridge();
       clearLogBridge();
     }