Fix stale cursor-acp plugin loading and stabilize flaky cache tests

- respect opencode plugin array before initializing cursor-acp\n- disable plugin entrypoint when cursor-acp is removed from config\n- add plugin toggle helper + tests\n- stabilize flaky cache timing assertions in unit/integration tests\n- make tmp-path assertions cross-platform

Author: hawkff

src/plugin-entry.ts

@@ -1,8 +1,28 @@
 /**
- * Minimal entrypoint for the OpenCode plugin loader.
- * Exports only the CursorPlugin to avoid non-plugin exports being
- * treated as plugins by OpenCode.
+ * OpenCode-only entrypoint.
+ *
+ * When cursor-acp is removed from the `plugin` array in opencode.json,
+ * this entrypoint turns into a no-op so users can disable the plugin
+ * without deleting the symlink file.
  */
-import { CursorPlugin } from "./plugin.js";
+import type { Plugin } from "@opencode-ai/plugin";
+import { shouldEnableCursorPlugin } from "./plugin-toggle.js";
+import { createLogger } from "./utils/logger.js";
 
-export default CursorPlugin;
+const log = createLogger("plugin-entry");
+
+const CursorPluginEntry: Plugin = async (input) => {
+  const state = shouldEnableCursorPlugin();
+  if (!state.enabled) {
+    log.info("Plugin disabled in OpenCode config; skipping initialization", {
+      configPath: state.configPath,
+      reason: state.reason,
+    });
+    return {};
+  }
+
+  const mod = await import("./plugin.js");
+  return mod.CursorPlugin(input);
+};
+
+export default CursorPluginEntry;

src/plugin-toggle.ts

@@ -0,0 +1,67 @@
+import { existsSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { join, resolve } from "path";
+
+const CURSOR_PROVIDER_ID = "cursor-acp";
+
+type EnvLike = Record<string, string | undefined>;
+
+export function resolveOpenCodeConfigPath(env: EnvLike = process.env): string {
+  if (env.OPENCODE_CONFIG && env.OPENCODE_CONFIG.length > 0) {
+    return resolve(env.OPENCODE_CONFIG);
+  }
+
+  const configHome = env.XDG_CONFIG_HOME && env.XDG_CONFIG_HOME.length > 0
+    ? env.XDG_CONFIG_HOME
+    : join(homedir(), ".config");
+
+  return join(configHome, "opencode", "opencode.json");
+}
+
+export function isCursorPluginEnabledInConfig(config: unknown): boolean {
+  if (!config || typeof config !== "object") {
+    return true;
+  }
+
+  const configObject = config as { plugin?: unknown; provider?: unknown };
+
+  if (Array.isArray(configObject.plugin)) {
+    return configObject.plugin.some((entry) => entry === CURSOR_PROVIDER_ID);
+  }
+
+  return true;
+}
+
+export function shouldEnableCursorPlugin(env: EnvLike = process.env): {
+  enabled: boolean;
+  configPath: string;
+  reason: string;
+} {
+  const configPath = resolveOpenCodeConfigPath(env);
+
+  if (!existsSync(configPath)) {
+    return {
+      enabled: true,
+      configPath,
+      reason: "config_missing",
+    };
+  }
+
+  try {
+    const raw = readFileSync(configPath, "utf8");
+    const parsed = JSON.parse(raw);
+    const enabled = isCursorPluginEnabledInConfig(parsed);
+
+    return {
+      enabled,
+      configPath,
+      reason: enabled ? "enabled_in_plugin_array_or_legacy" : "disabled_in_plugin_array",
+    };
+  } catch {
+    return {
+      enabled: true,
+      configPath,
+      reason: "config_unreadable_or_invalid",
+    };
+  }
+}

tests/competitive/edge.test.ts

@@ -113,19 +113,18 @@ describe("Competitive Edge Analysis", () => {
 
     it("should have faster model discovery with caching", async () => {
       const service = new ModelDiscoveryService({ cacheTTL: 60000 });
+      let queryCalls = 0;
+      const originalQuery = (service as any).queryCursorAgent.bind(service);
+      (service as any).queryCursorAgent = async () => {
+        queryCalls += 1;
+        return originalQuery();
+      };
 
-      // First discovery
-      const start1 = Date.now();
-      await service.discover();
-      const time1 = Date.now() - start1;
-
-      // Second discovery (cached)
-      const start2 = Date.now();
-      await service.discover();
-      const time2 = Date.now() - start2;
+      const models1 = await service.discover();
+      const models2 = await service.discover();
 
-      // Cached should be significantly faster
-      expect(time2).toBeLessThan(time1);
+      expect(models2).toEqual(models1);
+      expect(queryCalls).toBe(1);
     });
 
     it("should handle concurrent tool executions efficiently", async () => {

tests/integration/comprehensive.test.ts

@@ -223,17 +223,18 @@ describe("Comprehensive End-to-End Integration", () => {
 
     it("should cache model discovery", async () => {
       const service = new ModelDiscoveryService({ cacheTTL: 5000 });
+      let queryCalls = 0;
+      const originalQuery = (service as any).queryCursorAgent.bind(service);
+      (service as any).queryCursorAgent = async () => {
+        queryCalls += 1;
+        return originalQuery();
+      };
 
-      const startTime1 = Date.now();
-      await service.discover();
-      const endTime1 = Date.now();
-
-      const startTime2 = Date.now();
-      await service.discover(); // Should be cached
-      const endTime2 = Date.now();
+      const models1 = await service.discover();
+      const models2 = await service.discover();
 
-      // Second call should be much faster (cached)
-      expect(endTime2 - startTime2).toBeLessThan(endTime1 - startTime1);
+      expect(models2).toEqual(models1);
+      expect(queryCalls).toBe(1);
     });
   });
 
@@ -328,4 +329,4 @@ describe("Comprehensive End-to-End Integration", () => {
       }
     });
   });
-});
+});

tests/tools/defaults.test.ts

@@ -75,14 +75,17 @@ describe("Default Tools", () => {
     const registry = new ToolRegistry();
     registerDefaultTools(registry);
     const executor = new LocalExecutor(registry);
+    const fs = await import("fs");
+    const os = await import("os");
+    const workdir = os.tmpdir();
 
     const result = await executeWithChain([executor], "bash", {
       cmd: "pwd",
-      workdir: "/tmp",
+      workdir,
     });
 
     expect(result.status).toBe("success");
-    expect(result.output?.trim()).toBe("/tmp");
+    expect(fs.realpathSync(result.output?.trim() ?? "")).toBe(fs.realpathSync(workdir));
   });
 
   it("should execute read tool", async () => {

tests/unit/plugin-toggle.test.ts

@@ -0,0 +1,63 @@
+/// <reference types="bun-types/test-globals" />
+
+import { mkdtempSync, rmSync, writeFileSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import {
+  isCursorPluginEnabledInConfig,
+  resolveOpenCodeConfigPath,
+  shouldEnableCursorPlugin,
+} from "../../src/plugin-toggle";
+
+describe("plugin toggle", () => {
+  it("enables plugin when plugin array includes cursor-acp", () => {
+    expect(isCursorPluginEnabledInConfig({ plugin: ["cursor-acp"] })).toBe(true);
+  });
+
+  it("disables plugin when plugin array excludes cursor-acp", () => {
+    expect(isCursorPluginEnabledInConfig({ plugin: ["other-plugin"] })).toBe(false);
+  });
+
+  it("keeps legacy behavior when plugin array is missing", () => {
+    expect(isCursorPluginEnabledInConfig({ provider: { "cursor-acp": {} } })).toBe(true);
+    expect(isCursorPluginEnabledInConfig({ provider: {} })).toBe(true);
+  });
+
+  it("resolves config from OPENCODE_CONFIG first", () => {
+    const customConfig = join(tmpdir(), "custom-opencode.json");
+    const xdgHome = join(tmpdir(), "xdg");
+    const path = resolveOpenCodeConfigPath({
+      OPENCODE_CONFIG: customConfig,
+      XDG_CONFIG_HOME: xdgHome,
+    });
+    expect(path).toBe(customConfig);
+  });
+
+  it("disables when config file exists and plugin array excludes cursor-acp", () => {
+    const dir = mkdtempSync(join(tmpdir(), "cursor-toggle-"));
+    const configPath = join(dir, "opencode.json");
+
+    try {
+      writeFileSync(configPath, JSON.stringify({ plugin: ["other-plugin"] }));
+      const state = shouldEnableCursorPlugin({ OPENCODE_CONFIG: configPath });
+      expect(state.enabled).toBe(false);
+      expect(state.reason).toBe("disabled_in_plugin_array");
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("stays enabled when config is invalid JSON", () => {
+    const dir = mkdtempSync(join(tmpdir(), "cursor-toggle-"));
+    const configPath = join(dir, "opencode.json");
+
+    try {
+      writeFileSync(configPath, "{not-json");
+      const state = shouldEnableCursorPlugin({ OPENCODE_CONFIG: configPath });
+      expect(state.enabled).toBe(true);
+      expect(state.reason).toBe("config_unreadable_or_invalid");
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});