Skip to content

A desktop coding agent with free access to frontier models.

TypeScript
4.7 KB
Raw Blame
import { homedir } from "node:os";
import { join, relative } from "node:path";
import { readdir } from "node:fs/promises";
import type { PluginItem, ServerConfig } from "./types.js";
import { readJsoncFile } from "./jsonc.js";
import { opencodeConfigPath, projectPluginsDir } from "./workspace-files.js";
import { exists } from "./utils.js";
import { validatePluginSpec } from "./validators.js";
import {
  readEffectiveRuntimeOpencodeConfig,
  readGlobalRuntimeOpencodeConfig,
  runtimePluginList,
  writeGlobalRuntimeOpencodeConfig,
} from "./runtime-opencode-config-store.js";

export function normalizePluginSpec(spec: string): string {
  const trimmed = spec.trim();
  if (trimmed.startsWith("file:") || trimmed.startsWith("http:") || trimmed.startsWith("https:") || trimmed.startsWith("git:")) {
    return trimmed;
  }
  if (trimmed.startsWith("/")) {
    return trimmed;
  }
  if (trimmed.startsWith("@")) {
    const atIndex = trimmed.indexOf("@", 1);
    return atIndex > 0 ? trimmed.slice(0, atIndex) : trimmed;
  }
  const atIndex = trimmed.indexOf("@");
  return atIndex > 0 ? trimmed.slice(0, atIndex) : trimmed;
}

function pluginListFromConfig(config: Record<string, unknown>): string[] {
  const plugin = config.plugin;
  if (typeof plugin === "string") return [plugin];
  if (Array.isArray(plugin)) return plugin.filter((item) => typeof item === "string") as string[];
  return [];
}

async function listPluginFiles(dir: string, scope: "project" | "global", workspaceRoot?: string): Promise<PluginItem[]> {
  if (!(await exists(dir))) return [];
  const entries = await readdir(dir, { withFileTypes: true });
  const items: PluginItem[] = [];
  for (const entry of entries) {
    if (!entry.isFile()) continue;
    if (!entry.name.endsWith(".js") && !entry.name.endsWith(".ts")) continue;
    const absolutePath = join(dir, entry.name);
    const relativePath = workspaceRoot ? relative(workspaceRoot, absolutePath) : absolutePath;
    items.push({
      spec: `file://${absolutePath}`,
      source: scope === "project" ? "dir.project" : "dir.global",
      scope,
      path: relativePath,
    });
  }
  return items;
}

export async function listPlugins(serverConfig: ServerConfig, workspaceId: string, workspaceRoot: string, includeGlobal: boolean): Promise<{ items: PluginItem[]; loadOrder: string[] }> {
  const { data: config } = await readJsoncFile(opencodeConfigPath(workspaceRoot), {} as Record<string, unknown>, { allowInvalid: true });
  const pluginSpecs = pluginListFromConfig(config);
  const runtimeSpecs = runtimePluginList(await readEffectiveRuntimeOpencodeConfig(serverConfig, workspaceId));
  const items: PluginItem[] = pluginSpecs.map((spec) => ({
    spec,
    source: "config",
    scope: "project",
  }));

  const seen = new Set(pluginSpecs.map((spec) => normalizePluginSpec(spec)));
  for (const spec of runtimeSpecs) {
    const normalized = normalizePluginSpec(spec);
    if (seen.has(normalized)) continue;
    seen.add(normalized);
    items.push({
      spec,
      source: "config",
      scope: "project",
    });
  }

  const projectDir = projectPluginsDir(workspaceRoot);
  items.push(...(await listPluginFiles(projectDir, "project", workspaceRoot)));

  if (includeGlobal) {
    const globalDir = join(homedir(), ".config", "opencode", "plugins");
    items.push(...(await listPluginFiles(globalDir, "global")));
  }

  return {
    items,
    loadOrder: ["config.global", "config.project", "dir.global", "dir.project"],
  };
}

// Runtime-managed plugins are engine-global: the injected engine config file
// is rendered from the ENGINE_GLOBAL row only, so plugin writes target it.
export async function addPlugin(serverConfig: ServerConfig, spec: string): Promise<boolean> {
  validatePluginSpec(spec);
  const runtimeConfig = await readGlobalRuntimeOpencodeConfig(serverConfig);
  const pluginSpecs = runtimePluginList(runtimeConfig);
  const normalized = normalizePluginSpec(spec);
  const existing = pluginSpecs.find((item) => normalizePluginSpec(item) === normalized);
  if (existing) return false;
  pluginSpecs.push(spec);
  await writeGlobalRuntimeOpencodeConfig(serverConfig, (current) => ({ ...current, plugin: pluginSpecs }));
  return true;
}

export async function removePlugin(serverConfig: ServerConfig, name: string): Promise<boolean> {
  const runtimeConfig = await readGlobalRuntimeOpencodeConfig(serverConfig);
  const pluginSpecs = runtimePluginList(runtimeConfig);
  const normalized = normalizePluginSpec(name);
  const filtered = pluginSpecs.filter((item) => normalizePluginSpec(item) !== normalized);
  if (filtered.length === pluginSpecs.length) return false;
  await writeGlobalRuntimeOpencodeConfig(serverConfig, (current) => ({ ...current, plugin: filtered }));
  return true;
}