cursor-opencode-provider 0.2.7 → 0.2.9

package/dist/context/paths.js

@@ -1,8 +1,33 @@
 import { createHash } from "node:crypto";
-import { existsSync, mkdirSync } from "node:fs";
+import { mkdirSync } from "node:fs";
 import { homedir } from "node:os";
 import path from "node:path";
+import { fileURLToPath } from "node:url";
 import { trace } from "../debug.js";
+/** Host-neutral bridge installed by OCP before an unchanged provider is loaded. */
+export const OPENCODE_PATH_BRIDGE = Symbol.for("opencode.compat.path-bridge");
+function pathBridge() {
+    const value = globalThis[OPENCODE_PATH_BRIDGE];
+    if (!value || typeof value !== "object")
+        return undefined;
+    const bridge = value;
+    return typeof bridge.projectConfigDirs === "function" && typeof bridge.globalConfigDirs === "function"
+        ? bridge
+        : undefined;
+}
+export function opencodeProjectConfigDirs(workspaceRoot) {
+    return pathBridge()?.projectConfigDirs(path.resolve(workspaceRoot)) ?? [
+        path.join(path.resolve(workspaceRoot), ".opencode"),
+    ];
+}
+export function opencodeGlobalConfigDirs() {
+    return pathBridge()?.globalConfigDirs() ?? [opencodeGlobalConfigDir()];
+}
+export function opencodeConfigFileNames() {
+    return pathBridge()?.configFileNames?.length
+        ? [...pathBridge().configFileNames]
+        : ["opencode.json", "opencode.jsonc"];
+}
 /** Explicit host cache root (e.g. Effect v2 `Path.cache`, or `createCursor({ cacheDir })`). */
 let hostCacheDirOverride;
 function resolveHome(env = process.env) {
@@ -13,11 +38,6 @@ function xdgCacheHome(env = process.env) {
         return env.XDG_CACHE_HOME;
     return path.join(resolveHome(env), ".cache");
 }
-function xdgConfigHome(env = process.env) {
-    if (env.XDG_CONFIG_HOME && env.XDG_CONFIG_HOME.length > 0)
-        return env.XDG_CONFIG_HOME;
-    return path.join(resolveHome(env), ".config");
-}
 /**
  * Pin the process-wide cache root. Highest precedence for {@link opencodeGlobalCacheDir}.
  * Use for host-injected `Path.cache` or an explicit `createCursor({ cacheDir })`.
@@ -30,23 +50,35 @@ export function getHostCacheDirOverride() {
 }
 /**
  * Resolve the host cache directory without an override.
- * Mirrors OCP HostProfile drafts: MiMo (`mimocode` / `$MIMOCODE_HOME`), Kilo (`kilo`),
- * then OpenCode (`opencode`). Prefer fork config dirs when several exist.
+ *
+ * Explicit host environment wins. Otherwise, an installed provider inherits
+ * the host-named cache containing its module. A source checkout or otherwise
+ * unidentifiable install defaults to OpenCode. Merely having another host's
+ * config directory installed is not evidence that it owns this process.
  */
-export function resolveHostCacheDir(env = process.env) {
+export function resolveHostCacheDir(env = process.env, moduleUrl = import.meta.url) {
     const mimoHome = env.MIMOCODE_HOME;
     if (mimoHome && mimoHome.length > 0) {
         return path.join(mimoHome, "cache");
     }
-    const configHome = xdgConfigHome(env);
     const cacheHome = xdgCacheHome(env);
     const kiloConfig = env.KILO_CONFIG_DIR;
-    // Prefer more specific fork dirs before OpenCode (same order as OCP detect).
-    if ((kiloConfig && kiloConfig.length > 0) || existsSync(path.join(configHome, "kilo"))) {
+    if (kiloConfig && kiloConfig.length > 0) {
         return path.join(cacheHome, "kilo");
     }
-    if (existsSync(path.join(configHome, "mimocode"))) {
-        return path.join(cacheHome, "mimocode");
+    let modulePath;
+    try {
+        modulePath = moduleUrl.startsWith("file:") ? fileURLToPath(moduleUrl) : path.resolve(moduleUrl);
+    }
+    catch {
+        modulePath = undefined;
+    }
+    if (modulePath) {
+        for (const host of ["mimocode", "kilo", "opencode"]) {
+            const root = path.resolve(cacheHome, host);
+            if (modulePath === root || modulePath.startsWith(`${root}${path.sep}`))
+                return root;
+        }
     }
     return path.join(cacheHome, "opencode");
 }
@@ -54,12 +86,18 @@ export function resolveHostCacheDir(env = process.env) {
  * Best-effort: if `@opencode-compat/profile` is installed, adopt `detect().profile.paths.cacheDir`
  * when the host is supported. No-op when OCP is absent or detection fails.
  */
-export async function adoptCompatHostCacheDir() {
+export async function adoptCompatHostCacheDir(detector) {
+    if (hostCacheDirOverride)
+        return hostCacheDirOverride;
     try {
-        const { detect } = await import("@opencode-compat/profile");
+        const detect = detector ?? (await import("@opencode-compat/profile")).detect;
         const result = detect();
         if (!result.supported || result.id === "unknown")
             return undefined;
+        if (!result.source || !["env", "binary", "package"].includes(result.source)) {
+            trace(`host-cache: ignored weak OCP detect host=${result.id} source=${result.source ?? "unknown"}`);
+            return undefined;
+        }
         const cacheDir = result.profile.paths.cacheDir;
         if (!cacheDir || cacheDir.length === 0)
             return undefined;
@@ -80,8 +118,8 @@ export function opencodeGlobalConfigDir() {
  *
  * Precedence:
  * 1. {@link setHostCacheDirOverride} / `createCursor({ cacheDir })` (host `Path.cache`)
- * 2. OCP `detect()` when {@link adoptCompatHostCacheDir} ran successfully
- * 3. Local host heuristic ({@link resolveHostCacheDir})
+ * 2. Strong OCP `detect()` identity when {@link adoptCompatHostCacheDir} ran successfully
+ * 3. Explicit host environment / provider install path ({@link resolveHostCacheDir})
  */
 export function opencodeGlobalCacheDir() {
     if (hostCacheDirOverride)

package/dist/context/plugins.js

@@ -1,6 +1,6 @@
 import { readdir, stat } from "node:fs/promises";
 import path from "node:path";
-import { opencodeGlobalConfigDir } from "./paths.js";
+import { opencodeGlobalConfigDirs, opencodeProjectConfigDirs } from "./paths.js";
 async function listLocalPlugins(dir) {
     try {
         await stat(dir);
@@ -34,17 +34,21 @@ export async function collectPlugins(workspaceRoot, config) {
         seen.add(id);
         out.push({ id, source: "npm" });
     }
-    for (const p of await listLocalPlugins(path.join(workspaceRoot, ".opencode", "plugins"))) {
-        if (seen.has(p.id))
-            continue;
-        seen.add(p.id);
-        out.push(p);
-    }
-    for (const p of await listLocalPlugins(path.join(opencodeGlobalConfigDir(), "plugins"))) {
-        if (seen.has(p.id))
-            continue;
-        seen.add(p.id);
-        out.push(p);
+    for (const configDir of opencodeProjectConfigDirs(workspaceRoot)) {
+        for (const p of await listLocalPlugins(path.join(configDir, "plugins"))) {
+            if (seen.has(p.id))
+                continue;
+            seen.add(p.id);
+            out.push(p);
+        }
+    }
+    for (const configDir of opencodeGlobalConfigDirs()) {
+        for (const p of await listLocalPlugins(path.join(configDir, "plugins"))) {
+            if (seen.has(p.id))
+                continue;
+            seen.add(p.id);
+            out.push(p);
+        }
     }
     return out;
 }

package/dist/context/rules.js

@@ -1,7 +1,7 @@
 import { readFile, readdir, stat } from "node:fs/promises";
 import { homedir } from "node:os";
 import path from "node:path";
-import { opencodeGlobalConfigDir, resolveHomeRelative } from "./paths.js";
+import { opencodeConfigFileNames, opencodeGlobalConfigDirs, opencodeProjectConfigDirs, resolveHomeRelative } from "./paths.js";
 async function exists(file) {
     try {
         await stat(file);
@@ -12,7 +12,7 @@ async function exists(file) {
     }
 }
 async function readJsonConfig(dir) {
-    for (const name of ["opencode.json", "opencode.jsonc"]) {
+    for (const name of opencodeConfigFileNames()) {
         const file = path.join(dir, name);
         if (!(await exists(file)))
             continue;
@@ -151,29 +151,30 @@ export async function fetchRemoteInstruction(url, timeoutMs = 5000) {
         clearTimeout(timer);
     }
 }
-export async function loadMergedConfig(workspaceRoot) {
-    const globalConfig = await readJsonConfig(opencodeGlobalConfigDir());
-    if (isProjectConfigDisabled()) {
-        return {
-            ...globalConfig,
-            instructions: [...(globalConfig.instructions ?? [])],
-            plugin: [...(globalConfig.plugin ?? [])],
-            plugins: [...(globalConfig.plugins ?? [])],
-            mcp: { ...(globalConfig.mcp ?? {}) },
-            permission: globalConfig.permission,
-        };
-    }
-    const projectConfig = await readJsonConfig(workspaceRoot);
+function mergeConfig(base, overlay) {
     return {
-        ...globalConfig,
-        ...projectConfig,
-        instructions: [...(globalConfig.instructions ?? []), ...(projectConfig.instructions ?? [])],
-        plugin: [...new Set([...(globalConfig.plugin ?? []), ...(projectConfig.plugin ?? [])])],
-        plugins: [...new Set([...(globalConfig.plugins ?? []), ...(projectConfig.plugins ?? [])])],
-        mcp: { ...(globalConfig.mcp ?? {}), ...(projectConfig.mcp ?? {}) },
-        permission: projectConfig.permission ?? globalConfig.permission,
+        ...base,
+        ...overlay,
+        instructions: [...(base.instructions ?? []), ...(overlay.instructions ?? [])],
+        plugin: [...new Set([...(base.plugin ?? []), ...(overlay.plugin ?? [])])],
+        plugins: [...new Set([...(base.plugins ?? []), ...(overlay.plugins ?? [])])],
+        mcp: { ...(base.mcp ?? {}), ...(overlay.mcp ?? {}) },
+        permission: overlay.permission ?? base.permission,
     };
 }
+export async function loadMergedConfig(workspaceRoot) {
+    const globalConfig = await readJsonConfig(opencodeGlobalConfigDirs()[0] ?? "");
+    if (isProjectConfigDisabled())
+        return mergeConfig({}, globalConfig);
+    // The bridge supplies native project config roots for an unchanged plugin:
+    // .opencode on OpenCode, .mimocode on MiMo, and .kilo/.kilocode on Kilo.
+    // Later roots have higher precedence, matching the host's native ordering.
+    let projectConfig = await readJsonConfig(workspaceRoot);
+    for (const configDir of opencodeProjectConfigDirs(workspaceRoot)) {
+        projectConfig = mergeConfig(projectConfig, await readJsonConfig(configDir));
+    }
+    return mergeConfig(globalConfig, projectConfig);
+}
 /**
  * Collect OpenCode instruction files.
  */
@@ -205,7 +206,9 @@ export async function collectRules(workspaceRoot) {
             }
         }
     }
-    await add(path.join(opencodeGlobalConfigDir(), "AGENTS.md"));
+    for (const globalDir of opencodeGlobalConfigDirs()) {
+        await add(path.join(globalDir, "AGENTS.md"));
+    }
     await add(path.join(homedir(), ".claude", "CLAUDE.md"));
     for (const raw of config.instructions ?? []) {
         if (raw.startsWith("http://") || raw.startsWith("https://")) {

package/dist/context/skills.js

@@ -1,7 +1,7 @@
 import { readdir, readFile, stat } from "node:fs/promises";
 import path from "node:path";
 import { homedir } from "node:os";
-import { opencodeGlobalConfigDir } from "./paths.js";
+import { opencodeGlobalConfigDirs, opencodeProjectConfigDirs } from "./paths.js";
 async function exists(p) {
     try {
         await stat(p);
@@ -94,8 +94,13 @@ async function walkAncestorsFor(dir, rel, stop, out) {
 export async function collectSkills(workspaceRoot, worktree) {
     const out = new Map();
     const home = homedir();
-    await walkAncestorsFor(workspaceRoot, path.join(".opencode", "skills"), worktree, out);
-    await scanSkillsRoot(path.join(opencodeGlobalConfigDir(), "skills"), out);
+    for (const projectDir of opencodeProjectConfigDirs(workspaceRoot)) {
+        const relative = path.relative(workspaceRoot, projectDir);
+        await walkAncestorsFor(workspaceRoot, path.join(relative, "skills"), worktree, out);
+    }
+    for (const globalDir of opencodeGlobalConfigDirs()) {
+        await scanSkillsRoot(path.join(globalDir, "skills"), out);
+    }
     await walkAncestorsFor(workspaceRoot, path.join(".claude", "skills"), worktree, out);
     await scanSkillsRoot(path.join(home, ".claude", "skills"), out);
     await walkAncestorsFor(workspaceRoot, path.join(".agents", "skills"), worktree, out);

package/dist/deadline.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Bound a complete async operation, not only fetch(). Response body readers can
+ * ignore abort signals, so Promise.race remains the authoritative deadline.
+ *
+ * Rejects with `timeoutError()` before aborting so callers observe the domain
+ * timeout error rather than a generic AbortError.
+ */
+export declare function withAbortDeadline<T>(timeoutMs: number, timeoutError: () => Error, run: (signal: AbortSignal) => Promise<T>): Promise<T>;

package/dist/deadline.js

@@ -0,0 +1,25 @@
+/**
+ * Bound a complete async operation, not only fetch(). Response body readers can
+ * ignore abort signals, so Promise.race remains the authoritative deadline.
+ *
+ * Rejects with `timeoutError()` before aborting so callers observe the domain
+ * timeout error rather than a generic AbortError.
+ */
+export async function withAbortDeadline(timeoutMs, timeoutError, run) {
+    const controller = new AbortController();
+    let timer;
+    const deadline = new Promise((_, reject) => {
+        timer = setTimeout(() => {
+            reject(timeoutError());
+            controller.abort();
+        }, timeoutMs);
+        timer.unref?.();
+    });
+    try {
+        return await Promise.race([run(controller.signal), deadline]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}