@jgordijn/opencode-remote-config 0.2.0 → 0.3.0

package/README.md

@@ -100,6 +100,7 @@ The plugin reads its configuration from a separate JSON file (not `opencode.json
 
 | Option | Type | Default | Description |
 |--------|------|---------|-------------|
+| `installMethod` | `"link"` or `"copy"` | `"link"` | How to install skills/plugins (symlinks or copies) |
 | `repositories` | Array | `[]` | List of repositories to sync |
 | `repositories[].url` | String | Required | Git URL, HTTPS URL, or `file://` path |
 | `repositories[].ref` | String | Default branch | Branch, tag, or commit SHA (git only) |
@@ -109,6 +110,50 @@ The plugin reads its configuration from a separate JSON file (not `opencode.json
 | `repositories[].plugins` | `"*"` or `{ include: [...] }` or `{ exclude: [...] }` | All plugins | Plugins to import |
 | `repositories[].instructions` | `"*"` or `{ include: [...] }` or `{ exclude: [...] }` | All instructions | Instructions from manifest to import |
 
+### Installation Method
+
+By default, skills and plugins are installed using symlinks. This is fast and efficient but may not work in all environments.
+
+#### Configuration
+
+```json
+{
+  "installMethod": "link"
+}
+```
+
+| Value | Description |
+|-------|-------------|
+| `link` | Create symlinks (default). Fast, but may not work in containers or on Windows. |
+| `copy` | Copy files. Works everywhere. Uses rsync if available for efficiency. |
+
+#### When to Use Copy Mode
+
+Use `"installMethod": "copy"` when:
+
+- **Dev Containers**: Symlinks break because paths differ between host and container
+- **Windows**: Symlinks require admin privileges or developer mode
+- **Network filesystems**: Some NFS/CIFS mounts don't support symlinks properly
+
+#### Example
+
+```json
+{
+  "$schema": "https://raw.githubusercontent.com/jgordijn/opencode-remote-config/main/remote-skills.schema.json",
+  "installMethod": "copy",
+  "repositories": [
+    {
+      "url": "git@github.com:your-org/shared-skills.git"
+    }
+  ]
+}
+```
+
+When using copy mode:
+- rsync is preferred if available (efficient incremental updates)
+- Falls back to Node.js file copy if rsync is unavailable
+- Files are kept in sync with the source repository
+
 ### Local Directories
 
 For development or local skill repositories, use `file://` URLs:

package/dist/index.js

@@ -7475,8 +7475,49 @@ var coerce = {
 var NEVER = INVALID;
 // src/config.ts
 import { existsSync, readFileSync } from "fs";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+
+// src/logging.ts
+import { appendFileSync, mkdirSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
+var DEFAULT_LOG_DIR = join(homedir(), ".cache", "opencode", "remote-config");
+var currentLogDir = DEFAULT_LOG_DIR;
+var dirEnsured = false;
+var LOG_PREFIX = "[remote-config]";
+function getLogFile() {
+  return join(currentLogDir, "plugin.log");
+}
+function timestamp() {
+  return new Date().toISOString();
+}
+function writeLog(level, message) {
+  try {
+    if (!dirEnsured) {
+      mkdirSync(currentLogDir, { recursive: true });
+      dirEnsured = true;
+    }
+    appendFileSync(getLogFile(), `${timestamp()} [${level}] ${LOG_PREFIX} ${message}
+`);
+  } catch {
+    dirEnsured = false;
+  }
+}
+function log(message) {
+  writeLog("INFO", message);
+}
+function logError(message) {
+  writeLog("ERROR", message);
+}
+function logDebug(message) {
+  writeLog("DEBUG", message);
+}
+function logWarn(message) {
+  writeLog("WARN", message);
+}
+
+// src/config.ts
 var CONFIG_FILENAME = "remote-config.json";
 var FilterConfigSchema = exports_external.union([
   exports_external.object({
@@ -7514,16 +7555,18 @@ function shouldImport(name, config) {
 var RemoteSkillsConfigSchema = exports_external.object({
   $schema: exports_external.string().optional(),
   repositories: exports_external.array(RepositoryConfigSchema).default([]),
-  sync: exports_external.enum(["blocking", "background"]).default("blocking")
+  sync: exports_external.enum(["blocking", "background"]).default("blocking"),
+  installMethod: exports_external.enum(["link", "copy"]).default("link")
 }).strict();
 var DEFAULT_CONFIG = {
   repositories: [],
-  sync: "blocking"
+  sync: "blocking",
+  installMethod: "link"
 };
 function getConfigPaths() {
   return [
-    join(process.cwd(), ".opencode", CONFIG_FILENAME),
-    join(homedir(), ".config", "opencode", CONFIG_FILENAME)
+    join2(process.cwd(), ".opencode", CONFIG_FILENAME),
+    join2(homedir2(), ".config", "opencode", CONFIG_FILENAME)
   ];
 }
 function loadConfig() {
@@ -7538,13 +7581,13 @@ function loadConfigWithLocation() {
         const parsed = JSON.parse(content);
         const result = RemoteSkillsConfigSchema.safeParse(parsed);
         if (!result.success) {
-          console.error(`[remote-config] Invalid configuration in ${configPath}:`, result.error.format());
+          logError(`Invalid configuration in ${configPath}: ${JSON.stringify(result.error.format())}`);
           continue;
         }
-        const configDir = join(configPath, "..");
+        const configDir = join2(configPath, "..");
         return { config: result.data, configDir };
       } catch (error) {
-        console.error(`[remote-config] Error reading ${configPath}:`, error);
+        logError(`Error reading ${configPath}: ${error}`);
         continue;
       }
     }
@@ -7611,11 +7654,11 @@ var CommandConfigSchema = exports_external.object({
 
 // src/instruction.ts
 import { existsSync as existsSync3 } from "fs";
-import { join as join3, normalize, resolve, sep } from "path";
+import { join as join4, normalize, resolve, sep } from "path";
 
 // src/manifest.ts
 import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
-import { join as join2, isAbsolute } from "path";
+import { join as join3, isAbsolute } from "path";
 var MANIFEST_FILENAME = "manifest.json";
 function containsPathTraversal(path) {
   return path.split("/").some((segment) => segment === ".." || segment === ".");
@@ -7629,7 +7672,7 @@ var ManifestSchema = exports_external.object({
   instructions: exports_external.array(instructionPathSchema).optional().default([])
 });
 function loadManifest(repoPath) {
-  const manifestPath = join2(repoPath, MANIFEST_FILENAME);
+  const manifestPath = join3(repoPath, MANIFEST_FILENAME);
   if (!existsSync2(manifestPath)) {
     return { status: "not-found" };
   }
@@ -7679,7 +7722,7 @@ function discoverInstructions(repoPath) {
       console.warn(`[remote-config] Skipping instruction with path traversal: ${instructionName}`);
       continue;
     }
-    const absolutePath = join3(repoPath, instructionName);
+    const absolutePath = join4(repoPath, instructionName);
     const resolvedPath = normalize(resolve(absolutePath));
     const resolvedRepoPath = normalize(resolve(repoPath));
     if (!resolvedPath.startsWith(resolvedRepoPath + sep)) {
@@ -7835,14 +7878,14 @@ async function discoverAgents(repoPath) {
   const findAgents = (dir, depth) => {
     if (depth > DISCOVERY_LIMITS.maxDepth) {
       if (!limitsWarned) {
-        console.warn(`[remote-config] Skipping deep directories (max depth: ${DISCOVERY_LIMITS.maxDepth})`);
+        logWarn(`Skipping deep directories (max depth: ${DISCOVERY_LIMITS.maxDepth})`);
         limitsWarned = true;
       }
       return;
     }
     if (filesProcessed >= DISCOVERY_LIMITS.maxFiles) {
       if (!limitsWarned) {
-        console.warn(`[remote-config] Stopping discovery (max files: ${DISCOVERY_LIMITS.maxFiles})`);
+        logWarn(`Stopping discovery (max files: ${DISCOVERY_LIMITS.maxFiles})`);
         limitsWarned = true;
       }
       return;
@@ -7860,7 +7903,7 @@ async function discoverAgents(repoPath) {
         try {
           const stats = fs.statSync(fullPath);
           if (stats.size > DISCOVERY_LIMITS.maxFileSize) {
-            console.warn(`[remote-config] Skipping large file (${Math.round(stats.size / 1024)}KB): ${entry.name}`);
+            logWarn(`Skipping large file (${Math.round(stats.size / 1024)}KB): ${entry.name}`);
             continue;
           }
           filesProcessed++;
@@ -7870,7 +7913,7 @@ async function discoverAgents(repoPath) {
             agents.push(parsed);
           }
         } catch (err) {
-          console.error(`[remote-config] Failed to parse agent ${fullPath}:`, err);
+          logError(`Failed to parse agent ${fullPath}: ${err}`);
         }
       }
     }
@@ -7896,7 +7939,7 @@ function parseAgentMarkdown(filePath, content, agentDir) {
     });
   } catch (err) {
     const relativeToRepo = path.relative(path.dirname(agentDir), filePath);
-    console.error(`[remote-config] Failed to parse frontmatter in ${relativeToRepo}:`, err);
+    logError(`Failed to parse frontmatter in ${relativeToRepo}: ${err}`);
     return null;
   }
   if (!md.data || Object.keys(md.data).length === 0) {
@@ -7906,7 +7949,7 @@ function parseAgentMarkdown(filePath, content, agentDir) {
   const agentName = relativePath.replace(/\.md$/i, "");
   if (!/^[a-zA-Z0-9_/-]+$/.test(agentName)) {
     const relativeToRepo = path.relative(path.dirname(agentDir), filePath);
-    console.warn(`[remote-config] Skipping agent with invalid name characters: ${relativeToRepo}`);
+    logWarn(`Skipping agent with invalid name characters: ${relativeToRepo}`);
     return null;
   }
   const rawConfig = {
@@ -7915,7 +7958,7 @@ function parseAgentMarkdown(filePath, content, agentDir) {
   };
   const result = AgentConfigSchema.safeParse(rawConfig);
   if (!result.success) {
-    console.error(`[remote-config] Invalid agent config in ${filePath}:`, result.error.format());
+    logError(`Invalid agent config in ${filePath}: ${JSON.stringify(result.error.format())}`);
     return null;
   }
   return {
@@ -7938,14 +7981,14 @@ async function discoverCommands(repoPath) {
   const findCommands = (dir, depth) => {
     if (depth > DISCOVERY_LIMITS.maxDepth) {
       if (!limitsWarned) {
-        console.warn(`[remote-config] Skipping deep directories (max depth: ${DISCOVERY_LIMITS.maxDepth})`);
+        logWarn(`Skipping deep directories (max depth: ${DISCOVERY_LIMITS.maxDepth})`);
         limitsWarned = true;
       }
       return;
     }
     if (filesProcessed >= DISCOVERY_LIMITS.maxFiles) {
       if (!limitsWarned) {
-        console.warn(`[remote-config] Stopping discovery (max files: ${DISCOVERY_LIMITS.maxFiles})`);
+        logWarn(`Stopping discovery (max files: ${DISCOVERY_LIMITS.maxFiles})`);
         limitsWarned = true;
       }
       return;
@@ -7963,7 +8006,7 @@ async function discoverCommands(repoPath) {
         try {
           const stats = fs.statSync(fullPath);
           if (stats.size > DISCOVERY_LIMITS.maxFileSize) {
-            console.warn(`[remote-config] Skipping large file (${Math.round(stats.size / 1024)}KB): ${entry.name}`);
+            logWarn(`Skipping large file (${Math.round(stats.size / 1024)}KB): ${entry.name}`);
             continue;
           }
           filesProcessed++;
@@ -7973,7 +8016,7 @@ async function discoverCommands(repoPath) {
             commands.push(parsed);
           }
         } catch (err) {
-          console.error(`[remote-config] Failed to parse command ${fullPath}:`, err);
+          logError(`Failed to parse command ${fullPath}: ${err}`);
         }
       }
     }
@@ -7999,14 +8042,14 @@ function parseCommandMarkdown(filePath, content, commandDir) {
     });
   } catch (err) {
     const relativeToRepo = path.relative(path.dirname(commandDir), filePath);
-    console.error(`[remote-config] Failed to parse frontmatter in ${relativeToRepo}:`, err);
+    logError(`Failed to parse frontmatter in ${relativeToRepo}: ${err}`);
     return null;
   }
   const relativePath = path.relative(commandDir, filePath).replace(/\\/g, "/");
   const commandName = relativePath.replace(/\.md$/i, "");
   if (!/^[a-zA-Z0-9_/-]+$/.test(commandName)) {
     const relativeToRepo = path.relative(path.dirname(commandDir), filePath);
-    console.warn(`[remote-config] Skipping command with invalid name characters: ${relativeToRepo}`);
+    logWarn(`Skipping command with invalid name characters: ${relativeToRepo}`);
     return null;
   }
   const rawConfig = {
@@ -8015,7 +8058,7 @@ function parseCommandMarkdown(filePath, content, commandDir) {
   };
   const result = CommandConfigSchema.safeParse(rawConfig);
   if (!result.success) {
-    console.error(`[remote-config] Invalid command config in ${filePath}:`, result.error.format());
+    logError(`Invalid command config in ${filePath}: ${JSON.stringify(result.error.format())}`);
     return null;
   }
   return {
@@ -8038,14 +8081,14 @@ async function discoverPlugins(repoPath, repoShortName) {
   const findPlugins = (dir, depth) => {
     if (depth > DISCOVERY_LIMITS.maxDepth) {
       if (!limitsWarned) {
-        console.warn(`[remote-config] Skipping deep directories (max depth: ${DISCOVERY_LIMITS.maxDepth})`);
+        logWarn(`Skipping deep directories (max depth: ${DISCOVERY_LIMITS.maxDepth})`);
         limitsWarned = true;
       }
       return;
     }
     if (filesProcessed >= DISCOVERY_LIMITS.maxFiles) {
       if (!limitsWarned) {
-        console.warn(`[remote-config] Stopping discovery (max files: ${DISCOVERY_LIMITS.maxFiles})`);
+        logWarn(`Stopping discovery (max files: ${DISCOVERY_LIMITS.maxFiles})`);
         limitsWarned = true;
       }
       return;
@@ -8063,7 +8106,7 @@ async function discoverPlugins(repoPath, repoShortName) {
         try {
           const stats = fs.statSync(fullPath);
           if (stats.size > DISCOVERY_LIMITS.maxFileSize) {
-            console.warn(`[remote-config] Skipping large file (${Math.round(stats.size / 1024)}KB): ${entry.name}`);
+            logWarn(`Skipping large file (${Math.round(stats.size / 1024)}KB): ${entry.name}`);
             continue;
           }
           filesProcessed++;
@@ -8072,7 +8115,7 @@ async function discoverPlugins(repoPath, repoShortName) {
           const pluginName = relativePath.slice(0, -ext.length).replace(/\//g, "-");
           if (!/^[a-zA-Z0-9_-]+$/.test(pluginName)) {
             const relativeToRepo = path.relative(path.dirname(pluginDir), fullPath);
-            console.warn(`[remote-config] Skipping plugin with invalid name characters: ${relativeToRepo}`);
+            logWarn(`Skipping plugin with invalid name characters: ${relativeToRepo}`);
             continue;
           }
           plugins.push({
@@ -8082,7 +8125,7 @@ async function discoverPlugins(repoPath, repoShortName) {
             extension: ext
           });
         } catch (err) {
-          console.error(`[remote-config] Failed to process plugin ${fullPath}:`, err);
+          logError(`Failed to process plugin ${fullPath}: ${err}`);
         }
       }
     }
@@ -8197,20 +8240,122 @@ async function syncRepositories(configs) {
   return results;
 }
 
-// src/symlinks.ts
-import * as path2 from "path";
-import * as fs2 from "fs";
+// src/install.ts
+import * as path3 from "path";
+import * as fs3 from "fs";
+var {$: $3 } = globalThis.Bun;
+
+// src/copy.ts
 var {$: $2 } = globalThis.Bun;
-var SKILL_BASE = path2.join(process.env.HOME || "~", ".config", "opencode", "skill");
-var PLUGINS_DIR = path2.join(SKILL_BASE, "_plugins");
-function getSymlinkPath(repoShortName, skillName) {
-  return path2.join(PLUGINS_DIR, repoShortName, skillName);
+import * as fs2 from "fs";
+import * as path2 from "path";
+var rsyncAvailable = null;
+async function detectRsync() {
+  if (rsyncAvailable !== null) {
+    return rsyncAvailable;
+  }
+  try {
+    const result = await $2`which rsync`.quiet();
+    rsyncAvailable = result.exitCode === 0;
+  } catch {
+    rsyncAvailable = false;
+  }
+  return rsyncAvailable;
+}
+async function copyWithRsync(source, target) {
+  fs2.mkdirSync(path2.dirname(target), { recursive: true });
+  const result = await $2`rsync -a --delete ${source}/ ${target}/`.quiet();
+  if (result.exitCode !== 0) {
+    throw new Error(`rsync failed: ${result.stderr.toString()}`);
+  }
+}
+function copyWithNodeFs(source, target) {
+  if (fs2.existsSync(target)) {
+    const stat = fs2.lstatSync(target);
+    if (stat.isSymbolicLink() || stat.isFile()) {
+      fs2.unlinkSync(target);
+    } else {
+      fs2.rmSync(target, { recursive: true, force: true });
+    }
+  }
+  fs2.mkdirSync(path2.dirname(target), { recursive: true });
+  fs2.cpSync(source, target, { recursive: true });
+}
+async function syncDirectory(source, target) {
+  let sourceStat;
+  try {
+    sourceStat = fs2.statSync(source);
+  } catch {
+    throw new Error(`Source does not exist: ${source}`);
+  }
+  if (!sourceStat.isDirectory()) {
+    throw new Error(`Source is not a directory: ${source}`);
+  }
+  const resolvedSource = path2.resolve(source);
+  const resolvedTarget = path2.resolve(target);
+  if (resolvedTarget.startsWith(resolvedSource + path2.sep)) {
+    throw new Error(`Target cannot be inside source: ${target} is inside ${source}`);
+  }
+  if (resolvedSource.startsWith(resolvedTarget + path2.sep)) {
+    throw new Error(`Source cannot be inside target: ${source} is inside ${target}`);
+  }
+  const hasRsync = await detectRsync();
+  if (hasRsync) {
+    try {
+      await copyWithRsync(source, target);
+      logDebug(`Copied ${source} \u2192 ${target} using rsync`);
+      return { method: "rsync" };
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      logError(`rsync failed, falling back to fs: ${errorMessage}`);
+    }
+  }
+  try {
+    copyWithNodeFs(source, target);
+    logDebug(`Copied ${source} \u2192 ${target} using fs.cpSync`);
+    return { method: "fs" };
+  } catch (err) {
+    try {
+      if (fs2.existsSync(target)) {
+        const stat = fs2.lstatSync(target);
+        if (stat.isSymbolicLink() || stat.isFile()) {
+          fs2.unlinkSync(target);
+        } else {
+          fs2.rmSync(target, { recursive: true, force: true });
+        }
+      }
+    } catch {}
+    throw err;
+  }
+}
+
+// src/install.ts
+var SKILL_BASE = path3.join(process.env.HOME || "~", ".config", "opencode", "skill");
+var PLUGINS_DIR = path3.join(SKILL_BASE, "_plugins");
+function getInstallPath(repoShortName, skillName) {
+  return path3.join(PLUGINS_DIR, repoShortName, skillName);
 }
 function ensurePluginsDir() {
-  fs2.mkdirSync(PLUGINS_DIR, { recursive: true });
+  fs3.mkdirSync(PLUGINS_DIR, { recursive: true });
+}
+function createSymlinkSync(sourcePath, targetPath) {
+  if (fs3.existsSync(targetPath)) {
+    const stats = fs3.lstatSync(targetPath);
+    if (stats.isSymbolicLink()) {
+      const existingTarget = fs3.readlinkSync(targetPath);
+      if (existingTarget === sourcePath) {
+        return { created: false };
+      }
+      fs3.unlinkSync(targetPath);
+    } else {
+      return { created: false, error: `Path exists and is not a symlink: ${targetPath}` };
+    }
+  }
+  fs3.symlinkSync(sourcePath, targetPath, "dir");
+  return { created: true };
 }
-function createSkillSymlink(skill, repoShortName) {
-  const targetPath = getSymlinkPath(repoShortName, skill.name);
+async function createSkillInstall(skill, repoShortName, installMethod = "link") {
+  const targetPath = getInstallPath(repoShortName, skill.name);
   const result = {
     skillName: skill.name,
     sourcePath: skill.path,
@@ -8218,78 +8363,81 @@ function createSkillSymlink(skill, repoShortName) {
     created: false
   };
   try {
-    fs2.mkdirSync(path2.dirname(targetPath), { recursive: true });
-    if (fs2.existsSync(targetPath)) {
-      const stats = fs2.lstatSync(targetPath);
-      if (stats.isSymbolicLink()) {
-        const existingTarget = fs2.readlinkSync(targetPath);
-        if (existingTarget === skill.path) {
-          return result;
-        }
-        fs2.unlinkSync(targetPath);
-      } else {
-        result.error = `Path exists and is not a symlink: ${targetPath}`;
-        return result;
+    fs3.mkdirSync(path3.dirname(targetPath), { recursive: true });
+    if (installMethod === "copy") {
+      await syncDirectory(skill.path, targetPath);
+      result.created = true;
+    } else {
+      const symlinkResult = createSymlinkSync(skill.path, targetPath);
+      result.created = symlinkResult.created;
+      if (symlinkResult.error) {
+        result.error = symlinkResult.error;
       }
     }
-    fs2.symlinkSync(skill.path, targetPath, "dir");
-    result.created = true;
   } catch (err) {
     result.error = err instanceof Error ? err.message : String(err);
   }
   return result;
 }
-function createSymlinksForRepo(syncResult) {
+async function createInstallsForRepo(syncResult, installMethod = "link") {
   ensurePluginsDir();
   const results = [];
   for (const skill of syncResult.skills) {
-    const result = createSkillSymlink(skill, syncResult.shortName);
+    const result = await createSkillInstall(skill, syncResult.shortName, installMethod);
     results.push(result);
   }
   return results;
 }
-function getExistingSymlinks() {
-  const symlinks = new Map;
-  if (!fs2.existsSync(PLUGINS_DIR)) {
-    return symlinks;
-  }
-  const scanDir = (dir, prefix = "") => {
-    const entries = fs2.readdirSync(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      if (entry.name.startsWith("."))
+function getExistingInstalls() {
+  const installs = new Map;
+  if (!fs3.existsSync(PLUGINS_DIR)) {
+    return installs;
+  }
+  const repoEntries = fs3.readdirSync(PLUGINS_DIR, { withFileTypes: true });
+  for (const repoEntry of repoEntries) {
+    if (repoEntry.name.startsWith(".") || !repoEntry.isDirectory())
+      continue;
+    const repoPath = path3.join(PLUGINS_DIR, repoEntry.name);
+    const skillEntries = fs3.readdirSync(repoPath, { withFileTypes: true });
+    for (const skillEntry of skillEntries) {
+      if (skillEntry.name.startsWith("."))
         continue;
-      const fullPath = path2.join(dir, entry.name);
-      const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
-      if (entry.isSymbolicLink()) {
-        const target = fs2.readlinkSync(fullPath);
-        symlinks.set(relativePath, target);
-      } else if (entry.isDirectory()) {
-        scanDir(fullPath, relativePath);
+      const fullPath = path3.join(repoPath, skillEntry.name);
+      const relativePath = `${repoEntry.name}/${skillEntry.name}`;
+      if (skillEntry.isSymbolicLink()) {
+        const target = fs3.readlinkSync(fullPath);
+        installs.set(relativePath, target);
+      } else if (skillEntry.isDirectory()) {
+        installs.set(relativePath, fullPath);
       }
     }
-  };
-  scanDir(PLUGINS_DIR);
-  return symlinks;
+  }
+  return installs;
 }
-function cleanupStaleSymlinks(currentSkills) {
+function cleanupStaleInstalls(currentSkills) {
   const result = {
     removed: [],
     errors: []
   };
-  const existingSymlinks = getExistingSymlinks();
-  for (const [relativePath] of existingSymlinks) {
+  const existingInstalls = getExistingInstalls();
+  for (const [relativePath] of existingInstalls) {
     if (!currentSkills.has(relativePath)) {
-      const fullPath = path2.join(PLUGINS_DIR, relativePath);
+      const fullPath = path3.join(PLUGINS_DIR, relativePath);
       try {
-        fs2.unlinkSync(fullPath);
+        const stats = fs3.lstatSync(fullPath);
+        if (stats.isSymbolicLink()) {
+          fs3.unlinkSync(fullPath);
+        } else if (stats.isDirectory()) {
+          fs3.rmSync(fullPath, { recursive: true, force: true });
+        }
         result.removed.push(relativePath);
-        let parentDir = path2.dirname(fullPath);
+        let parentDir = path3.dirname(fullPath);
         while (parentDir !== PLUGINS_DIR && parentDir.startsWith(PLUGINS_DIR)) {
           try {
-            const entries = fs2.readdirSync(parentDir);
+            const entries = fs3.readdirSync(parentDir);
             if (entries.length === 0) {
-              fs2.rmdirSync(parentDir);
-              parentDir = path2.dirname(parentDir);
+              fs3.rmdirSync(parentDir);
+              parentDir = path3.dirname(parentDir);
             } else {
               break;
             }
@@ -8305,16 +8453,16 @@ function cleanupStaleSymlinks(currentSkills) {
   return result;
 }
 function hasLocalConflict(skillName) {
-  const localSkillPath = path2.join(SKILL_BASE, skillName);
-  if (fs2.existsSync(localSkillPath)) {
-    const realPath = fs2.realpathSync(localSkillPath);
+  const localSkillPath = path3.join(SKILL_BASE, skillName);
+  if (fs3.existsSync(localSkillPath)) {
+    const realPath = fs3.realpathSync(localSkillPath);
     return !realPath.includes("_plugins");
   }
   return false;
 }
 async function findGitRoot(startPath) {
   try {
-    const result = await $2`git -C ${startPath} rev-parse --show-toplevel`.quiet();
+    const result = await $3`git -C ${startPath} rev-parse --show-toplevel`.quiet();
     if (result.exitCode === 0) {
       return result.stdout.toString().trim();
     }
@@ -8326,14 +8474,14 @@ async function ensureGitignore() {
   if (!gitRoot) {
     return { modified: false, gitRoot: null };
   }
-  const gitignorePath = path2.join(gitRoot, ".gitignore");
+  const gitignorePath = path3.join(gitRoot, ".gitignore");
   const pluginsEntry = "_plugins/";
-  const relativePath = path2.relative(gitRoot, PLUGINS_DIR);
+  const relativePath = path3.relative(gitRoot, PLUGINS_DIR);
   const gitignoreEntry = relativePath ? `${relativePath}/` : pluginsEntry;
   let content = "";
   let exists = false;
   try {
-    content = fs2.readFileSync(gitignorePath, "utf-8");
+    content = fs3.readFileSync(gitignorePath, "utf-8");
     exists = true;
   } catch {}
   const lines = content.split(`
@@ -8355,27 +8503,41 @@ ${gitignoreEntry}
 ` : `# OpenCode remote skills plugin
 ${gitignoreEntry}
 `;
-  fs2.writeFileSync(gitignorePath, newContent);
+  fs3.writeFileSync(gitignorePath, newContent);
   return { modified: true, gitRoot };
 }
 
-// src/plugin-symlinks.ts
-import * as fs3 from "fs";
-import * as path3 from "path";
-import { homedir as homedir2 } from "os";
-var DEFAULT_PLUGIN_DIR = path3.join(homedir2(), ".config", "opencode", "plugin");
+// src/plugin-install.ts
+import * as fs4 from "fs";
+import * as path4 from "path";
+import { homedir as homedir3 } from "os";
+var DEFAULT_PLUGIN_DIR = path4.join(homedir3(), ".config", "opencode", "plugin");
 var REMOTE_PREFIX = "_remote_";
+function removePathIfExists(targetPath) {
+  try {
+    const stats = fs4.lstatSync(targetPath);
+    if (stats.isDirectory()) {
+      fs4.rmSync(targetPath, { recursive: true });
+    } else {
+      fs4.unlinkSync(targetPath);
+    }
+  } catch (err) {
+    if (err.code !== "ENOENT") {
+      throw err;
+    }
+  }
+}
 function getPluginSymlinkName(plugin) {
   return `${REMOTE_PREFIX}${plugin.repoShortName}_${plugin.name}${plugin.extension}`;
 }
 function ensurePluginDir(pluginDir = DEFAULT_PLUGIN_DIR) {
-  if (!fs3.existsSync(pluginDir)) {
-    fs3.mkdirSync(pluginDir, { recursive: true });
+  if (!fs4.existsSync(pluginDir)) {
+    fs4.mkdirSync(pluginDir, { recursive: true });
   }
 }
-function createPluginSymlink(plugin, pluginDir = DEFAULT_PLUGIN_DIR) {
+function createPluginInstall(plugin, pluginDir = DEFAULT_PLUGIN_DIR, installMethod = "link") {
   const symlinkName = getPluginSymlinkName(plugin);
-  const symlinkPath = path3.join(pluginDir, symlinkName);
+  const symlinkPath = path4.join(pluginDir, symlinkName);
   const result = {
     pluginName: plugin.name,
     symlinkName,
@@ -8384,45 +8546,42 @@ function createPluginSymlink(plugin, pluginDir = DEFAULT_PLUGIN_DIR) {
   };
   try {
     ensurePluginDir(pluginDir);
-    try {
-      fs3.lstatSync(symlinkPath);
-      fs3.unlinkSync(symlinkPath);
-    } catch (err) {
-      if (err.code !== "ENOENT") {
-        throw err;
-      }
+    removePathIfExists(symlinkPath);
+    if (installMethod === "copy") {
+      fs4.cpSync(plugin.path, symlinkPath);
+    } else {
+      fs4.symlinkSync(plugin.path, symlinkPath);
     }
-    fs3.symlinkSync(plugin.path, symlinkPath);
   } catch (err) {
     result.error = err instanceof Error ? err.message : String(err);
   }
   return result;
 }
-function createPluginSymlinks(plugins, pluginDir = DEFAULT_PLUGIN_DIR) {
-  return plugins.map((p) => createPluginSymlink(p, pluginDir));
+function createPluginInstalls(plugins, pluginDir = DEFAULT_PLUGIN_DIR, installMethod = "link") {
+  return plugins.map((plugin) => createPluginInstall(plugin, pluginDir, installMethod));
 }
-function getRemotePluginSymlinks(pluginDir = DEFAULT_PLUGIN_DIR) {
-  if (!fs3.existsSync(pluginDir)) {
+function getRemotePluginInstalls(pluginDir = DEFAULT_PLUGIN_DIR) {
+  if (!fs4.existsSync(pluginDir)) {
     return [];
   }
   try {
-    const entries = fs3.readdirSync(pluginDir);
+    const entries = fs4.readdirSync(pluginDir);
     return entries.filter((name) => name.startsWith(REMOTE_PREFIX));
   } catch {
     return [];
   }
 }
-function cleanupStalePluginSymlinks(currentSymlinks, pluginDir = DEFAULT_PLUGIN_DIR) {
+function cleanupStalePluginInstalls(currentInstalls, pluginDir = DEFAULT_PLUGIN_DIR) {
   const result = {
     removed: [],
     errors: []
   };
-  const existing = getRemotePluginSymlinks(pluginDir);
+  const existing = getRemotePluginInstalls(pluginDir);
   for (const name of existing) {
-    if (!currentSymlinks.has(name)) {
-      const symlinkPath = path3.join(pluginDir, name);
+    if (!currentInstalls.has(name)) {
+      const installPath = path4.join(pluginDir, name);
       try {
-        fs3.unlinkSync(symlinkPath);
+        removePathIfExists(installPath);
         result.removed.push(name);
       } catch (err) {
         result.errors.push(`Failed to remove ${name}: ${err instanceof Error ? err.message : String(err)}`);
@@ -8433,33 +8592,7 @@ function cleanupStalePluginSymlinks(currentSymlinks, pluginDir = DEFAULT_PLUGIN_
 }
 
 // src/index.ts
-import { appendFileSync, mkdirSync as mkdirSync4 } from "fs";
-import { join as join7 } from "path";
-import { homedir as homedir3 } from "os";
-var LOG_PREFIX = "[remote-config]";
-var LOG_DIR = join7(homedir3(), ".cache", "opencode", "remote-config");
-var LOG_FILE = join7(LOG_DIR, "plugin.log");
 var initialized = false;
-function timestamp() {
-  return new Date().toISOString();
-}
-function writeLog(level, message) {
-  try {
-    mkdirSync4(LOG_DIR, { recursive: true });
-    appendFileSync(LOG_FILE, `${timestamp()} [${level}] ${message}
-`);
-  } catch {}
-}
-function log(message) {
-  const fullMessage = `${LOG_PREFIX} ${message}`;
-  console.log(fullMessage);
-  writeLog("INFO", message);
-}
-function logError(message) {
-  const fullMessage = `${LOG_PREFIX} ${message}`;
-  console.error(fullMessage);
-  writeLog("ERROR", message);
-}
 async function performSync(config) {
   if (config.repositories.length === 0) {
     return { results: [], skippedConflicts: [], totalSkills: 0, remoteAgents: new Map, remoteCommands: new Map, remoteInstructions: [], pluginsChanged: false, totalPlugins: 0 };
@@ -8474,30 +8607,30 @@ async function performSync(config) {
       logError(`\u2717 Failed to sync ${result.shortName}: ${result.error}`);
       continue;
     }
-    const skillsToLink = result.skills.filter((skill) => {
+    const skillsToInstall = result.skills.filter((skill) => {
       if (hasLocalConflict(skill.name)) {
         skippedConflicts.push(skill.name);
         return false;
       }
       return true;
     });
-    const filteredResult = { ...result, skills: skillsToLink };
-    const symlinkResults = createSymlinksForRepo(filteredResult);
-    for (const sr of symlinkResults) {
+    const filteredResult = { ...result, skills: skillsToInstall };
+    const installResults = await createInstallsForRepo(filteredResult, config.installMethod);
+    for (const sr of installResults) {
       if (!sr.error) {
         currentSkills.add(`${result.shortName}/${sr.skillName}`);
         totalSkills++;
       } else {
-        logError(`\u2717 Failed to create symlink for ${sr.skillName}: ${sr.error}`);
+        logError(`\u2717 Failed to install skill ${sr.skillName}: ${sr.error}`);
       }
     }
-    const skillCount = skillsToLink.length;
+    const skillCount = skillsToInstall.length;
     const status = result.updated ? "\u2713" : "\u2713";
     log(`${status} ${result.shortName} (${result.ref}) - ${skillCount} skills`);
   }
-  const cleanup = cleanupStaleSymlinks(currentSkills);
+  const cleanup = cleanupStaleInstalls(currentSkills);
   if (cleanup.removed.length > 0) {
-    log(`Cleaned up ${cleanup.removed.length} stale symlinks`);
+    log(`Cleaned up ${cleanup.removed.length} stale skill installs`);
   }
   for (const conflict of skippedConflicts) {
     log(`\u26A0 Conflict: '${conflict}' exists locally, skipping`);
@@ -8557,25 +8690,25 @@ async function performSync(config) {
       continue;
     allPlugins.push(...result.plugins);
   }
-  const existingPluginSymlinks = new Set(getRemotePluginSymlinks());
-  const newPluginSymlinks = new Set;
+  const existingPluginInstalls = new Set(getRemotePluginInstalls());
+  const newPluginInstalls = new Set;
   if (allPlugins.length > 0) {
-    const symlinkResults = createPluginSymlinks(allPlugins);
-    for (const sr of symlinkResults) {
+    const installResults = createPluginInstalls(allPlugins, undefined, config.installMethod);
+    for (const sr of installResults) {
       if (!sr.error) {
-        newPluginSymlinks.add(sr.symlinkName);
+        newPluginInstalls.add(sr.symlinkName);
       } else {
-        logError(`\u2717 Failed to create plugin symlink for ${sr.pluginName}: ${sr.error}`);
+        logError(`\u2717 Failed to install plugin ${sr.pluginName}: ${sr.error}`);
       }
     }
     log(`Discovered ${allPlugins.length} remote plugins`);
   }
-  const pluginCleanup = cleanupStalePluginSymlinks(newPluginSymlinks);
+  const pluginCleanup = cleanupStalePluginInstalls(newPluginInstalls);
   if (pluginCleanup.removed.length > 0) {
-    log(`Cleaned up ${pluginCleanup.removed.length} stale plugin symlinks`);
+    log(`Cleaned up ${pluginCleanup.removed.length} stale plugin installs`);
   }
-  const pluginsChanged = !setsEqual(existingPluginSymlinks, newPluginSymlinks);
-  const totalPlugins = newPluginSymlinks.size;
+  const pluginsChanged = !setsEqual(existingPluginInstalls, newPluginInstalls);
+  const totalPlugins = newPluginInstalls.size;
   return { results, skippedConflicts, totalSkills, remoteAgents, remoteCommands, remoteInstructions, pluginsChanged, totalPlugins };
 }
 function setsEqual(a, b) {
@@ -8596,6 +8729,11 @@ var RemoteSkillsPlugin = async (ctx) => {
   if (pluginConfig.repositories.length === 0) {
     return {};
   }
+  if (pluginConfig.installMethod === "copy") {
+    logDebug("Using copy mode for skill/plugin installation");
+  } else {
+    logDebug("Using symlink mode for skill/plugin installation");
+  }
   ensurePluginsDir();
   const gitignoreResult = await ensureGitignore();
   if (gitignoreResult.modified) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jgordijn/opencode-remote-config",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "OpenCode plugin to sync skills, agents and commands from Git repositories",
   "repository": {
     "type": "git",