@jgordijn/opencode-remote-config 0.1.0 → 0.3.0

package/README.md

@@ -1,6 +1,6 @@
 # opencode-remote-config
 
-An OpenCode plugin that syncs skills and agents from Git repositories, making them available to OpenCode without polluting your local configuration.
+An OpenCode plugin that syncs skills, agents, commands, and instructions from Git repositories, making them available to OpenCode without polluting your local configuration.
 
 ## Features
 
@@ -8,8 +8,10 @@ An OpenCode plugin that syncs skills and agents from Git repositories, making th
 - **Local directories**: Use `file://` URLs for local directories (great for development)
 - **Skills import**: Import skill definitions from `skill/` directory
 - **Agents import**: Import agent definitions from `agent/` directory
+- **Commands import**: Import slash commands from `command/` directory
 - **Plugins import**: Import OpenCode hook plugins from `plugin/` directory
-- **Selective import**: Import all or specify which skills/agents/plugins to include
+- **Instructions import**: Import AGENTS.md instructions via manifest.json
+- **Selective import**: Use `include` or `exclude` filters for fine-grained control
 - **Ref pinning**: Pin to branch, tag, or commit SHA
 - **Priority handling**: User config > first repository > subsequent repositories
 - **Conflict handling**: Local definitions take precedence, warns on conflicts
@@ -71,9 +73,9 @@ bun install && bun run build
        {
          "url": "git@github.com:company/shared-skills.git",
          "ref": "main",
-         "skills": ["code-review", "kotlin-pro"],
-         "agents": ["code-reviewer", "specialized/db-expert"],
-         "plugins": ["notify", "utils-logger"]
+         "skills": { "include": ["code-review", "kotlin-pro"] },
+         "agents": { "include": ["code-reviewer", "specialized/db-expert"] },
+         "plugins": { "include": ["notify", "utils-logger"] }
        },
        {
          "url": "git@github.com:team/team-skills.git",
@@ -83,7 +85,7 @@ bun install && bun run build
    }
    ```
 
-3. **Restart OpenCode** to load the plugin.
+**Restart OpenCode** to load the plugin.
 
 ### Configuration
 
@@ -98,12 +100,59 @@ 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) |
-| `repositories[].skills` | Array or `"*"` | All skills | Specific skills to import |
-| `repositories[].agents` | Array or `"*"` | All agents | Specific agents to import |
-| `repositories[].plugins` | Array or `"*"` | All plugins | Specific plugins to import |
+| `repositories[].skills` | `"*"` or `{ include: [...] }` or `{ exclude: [...] }` | All skills | Skills to import |
+| `repositories[].agents` | `"*"` or `{ include: [...] }` or `{ exclude: [...] }` | All agents | Agents to import |
+| `repositories[].commands` | `"*"` or `{ include: [...] }` or `{ exclude: [...] }` | All commands | Slash commands to import |
+| `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
 
@@ -129,7 +178,7 @@ For development or local skill repositories, use `file://` URLs:
 Skills are cloned to a cache directory and symlinked into the OpenCode skill directory:
 
 ```
-~/.cache/opencode/remote-skills/repos/
+~/.cache/opencode/remote-config/repos/
 └── github.com-company-shared-skills/
     └── <full git clone>
 
@@ -200,20 +249,20 @@ Nested paths are converted to dashes: `plugin/foo/bar/baz.ts` becomes `foo-bar-b
 
 **Plugin changes require restart:** Unlike skills, plugins are loaded at OpenCode startup. When plugin changes are detected, you'll see:
 ```
-[remote-skills] Plugin changes detected. Restart OpenCode to apply.
+[remote-config] Plugin changes detected. Restart OpenCode to apply.
 ```
 
 ### Example Output
 
 ```
-[remote-skills] Syncing 2 repositories...
-[remote-skills] ✓ company/shared-skills (main) - 5 skills
-[remote-skills] ✓ team/team-skills (v1.2.0) - 3 skills
-[remote-skills] ⚠ Conflict: 'git-commit' exists locally, skipping
-[remote-skills] Discovered 4 remote agents
-[remote-skills] Discovered 2 remote plugins
-[remote-skills] 7 skills, 2 plugins available
-[remote-skills] Injected 4 remote agents into config
+[remote-config] Syncing 2 repositories...
+[remote-config] ✓ company/shared-skills (main) - 5 skills
+[remote-config] ✓ team/team-skills (v1.2.0) - 3 skills
+[remote-config] ⚠ Conflict: 'git-commit' exists locally, skipping
+[remote-config] Discovered 4 remote agents
+[remote-config] Discovered 2 remote plugins
+[remote-config] 7 skills, 2 plugins available
+[remote-config] Injected 4 remote agents into config
 ```
 
 ### Authentication
@@ -305,7 +354,7 @@ This section contains instructions for LLM agents helping users set up the openc
 **Problem: Updates not reflected**
 - In background mode, restart OpenCode to apply updates
 - Check that the `ref` (branch/tag) is correct
-- Try removing the cached repo: `rm -rf ~/.cache/opencode/remote-skills/repos/<repo-id>`
+- Try removing the cached repo: `rm -rf ~/.cache/opencode/remote-config/repos/<repo-id>`
 
 ### Repository Structure Requirements
 
@@ -412,8 +461,8 @@ import * as fs from "fs"
     {
       "url": "git@github.com:company/shared-skills.git",
       "ref": "main",
-      "skills": ["code-review", "testing"],
-      "agents": ["code-reviewer"]
+      "skills": { "include": ["code-review", "testing"] },
+      "agents": { "include": ["code-reviewer"] }
     },
     {
       "url": "git@github.com:team/team-skills.git",
@@ -424,13 +473,27 @@ import * as fs from "fs"
 }
 ```
 
-**Skills only (no agents):**
+**Skills only (exclude all agents):**
+```jsonc
+{
+  "repositories": [
+    {
+      "url": "git@github.com:company/skills.git",
+      "agents": { "include": ["__none__"] }  // Include a non-existent name to import no agents
+    }
+  ]
+}
+```
+
+Note: To effectively import nothing, include a name that doesn't exist in the repository. The include/exclude arrays require at least one item.
+
+**Exclude specific items:**
 ```jsonc
 {
   "repositories": [
     {
       "url": "git@github.com:company/skills.git",
-      "agents": []  // Empty array imports no agents
+      "skills": { "exclude": ["deprecated-skill", "experimental"] }
     }
   ]
 }
@@ -443,8 +506,8 @@ import * as fs from "fs"
     {
       "url": "git@github.com:company/shared-skills.git",
       "skills": "*",
-      "agents": ["code-reviewer"],
-      "plugins": ["notify", "analytics"]
+      "agents": { "include": ["code-reviewer"] },
+      "plugins": { "include": ["notify", "analytics"] }
     }
   ]
 }

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({
@@ -7496,21 +7537,36 @@ var RepositoryConfigSchema = exports_external.object({
   skills: ImportConfigSchema.optional(),
   agents: ImportConfigSchema.optional(),
   commands: ImportConfigSchema.optional(),
-  plugins: ImportConfigSchema.optional()
+  plugins: ImportConfigSchema.optional(),
+  instructions: ImportConfigSchema.optional()
 }).strict();
+function shouldImport(name, config) {
+  if (config === undefined || config === "*") {
+    return true;
+  }
+  if ("include" in config) {
+    return config.include.includes(name);
+  }
+  if ("exclude" in config) {
+    return !config.exclude.includes(name);
+  }
+  return true;
+}
 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() {
@@ -7525,13 +7581,13 @@ function loadConfigWithLocation() {
         const parsed = JSON.parse(content);
         const result = RemoteSkillsConfigSchema.safeParse(parsed);
         if (!result.success) {
-          console.error(`[remote-skills] 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-skills] Error reading ${configPath}:`, error);
+        logError(`Error reading ${configPath}: ${error}`);
         continue;
       }
     }
@@ -7596,8 +7652,95 @@ var CommandConfigSchema = exports_external.object({
   subtask: exports_external.boolean().optional()
 }).passthrough();
 
+// src/instruction.ts
+import { existsSync as existsSync3 } from "fs";
+import { join as join4, normalize, resolve, sep } from "path";
+
+// src/manifest.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { join as join3, isAbsolute } from "path";
+var MANIFEST_FILENAME = "manifest.json";
+function containsPathTraversal(path) {
+  return path.split("/").some((segment) => segment === ".." || segment === ".");
+}
+var instructionPathSchema = exports_external.string().transform((path) => path.trim()).transform((path) => path.startsWith("./") ? path.slice(2) : path).refine((path) => path.length > 0, { message: "Instruction path must not be empty" }).refine((path) => path.endsWith(".md"), { message: "Instruction path must end with .md" }).refine((path) => {
+  const filename = path.includes("/") ? path.split("/").pop() : path;
+  return filename.length > 3;
+}, { message: "Instruction path must have a filename before .md extension" }).refine((path) => !isAbsolute(path), { message: "Instruction path must be relative (absolute paths not allowed)" }).refine((path) => !path.includes("\\"), { message: "Instruction path must use forward slashes (POSIX-style)" }).refine((path) => !containsPathTraversal(path), { message: "Instruction path must not contain path traversal (. or ..)" }).refine((path) => !path.includes("//"), { message: "Instruction path must not contain consecutive slashes" }).refine((path) => !path.endsWith("/"), { message: "Instruction path must not have a trailing slash" });
+var ManifestSchema = exports_external.object({
+  $schema: exports_external.string().optional(),
+  instructions: exports_external.array(instructionPathSchema).optional().default([])
+});
+function loadManifest(repoPath) {
+  const manifestPath = join3(repoPath, MANIFEST_FILENAME);
+  if (!existsSync2(manifestPath)) {
+    return { status: "not-found" };
+  }
+  try {
+    const content = readFileSync2(manifestPath, "utf-8");
+    const parsed = JSON.parse(content);
+    const result = ManifestSchema.safeParse(parsed);
+    if (!result.success) {
+      const errorMessage = JSON.stringify(result.error.format());
+      console.warn(`[remote-config] Invalid manifest.json in ${repoPath}:`, result.error.format());
+      return { status: "invalid", error: errorMessage };
+    }
+    return { status: "found", manifest: result.data };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.warn(`[remote-config] Error reading manifest.json in ${repoPath}:`, error);
+    return { status: "invalid", error: errorMessage };
+  }
+}
+
+// src/instruction.ts
+var INSTRUCTION_LIMITS = {
+  maxInstructions: 100,
+  maxPathLength: 500
+};
+function discoverInstructions(repoPath) {
+  const result = loadManifest(repoPath);
+  if (result.status === "not-found") {
+    return [];
+  }
+  if (result.status === "invalid") {
+    console.warn(`[remote-config] Skipping instructions for ${repoPath}: invalid manifest.json`);
+    return [];
+  }
+  const manifest = result.manifest;
+  const instructions = [];
+  const instructionsToProcess = manifest.instructions.slice(0, INSTRUCTION_LIMITS.maxInstructions);
+  if (manifest.instructions.length > INSTRUCTION_LIMITS.maxInstructions) {
+    console.warn(`[remote-config] Limiting instructions to ${INSTRUCTION_LIMITS.maxInstructions} (manifest has ${manifest.instructions.length})`);
+  }
+  for (const instructionName of instructionsToProcess) {
+    if (instructionName.length > INSTRUCTION_LIMITS.maxPathLength) {
+      console.warn(`[remote-config] Skipping instruction with path exceeding ${INSTRUCTION_LIMITS.maxPathLength} chars`);
+      continue;
+    }
+    if (containsPathTraversal(instructionName)) {
+      console.warn(`[remote-config] Skipping instruction with path traversal: ${instructionName}`);
+      continue;
+    }
+    const absolutePath = join4(repoPath, instructionName);
+    const resolvedPath = normalize(resolve(absolutePath));
+    const resolvedRepoPath = normalize(resolve(repoPath));
+    if (!resolvedPath.startsWith(resolvedRepoPath + sep)) {
+      console.warn(`[remote-config] Skipping instruction outside repository: ${instructionName}`);
+      continue;
+    }
+    if (existsSync3(absolutePath)) {
+      instructions.push({
+        name: instructionName,
+        path: absolutePath
+      });
+    }
+  }
+  return instructions;
+}
+
 // src/git.ts
-var CACHE_BASE = path.join(process.env.HOME || "~", ".cache", "opencode", "remote-skills", "repos");
+var CACHE_BASE = path.join(process.env.HOME || "~", ".cache", "opencode", "remote-config", "repos");
 function isFileUrl(url) {
   return url.startsWith("file://");
 }
@@ -7617,7 +7760,10 @@ async function cloneRepo(url, repoPath) {
   const result = await $`git clone ${url} ${repoPath}`.quiet();
   if (result.exitCode !== 0) {
     const stderr = result.stderr.toString().trim();
-    throw new Error(`git clone failed: ${stderr || `exit code ${result.exitCode}`}`);
+    const stdout = result.stdout.toString().trim();
+    const output = [stderr, stdout].filter(Boolean).join(`
+`) || `exit code ${result.exitCode}`;
+    throw new Error(`git clone failed: ${output}`);
   }
 }
 async function fetchAndCheckout(repoPath, ref) {
@@ -7626,20 +7772,29 @@ async function fetchAndCheckout(repoPath, ref) {
   const fetchResult = await $`git -C ${repoPath} fetch --all --prune`.quiet();
   if (fetchResult.exitCode !== 0) {
     const stderr = fetchResult.stderr.toString().trim();
-    throw new Error(`git fetch failed: ${stderr || `exit code ${fetchResult.exitCode}`}`);
+    const stdout = fetchResult.stdout.toString().trim();
+    const output = [stderr, stdout].filter(Boolean).join(`
+`) || `exit code ${fetchResult.exitCode}`;
+    throw new Error(`git fetch failed: ${output}`);
   }
   if (ref) {
     const checkoutResult = await $`git -C ${repoPath} checkout ${ref}`.quiet();
     if (checkoutResult.exitCode !== 0) {
       const stderr = checkoutResult.stderr.toString().trim();
-      throw new Error(`git checkout ${ref} failed: ${stderr || `exit code ${checkoutResult.exitCode}`}`);
+      const stdout = checkoutResult.stdout.toString().trim();
+      const output = [stderr, stdout].filter(Boolean).join(`
+`) || `exit code ${checkoutResult.exitCode}`;
+      throw new Error(`git checkout ${ref} failed: ${output}`);
     }
     const isBranch = await $`git -C ${repoPath} symbolic-ref -q HEAD`.quiet();
     if (isBranch.exitCode === 0) {
       const pullResult = await $`git -C ${repoPath} pull --ff-only`.quiet();
       if (pullResult.exitCode !== 0) {
         const stderr = pullResult.stderr.toString().trim();
-        throw new Error(`git pull failed: ${stderr || `exit code ${pullResult.exitCode}`}`);
+        const stdout = pullResult.stdout.toString().trim();
+        const output = [stderr, stdout].filter(Boolean).join(`
+`) || `exit code ${pullResult.exitCode}`;
+        throw new Error(`git pull failed: ${output}`);
       }
     }
   } else {
@@ -7723,14 +7878,14 @@ async function discoverAgents(repoPath) {
   const findAgents = (dir, depth) => {
     if (depth > DISCOVERY_LIMITS.maxDepth) {
       if (!limitsWarned) {
-        console.warn(`[remote-skills] 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-skills] Stopping discovery (max files: ${DISCOVERY_LIMITS.maxFiles})`);
+        logWarn(`Stopping discovery (max files: ${DISCOVERY_LIMITS.maxFiles})`);
         limitsWarned = true;
       }
       return;
@@ -7748,7 +7903,7 @@ async function discoverAgents(repoPath) {
         try {
           const stats = fs.statSync(fullPath);
           if (stats.size > DISCOVERY_LIMITS.maxFileSize) {
-            console.warn(`[remote-skills] 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++;
@@ -7758,7 +7913,7 @@ async function discoverAgents(repoPath) {
             agents.push(parsed);
           }
         } catch (err) {
-          console.error(`[remote-skills] Failed to parse agent ${fullPath}:`, err);
+          logError(`Failed to parse agent ${fullPath}: ${err}`);
         }
       }
     }
@@ -7784,7 +7939,7 @@ function parseAgentMarkdown(filePath, content, agentDir) {
     });
   } catch (err) {
     const relativeToRepo = path.relative(path.dirname(agentDir), filePath);
-    console.error(`[remote-skills] 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) {
@@ -7794,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-skills] Skipping agent with invalid name characters: ${relativeToRepo}`);
+    logWarn(`Skipping agent with invalid name characters: ${relativeToRepo}`);
     return null;
   }
   const rawConfig = {
@@ -7803,7 +7958,7 @@ function parseAgentMarkdown(filePath, content, agentDir) {
   };
   const result = AgentConfigSchema.safeParse(rawConfig);
   if (!result.success) {
-    console.error(`[remote-skills] Invalid agent config in ${filePath}:`, result.error.format());
+    logError(`Invalid agent config in ${filePath}: ${JSON.stringify(result.error.format())}`);
     return null;
   }
   return {
@@ -7826,14 +7981,14 @@ async function discoverCommands(repoPath) {
   const findCommands = (dir, depth) => {
     if (depth > DISCOVERY_LIMITS.maxDepth) {
       if (!limitsWarned) {
-        console.warn(`[remote-skills] 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-skills] Stopping discovery (max files: ${DISCOVERY_LIMITS.maxFiles})`);
+        logWarn(`Stopping discovery (max files: ${DISCOVERY_LIMITS.maxFiles})`);
         limitsWarned = true;
       }
       return;
@@ -7851,7 +8006,7 @@ async function discoverCommands(repoPath) {
         try {
           const stats = fs.statSync(fullPath);
           if (stats.size > DISCOVERY_LIMITS.maxFileSize) {
-            console.warn(`[remote-skills] 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++;
@@ -7861,7 +8016,7 @@ async function discoverCommands(repoPath) {
             commands.push(parsed);
           }
         } catch (err) {
-          console.error(`[remote-skills] Failed to parse command ${fullPath}:`, err);
+          logError(`Failed to parse command ${fullPath}: ${err}`);
         }
       }
     }
@@ -7887,14 +8042,14 @@ function parseCommandMarkdown(filePath, content, commandDir) {
     });
   } catch (err) {
     const relativeToRepo = path.relative(path.dirname(commandDir), filePath);
-    console.error(`[remote-skills] 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-skills] Skipping command with invalid name characters: ${relativeToRepo}`);
+    logWarn(`Skipping command with invalid name characters: ${relativeToRepo}`);
     return null;
   }
   const rawConfig = {
@@ -7903,7 +8058,7 @@ function parseCommandMarkdown(filePath, content, commandDir) {
   };
   const result = CommandConfigSchema.safeParse(rawConfig);
   if (!result.success) {
-    console.error(`[remote-skills] Invalid command config in ${filePath}:`, result.error.format());
+    logError(`Invalid command config in ${filePath}: ${JSON.stringify(result.error.format())}`);
     return null;
   }
   return {
@@ -7926,14 +8081,14 @@ async function discoverPlugins(repoPath, repoShortName) {
   const findPlugins = (dir, depth) => {
     if (depth > DISCOVERY_LIMITS.maxDepth) {
       if (!limitsWarned) {
-        console.warn(`[remote-skills] 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-skills] Stopping discovery (max files: ${DISCOVERY_LIMITS.maxFiles})`);
+        logWarn(`Stopping discovery (max files: ${DISCOVERY_LIMITS.maxFiles})`);
         limitsWarned = true;
       }
       return;
@@ -7951,7 +8106,7 @@ async function discoverPlugins(repoPath, repoShortName) {
         try {
           const stats = fs.statSync(fullPath);
           if (stats.size > DISCOVERY_LIMITS.maxFileSize) {
-            console.warn(`[remote-skills] 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++;
@@ -7960,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-skills] Skipping plugin with invalid name characters: ${relativeToRepo}`);
+            logWarn(`Skipping plugin with invalid name characters: ${relativeToRepo}`);
             continue;
           }
           plugins.push({
@@ -7970,7 +8125,7 @@ async function discoverPlugins(repoPath, repoShortName) {
             extension: ext
           });
         } catch (err) {
-          console.error(`[remote-skills] Failed to process plugin ${fullPath}:`, err);
+          logError(`Failed to process plugin ${fullPath}: ${err}`);
         }
       }
     }
@@ -7993,31 +8148,22 @@ async function syncLocalDirectory(config) {
   let agents = [];
   let commands = [];
   let plugins = [];
+  let instructions = [];
   if (!fs.existsSync(localPath)) {
     error = `Local directory not found: ${localPath}`;
   } else if (!fs.statSync(localPath).isDirectory()) {
     error = `Not a directory: ${localPath}`;
   } else {
     skills = await discoverSkills(localPath);
-    if (config.skills && config.skills !== "*" && Array.isArray(config.skills)) {
-      const requestedSkills = new Set(config.skills);
-      skills = skills.filter((s) => requestedSkills.has(s.name));
-    }
+    skills = skills.filter((s) => shouldImport(s.name, config.skills));
     agents = await discoverAgents(localPath);
-    if (config.agents && config.agents !== "*" && Array.isArray(config.agents)) {
-      const requestedAgents = new Set(config.agents);
-      agents = agents.filter((a) => requestedAgents.has(a.name));
-    }
+    agents = agents.filter((a) => shouldImport(a.name, config.agents));
     commands = await discoverCommands(localPath);
-    if (config.commands && config.commands !== "*" && Array.isArray(config.commands)) {
-      const requestedCommands = new Set(config.commands);
-      commands = commands.filter((c) => requestedCommands.has(c.name));
-    }
+    commands = commands.filter((c) => shouldImport(c.name, config.commands));
     plugins = await discoverPlugins(localPath, shortName);
-    if (config.plugins && config.plugins !== "*" && Array.isArray(config.plugins)) {
-      const requestedPlugins = new Set(config.plugins);
-      plugins = plugins.filter((p) => requestedPlugins.has(p.name));
-    }
+    plugins = plugins.filter((p) => shouldImport(p.name, config.plugins));
+    instructions = discoverInstructions(localPath);
+    instructions = instructions.filter((i) => shouldImport(i.name, config.instructions));
   }
   return {
     repoId,
@@ -8028,6 +8174,7 @@ async function syncLocalDirectory(config) {
     agents,
     commands,
     plugins,
+    instructions,
     updated: false,
     error
   };
@@ -8055,29 +8202,20 @@ async function syncGitRepository(config) {
   let agents = [];
   let commands = [];
   let plugins = [];
+  let instructions = [];
   let currentRef = config.ref || "default";
   if (isCloned(repoPath)) {
     skills = await discoverSkills(repoPath);
     currentRef = await getCurrentRef(repoPath);
-    if (config.skills && config.skills !== "*" && Array.isArray(config.skills)) {
-      const requestedSkills = new Set(config.skills);
-      skills = skills.filter((s) => requestedSkills.has(s.name));
-    }
+    skills = skills.filter((s) => shouldImport(s.name, config.skills));
     agents = await discoverAgents(repoPath);
-    if (config.agents && config.agents !== "*" && Array.isArray(config.agents)) {
-      const requestedAgents = new Set(config.agents);
-      agents = agents.filter((a) => requestedAgents.has(a.name));
-    }
+    agents = agents.filter((a) => shouldImport(a.name, config.agents));
     commands = await discoverCommands(repoPath);
-    if (config.commands && config.commands !== "*" && Array.isArray(config.commands)) {
-      const requestedCommands = new Set(config.commands);
-      commands = commands.filter((c) => requestedCommands.has(c.name));
-    }
+    commands = commands.filter((c) => shouldImport(c.name, config.commands));
     plugins = await discoverPlugins(repoPath, shortName);
-    if (config.plugins && config.plugins !== "*" && Array.isArray(config.plugins)) {
-      const requestedPlugins = new Set(config.plugins);
-      plugins = plugins.filter((p) => requestedPlugins.has(p.name));
-    }
+    plugins = plugins.filter((p) => shouldImport(p.name, config.plugins));
+    instructions = discoverInstructions(repoPath);
+    instructions = instructions.filter((i) => shouldImport(i.name, config.instructions));
   }
   return {
     repoId,
@@ -8088,6 +8226,7 @@ async function syncGitRepository(config) {
     agents,
     commands,
     plugins,
+    instructions,
     updated,
     error
   };
@@ -8101,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,
@@ -8122,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;
             }
@@ -8209,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();
     }
@@ -8230,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(`
@@ -8259,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,
@@ -8288,40 +8546,42 @@ function createPluginSymlink(plugin, pluginDir = DEFAULT_PLUGIN_DIR) {
   };
   try {
     ensurePluginDir(pluginDir);
-    if (fs3.existsSync(symlinkPath)) {
-      fs3.unlinkSync(symlinkPath);
+    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)}`);
@@ -8332,36 +8592,10 @@ function cleanupStalePluginSymlinks(currentSymlinks, pluginDir = DEFAULT_PLUGIN_
 }
 
 // src/index.ts
-import { appendFileSync, mkdirSync as mkdirSync4 } from "fs";
-import { join as join5 } from "path";
-import { homedir as homedir3 } from "os";
-var LOG_PREFIX = "[remote-skills]";
-var LOG_DIR = join5(homedir3(), ".cache", "opencode", "remote-skills");
-var LOG_FILE = join5(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, pluginsChanged: false, totalPlugins: 0 };
+    return { results: [], skippedConflicts: [], totalSkills: 0, remoteAgents: new Map, remoteCommands: new Map, remoteInstructions: [], pluginsChanged: false, totalPlugins: 0 };
   }
   log(`Syncing ${config.repositories.length} repositories...`);
   const results = await syncRepositories(config.repositories);
@@ -8373,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`);
@@ -8439,32 +8673,43 @@ async function performSync(config) {
   if (remoteCommands.size > 0) {
     log(`Discovered ${remoteCommands.size} remote commands`);
   }
+  const remoteInstructions = [];
+  for (const result of results) {
+    if (result.error)
+      continue;
+    for (const instruction of result.instructions) {
+      remoteInstructions.push(instruction.path);
+    }
+  }
+  if (remoteInstructions.length > 0) {
+    log(`Discovered ${remoteInstructions.length} remote instructions`);
+  }
   const allPlugins = [];
   for (const result of results) {
     if (result.error)
       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;
-  return { results, skippedConflicts, totalSkills, remoteAgents, remoteCommands, pluginsChanged, totalPlugins };
+  const pluginsChanged = !setsEqual(existingPluginInstalls, newPluginInstalls);
+  const totalPlugins = newPluginInstalls.size;
+  return { results, skippedConflicts, totalSkills, remoteAgents, remoteCommands, remoteInstructions, pluginsChanged, totalPlugins };
 }
 function setsEqual(a, b) {
   if (a.size !== b.size)
@@ -8484,12 +8729,17 @@ 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) {
     log(`Added _plugins/ to .gitignore at ${gitignoreResult.gitRoot}`);
   }
-  const { totalSkills, skippedConflicts, remoteAgents, remoteCommands, pluginsChanged, totalPlugins } = await performSync(pluginConfig);
+  const { totalSkills, skippedConflicts, remoteAgents, remoteCommands, remoteInstructions, pluginsChanged, totalPlugins } = await performSync(pluginConfig);
   if (pluginsChanged) {
     log("\u26A0 Plugin changes detected. Restart OpenCode to apply.");
   }
@@ -8499,9 +8749,11 @@ var RemoteSkillsPlugin = async (ctx) => {
     parts.push(`${totalSkills} skills`);
   if (totalPlugins > 0)
     parts.push(`${totalPlugins} plugins`);
+  if (remoteInstructions.length > 0)
+    parts.push(`${remoteInstructions.length} instructions`);
   let message;
   if (parts.length === 0) {
-    message = "No remote skills or plugins found";
+    message = "No remote config found";
   } else {
     message = `${parts.join(", ")} available`;
     if (skippedCount > 0) {
@@ -8547,6 +8799,19 @@ var RemoteSkillsPlugin = async (ctx) => {
           }
         }
       }
+      if (remoteInstructions.length > 0) {
+        if (config.instructions !== undefined && typeof config.instructions !== "string" && !Array.isArray(config.instructions)) {
+          logError("config.instructions is not a string or array, skipping instruction injection");
+        } else if (Array.isArray(config.instructions) && !config.instructions.every((x) => typeof x === "string")) {
+          logError("config.instructions contains non-string elements, skipping instruction injection");
+        } else {
+          if (!Array.isArray(config.instructions)) {
+            config.instructions = config.instructions ? [config.instructions] : [];
+          }
+          config.instructions.push(...remoteInstructions);
+          log(`Appended ${remoteInstructions.length} remote instructions`);
+        }
+      }
     },
     event: async ({ event }) => {}
   };

package/package.json

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